1 // This may look like C code, but it is really -*- C++ -*- 2 // 3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003 4 // Copyright Dirk Lemstra 2013-2016 5 // 6 // Definition of Image, the representation of a single image in Magick++ 7 // 8 9 #if !defined(Magick_Image_header) 10 #define Magick_Image_header 11 12 #include "Magick++/Include.h" 13 #include <string> 14 #include <list> 15 #include "Magick++/Blob.h" 16 #include "Magick++/Color.h" 17 #include "Magick++/Drawable.h" 18 #include "Magick++/Exception.h" 19 #include "Magick++/Geometry.h" 20 #include "Magick++/Statistic.h" 21 #include "Magick++/TypeMetric.h" 22 23 namespace Magick 24 { 25 // Forward declarations 26 class Options; 27 class ImageRef; 28 29 extern MagickPPExport const char *borderGeometryDefault; 30 extern MagickPPExport const char *frameGeometryDefault; 31 extern MagickPPExport const char *raiseGeometryDefault; 32 33 // Compare two Image objects regardless of LHS/RHS 34 // Image sizes and signatures are used as basis of comparison 35 MagickPPExport int operator == 36 (const Magick::Image &left_,const Magick::Image &right_); 37 MagickPPExport int operator != 38 (const Magick::Image &left_,const Magick::Image &right_); 39 MagickPPExport int operator > 40 (const Magick::Image &left_,const Magick::Image &right_); 41 MagickPPExport int operator < 42 (const Magick::Image &left_,const Magick::Image &right_); 43 MagickPPExport int operator >= 44 (const Magick::Image &left_,const Magick::Image &right_); 45 MagickPPExport int operator <= 46 (const Magick::Image &left_,const Magick::Image &right_); 47 48 // 49 // Image is the representation of an image. In reality, it actually 50 // a handle object which contains a pointer to a shared reference 51 // object (ImageRef). As such, this object is extremely space efficient. 52 // 53 class MagickPPExport Image 54 { 55 public: 56 57 // Default constructor 58 Image(void); 59 60 // Construct Image from in-memory BLOB 61 Image(const Blob &blob_); 62 63 // Construct Image of specified size from in-memory BLOB 64 Image(const Blob &blob_,const Geometry &size_); 65 66 // Construct Image of specified size and depth from in-memory BLOB 67 Image(const Blob &blob_,const Geometry &size_,const size_t depth_); 68 69 // Construct Image of specified size, depth, and format from 70 // in-memory BLOB 71 Image(const Blob &blob_,const Geometry &size_,const size_t depth_, 72 const std::string &magick_); 73 74 // Construct Image of specified size, and format from in-memory BLOB 75 Image(const Blob &blob_,const Geometry &size_,const std::string &magick_); 76 77 // Construct a blank image canvas of specified size and color 78 Image(const Geometry &size_,const Color &color_); 79 80 // Copy constructor 81 Image(const Image &image_); 82 83 // Copy constructor to copy part of the image 84 Image(const Image &image_,const Geometry &geometry_); 85 86 // Construct an image based on an array of raw pixels, of 87 // specified type and mapping, in memory 88 Image(const size_t width_,const size_t height_,const std::string &map_, 89 const StorageType type_,const void *pixels_); 90 91 // Construct from image file or image specification 92 Image(const std::string &imageSpec_); 93 94 // Destructor 95 virtual ~Image(); 96 97 // Assignment operator 98 Image& operator=(const Image &image_); 99 100 // Join images into a single multi-image file 101 void adjoin(const bool flag_); 102 bool adjoin(void) const; 103 104 // Image supports transparency (alpha channel) 105 void alpha(const bool alphaFlag_); 106 bool alpha(void) const; 107 108 // Transparent color 109 void alphaColor(const Color &alphaColor_); 110 Color alphaColor(void) const; 111 112 // Time in 1/100ths of a second which must expire before 113 // displaying the next image in an animated sequence. 114 void animationDelay(const size_t delay_); 115 size_t animationDelay(void) const; 116 117 // Lessen (or intensify) when adding noise to an image. 118 void attenuate(const double attenuate_); 119 120 // Number of iterations to loop an animation (e.g. Netscape loop 121 // extension) for. 122 void animationIterations(const size_t iterations_); 123 size_t animationIterations(void) const; 124 125 // Image background color 126 void backgroundColor(const Color &color_); 127 Color backgroundColor(void) const; 128 129 // Name of texture image to tile onto the image background 130 void backgroundTexture(const std::string &backgroundTexture_); 131 std::string backgroundTexture(void) const; 132 133 // Base image width (before transformations) 134 size_t baseColumns(void) const; 135 136 // Base image filename (before transformations) 137 std::string baseFilename(void) const; 138 139 // Base image height (before transformations) 140 size_t baseRows(void) const; 141 142 // Use black point compensation. 143 void blackPointCompensation(const bool flag_); 144 bool blackPointCompensation(void) const; 145 146 // Image border color 147 void borderColor(const Color &color_); 148 Color borderColor(void) const; 149 150 // Return smallest bounding box enclosing non-border pixels. The 151 // current fuzz value is used when discriminating between pixels. 152 // This is the crop bounding box used by crop(Geometry(0,0)); 153 Geometry boundingBox(void) const; 154 155 // Text bounding-box base color (default none) 156 void boxColor(const Color &boxColor_); 157 Color boxColor(void) const; 158 159 // Set or obtain modulus channel depth 160 void channelDepth(const ChannelType channel_,const size_t depth_); 161 size_t channelDepth(const ChannelType channel_); 162 163 // Returns the number of channels in this image. 164 size_t channels() const; 165 166 // Image class (DirectClass or PseudoClass) 167 // NOTE: setting a DirectClass image to PseudoClass will result in 168 // the loss of color information if the number of colors in the 169 // image is greater than the maximum palette size (either 256 or 170 // 65536 entries depending on the value of MAGICKCORE_QUANTUM_DEPTH when 171 // ImageMagick was built). 172 void classType(const ClassType class_); 173 ClassType classType(void) const; 174 175 // Colors within this distance are considered equal 176 void colorFuzz(const double fuzz_); 177 double colorFuzz(void) const; 178 179 // Colormap size (number of colormap entries) 180 void colorMapSize(const size_t entries_); 181 size_t colorMapSize(void) const; 182 183 // Image Color Space 184 void colorSpace(const ColorspaceType colorSpace_); 185 ColorspaceType colorSpace(void) const; 186 187 void colorSpaceType(const ColorspaceType colorSpace_); 188 ColorspaceType colorSpaceType(void) const; 189 190 // Image width 191 size_t columns(void) const; 192 193 // Comment image (add comment string to image) 194 void comment(const std::string &comment_); 195 std::string comment(void) const; 196 197 // Composition operator to be used when composition is implicitly 198 // used (such as for image flattening). 199 void compose(const CompositeOperator compose_); 200 CompositeOperator compose(void) const; 201 202 // Compression type 203 void compressType(const CompressionType compressType_); 204 CompressionType compressType(void) const; 205 206 // Enable printing of debug messages from ImageMagick 207 void debug(const bool flag_); 208 bool debug(void) const; 209 210 // Vertical and horizontal resolution in pixels of the image 211 void density(const Point &density_); 212 Point density(void) const; 213 214 // Image depth (bits allocated to red/green/blue components) 215 void depth(const size_t depth_); 216 size_t depth(void) const; 217 218 // Tile names from within an image montage 219 std::string directory(void) const; 220 221 // Endianness (little like Intel or big like SPARC) for image 222 // formats which support endian-specific options. 223 void endian(const EndianType endian_); 224 EndianType endian(void) const; 225 226 // Exif profile (BLOB) 227 void exifProfile(const Blob &exifProfile_); 228 Blob exifProfile(void) const; 229 230 // Image file name 231 void fileName(const std::string &fileName_); 232 std::string fileName(void) const; 233 234 // Number of bytes of the image on disk 235 MagickSizeType fileSize(void) const; 236 237 // Color to use when filling drawn objects 238 void fillColor(const Color &fillColor_); 239 Color fillColor(void) const; 240 241 // Rule to use when filling drawn objects 242 void fillRule(const FillRule &fillRule_); 243 FillRule fillRule(void) const; 244 245 // Pattern to use while filling drawn objects. 246 void fillPattern(const Image &fillPattern_); 247 Image fillPattern(void) const; 248 249 // Filter to use when resizing image 250 void filterType(const FilterType filterType_); 251 FilterType filterType(void) const; 252 253 // Text rendering font 254 void font(const std::string &font_); 255 std::string font(void) const; 256 257 // Font family 258 void fontFamily(const std::string &family_); 259 std::string fontFamily(void) const; 260 261 // Font point size 262 void fontPointsize(const double pointSize_); 263 double fontPointsize(void) const; 264 265 // Font style 266 void fontStyle(const StyleType style_); 267 StyleType fontStyle(void) const; 268 269 // Font weight 270 void fontWeight(const size_t weight_); 271 size_t fontWeight(void) const; 272 273 // Long image format description 274 std::string format(void) const; 275 276 // Formats the specified expression 277 // More info here: http://www.imagemagick.org/script/escape.php 278 std::string formatExpression(const std::string expression); 279 280 // Gamma level of the image 281 double gamma(void) const; 282 283 // Preferred size of the image when encoding 284 Geometry geometry(void) const; 285 286 // GIF disposal method 287 void gifDisposeMethod(const DisposeType disposeMethod_); 288 DisposeType gifDisposeMethod(void) const; 289 290 bool hasChannel(const PixelChannel channel) const; 291 292 // When comparing images, emphasize pixel differences with this color. 293 void highlightColor(const Color color_); 294 295 // ICC color profile (BLOB) 296 void iccColorProfile(const Blob &colorProfile_); 297 Blob iccColorProfile(void) const; 298 299 // Type of interlacing to use 300 void interlaceType(const InterlaceType interlace_); 301 InterlaceType interlaceType(void) const; 302 303 // Pixel color interpolation method to use 304 void interpolate(const PixelInterpolateMethod interpolate_); 305 PixelInterpolateMethod interpolate(void) const; 306 307 // IPTC profile (BLOB) 308 void iptcProfile(const Blob &iptcProfile_); 309 Blob iptcProfile(void) const; 310 311 // Returns true if none of the pixels in the image have an alpha value 312 // other than OpaqueAlpha (QuantumRange). 313 bool isOpaque(void) const; 314 315 // Does object contain valid image? 316 void isValid(const bool isValid_); 317 bool isValid(void) const; 318 319 // Image label 320 void label(const std::string &label_); 321 std::string label(void) const; 322 323 // When comparing images, de-emphasize pixel differences with this color. 324 void lowlightColor(const Color color_); 325 326 // File type magick identifier (.e.g "GIF") 327 void magick(const std::string &magick_); 328 std::string magick(void) const; 329 330 // The mean error per pixel computed when an image is color reduced 331 double meanErrorPerPixel(void) const; 332 333 // Image modulus depth (minimum number of bits required to support 334 // red/green/blue components without loss of accuracy) 335 void modulusDepth(const size_t modulusDepth_); 336 size_t modulusDepth(void) const; 337 338 // Transform image to black and white 339 void monochrome(const bool monochromeFlag_); 340 bool monochrome(void) const; 341 342 // Tile size and offset within an image montage 343 Geometry montageGeometry(void) const; 344 345 // The normalized max error per pixel computed when an image is 346 // color reduced. 347 double normalizedMaxError(void) const; 348 349 // The normalized mean error per pixel computed when an image is 350 // color reduced. 351 double normalizedMeanError(void) const; 352 353 // Image orientation 354 void orientation(const OrientationType orientation_); 355 OrientationType orientation(void) const; 356 357 // Preferred size and location of an image canvas. 358 void page(const Geometry &pageSize_); 359 Geometry page(void) const; 360 361 // JPEG/MIFF/PNG compression level (default 75). 362 void quality(const size_t quality_); 363 size_t quality(void) const; 364 365 // Maximum number of colors to quantize to 366 void quantizeColors(const size_t colors_); 367 size_t quantizeColors(void) const; 368 369 // Colorspace to quantize in. 370 void quantizeColorSpace(const ColorspaceType colorSpace_); 371 ColorspaceType quantizeColorSpace(void) const; 372 373 // Dither image during quantization (default true). 374 void quantizeDither(const bool ditherFlag_); 375 bool quantizeDither(void) const; 376 377 // Dither method 378 void quantizeDitherMethod(const DitherMethod ditherMethod_); 379 DitherMethod quantizeDitherMethod(void) const; 380 381 // Quantization tree-depth 382 void quantizeTreeDepth(const size_t treeDepth_); 383 size_t quantizeTreeDepth(void) const; 384 385 // Suppress all warning messages. Error messages are still reported. 386 void quiet(const bool quiet_); 387 bool quiet(void) const; 388 389 // The type of rendering intent 390 void renderingIntent(const RenderingIntent renderingIntent_); 391 RenderingIntent renderingIntent(void) const; 392 393 // Units of image resolution 394 void resolutionUnits(const ResolutionType resolutionUnits_); 395 ResolutionType resolutionUnits(void) const; 396 397 // The number of pixel rows in the image 398 size_t rows(void) const; 399 400 // Image scene number 401 void scene(const size_t scene_); 402 size_t scene(void) const; 403 404 // Width and height of a raw image 405 void size(const Geometry &geometry_); 406 Geometry size(void) const; 407 408 // enabled/disable stroke anti-aliasing 409 void strokeAntiAlias(const bool flag_); 410 bool strokeAntiAlias(void) const; 411 412 // Color to use when drawing object outlines 413 void strokeColor(const Color &strokeColor_); 414 Color strokeColor(void) const; 415 416 // Specify the pattern of dashes and gaps used to stroke 417 // paths. The strokeDashArray represents a zero-terminated array 418 // of numbers that specify the lengths of alternating dashes and 419 // gaps in pixels. If an odd number of values is provided, then 420 // the list of values is repeated to yield an even number of 421 // values. A typical strokeDashArray_ array might contain the 422 // members 5 3 2 0, where the zero value indicates the end of the 423 // pattern array. 424 void strokeDashArray(const double *strokeDashArray_); 425 const double *strokeDashArray(void) const; 426 427 // While drawing using a dash pattern, specify distance into the 428 // dash pattern to start the dash (default 0). 429 void strokeDashOffset(const double strokeDashOffset_); 430 double strokeDashOffset(void) const; 431 432 // Specify the shape to be used at the end of open subpaths when 433 // they are stroked. Values of LineCap are UndefinedCap, ButtCap, 434 // RoundCap, and SquareCap. 435 void strokeLineCap(const LineCap lineCap_); 436 LineCap strokeLineCap(void) const; 437 438 // Specify the shape to be used at the corners of paths (or other 439 // vector shapes) when they are stroked. Values of LineJoin are 440 // UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin. 441 void strokeLineJoin(const LineJoin lineJoin_); 442 LineJoin strokeLineJoin(void) const; 443 444 // Specify miter limit. When two line segments meet at a sharp 445 // angle and miter joins have been specified for 'lineJoin', it is 446 // possible for the miter to extend far beyond the thickness of 447 // the line stroking the path. The miterLimit' imposes a limit on 448 // the ratio of the miter length to the 'lineWidth'. The default 449 // value of this parameter is 4. 450 void strokeMiterLimit(const size_t miterLimit_); 451 size_t strokeMiterLimit(void) const; 452 453 // Pattern image to use while stroking object outlines. 454 void strokePattern(const Image &strokePattern_); 455 Image strokePattern(void) const; 456 457 // Stroke width for drawing vector objects (default one) 458 void strokeWidth(const double strokeWidth_); 459 double strokeWidth(void) const; 460 461 // Subimage of an image sequence 462 void subImage(const size_t subImage_); 463 size_t subImage(void) const; 464 465 // Number of images relative to the base image 466 void subRange(const size_t subRange_); 467 size_t subRange(void) const; 468 469 // Anti-alias Postscript and TrueType fonts (default true) 470 void textAntiAlias(const bool flag_); 471 bool textAntiAlias(void) const; 472 473 // Render text right-to-left or left-to-right. 474 void textDirection(DirectionType direction_); 475 DirectionType textDirection() const; 476 477 // Annotation text encoding (e.g. "UTF-16") 478 void textEncoding(const std::string &encoding_); 479 std::string textEncoding(void) const; 480 481 // Text gravity. 482 void textGravity(GravityType gravity_); 483 GravityType textGravity() const; 484 485 // Text inter-line spacing 486 void textInterlineSpacing(double spacing_); 487 double textInterlineSpacing(void) const; 488 489 // Text inter-word spacing 490 void textInterwordSpacing(double spacing_); 491 double textInterwordSpacing(void) const; 492 493 // Text inter-character kerning 494 void textKerning(double kerning_); 495 double textKerning(void) const; 496 497 // Text undercolor box 498 void textUnderColor(const Color &underColor_); 499 Color textUnderColor(void) const; 500 501 // Number of colors in the image 502 size_t totalColors(void) const; 503 504 // Rotation to use when annotating with text or drawing 505 void transformRotation(const double angle_); 506 507 // Skew to use in X axis when annotating with text or drawing 508 void transformSkewX(const double skewx_); 509 510 // Skew to use in Y axis when annotating with text or drawing 511 void transformSkewY(const double skewy_); 512 513 // Image representation type (also see type operation) 514 // Available types: 515 // Bilevel Grayscale GrayscaleMatte 516 // Palette PaletteMatte TrueColor 517 // TrueColorMatte ColorSeparation ColorSeparationMatte 518 void type(const ImageType type_); 519 ImageType type(void) const; 520 521 // Print detailed information about the image 522 void verbose(const bool verboseFlag_); 523 bool verbose(void) const; 524 525 // Virtual pixel method 526 void virtualPixelMethod(const VirtualPixelMethod virtualPixelMethod_); 527 VirtualPixelMethod virtualPixelMethod(void) const; 528 529 // X11 display to display to, obtain fonts from, or to capture 530 // image from 531 void x11Display(const std::string &display_); 532 std::string x11Display(void) const; 533 534 // x resolution of the image 535 double xResolution(void) const; 536 537 // y resolution of the image 538 double yResolution(void) const; 539 540 // Adaptive-blur image with specified blur factor 541 // The radius_ parameter specifies the radius of the Gaussian, in 542 // pixels, not counting the center pixel. The sigma_ parameter 543 // specifies the standard deviation of the Laplacian, in pixels. 544 void adaptiveBlur(const double radius_=0.0,const double sigma_=1.0); 545 546 // This is shortcut function for a fast interpolative resize using mesh 547 // interpolation. It works well for small resizes of less than +/- 50% 548 // of the original image size. For larger resizing on images a full 549 // filtered and slower resize function should be used instead. 550 void adaptiveResize(const Geometry &geometry_); 551 552 // Adaptively sharpens the image by sharpening more intensely near image 553 // edges and less intensely far from edges. We sharpen the image with a 554 // Gaussian operator of the given radius and standard deviation (sigma). 555 // For reasonable results, radius should be larger than sigma. 556 void adaptiveSharpen(const double radius_=0.0,const double sigma_=1.0); 557 void adaptiveSharpenChannel(const ChannelType channel_, 558 const double radius_=0.0,const double sigma_=1.0); 559 560 // Local adaptive threshold image 561 // http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm 562 // Width x height define the size of the pixel neighborhood 563 // bias = constant to subtract from pixel neighborhood mean 564 void adaptiveThreshold(const size_t width_,const size_t height_, 565 const double bias_=0.0); 566 567 // Add noise to image with specified noise type 568 void addNoise(const NoiseType noiseType_); 569 void addNoiseChannel(const ChannelType channel_, 570 const NoiseType noiseType_); 571 572 // Transform image by specified affine (or free transform) matrix. 573 void affineTransform(const DrawableAffine &affine); 574 575 // Set or attenuate the alpha channel in the image. If the image 576 // pixels are opaque then they are set to the specified alpha 577 // value, otherwise they are blended with the supplied alpha 578 // value. The value of alpha_ ranges from 0 (completely opaque) 579 // to QuantumRange. The defines OpaqueAlpha and TransparentAlpha are 580 // available to specify completely opaque or completely 581 // transparent, respectively. 582 void alpha(const unsigned int alpha_); 583 584 // AlphaChannel() activates, deactivates, resets, or sets the alpha 585 // channel. 586 void alphaChannel(AlphaChannelOption alphaOption_); 587 588 // 589 // Annotate image (draw text on image) 590 // 591 // Gravity effects text placement in bounding area according to rules: 592 // NorthWestGravity text bottom-left corner placed at top-left 593 // NorthGravity text bottom-center placed at top-center 594 // NorthEastGravity text bottom-right corner placed at top-right 595 // WestGravity text left-center placed at left-center 596 // CenterGravity text center placed at center 597 // EastGravity text right-center placed at right-center 598 // SouthWestGravity text top-left placed at bottom-left 599 // SouthGravity text top-center placed at bottom-center 600 // SouthEastGravity text top-right placed at bottom-right 601 602 // Annotate using specified text, and placement location 603 void annotate(const std::string &text_,const Geometry &location_); 604 605 // Annotate using specified text, bounding area, and placement 606 // gravity 607 void annotate(const std::string &text_,const Geometry &boundingArea_, 608 const GravityType gravity_); 609 610 // Annotate with text using specified text, bounding area, 611 // placement gravity, and rotation. 612 void annotate(const std::string &text_,const Geometry &boundingArea_, 613 const GravityType gravity_,const double degrees_); 614 615 // Annotate with text (bounding area is entire image) and placement 616 // gravity. 617 void annotate(const std::string &text_,const GravityType gravity_); 618 619 // Inserts the artifact with the specified name and value into 620 // the artifact tree of the image. 621 void artifact(const std::string &name_,const std::string &value_); 622 623 // Returns the value of the artifact with the specified name. 624 std::string artifact(const std::string &name_) const; 625 626 // Access/Update a named image attribute 627 void attribute(const std::string name_,const std::string value_); 628 std::string attribute(const std::string name_) const; 629 630 // Extracts the 'mean' from the image and adjust the image to try 631 // make set its gamma appropriatally. 632 void autoGamma(void); 633 void autoGammaChannel(const ChannelType channel_); 634 635 // Adjusts the levels of a particular image channel by scaling the 636 // minimum and maximum values to the full quantum range. 637 void autoLevel(void); 638 void autoLevelChannel(const ChannelType channel_); 639 640 // Adjusts an image so that its orientation is suitable for viewing. 641 void autoOrient(void); 642 643 // Forces all pixels below the threshold into black while leaving all 644 // pixels at or above the threshold unchanged. 645 void blackThreshold(const std::string &threshold_); 646 void blackThresholdChannel(const ChannelType channel_, 647 const std::string &threshold_); 648 649 // Simulate a scene at nighttime in the moonlight. 650 void blueShift(const double factor_=1.5); 651 652 // Blur image with specified blur factor 653 // The radius_ parameter specifies the radius of the Gaussian, in 654 // pixels, not counting the center pixel. The sigma_ parameter 655 // specifies the standard deviation of the Laplacian, in pixels. 656 void blur(const double radius_=0.0,const double sigma_=1.0); 657 void blurChannel(const ChannelType channel_,const double radius_=0.0, 658 const double sigma_=1.0); 659 660 // Border image (add border to image) 661 void border(const Geometry &geometry_=borderGeometryDefault); 662 663 // Changes the brightness and/or contrast of an image. It converts the 664 // brightness and contrast parameters into slope and intercept and calls 665 // a polynomical function to apply to the image. 666 void brightnessContrast(const double brightness_=0.0, 667 const double contrast_=0.0); 668 void brightnessContrastChannel(const ChannelType channel_, 669 const double brightness_=0.0,const double contrast_=0.0); 670 671 // Uses a multi-stage algorithm to detect a wide range of edges in images. 672 void cannyEdge(const double radius_=0.0,const double sigma_=1.0, 673 const double lowerPercent_=0.1,const double upperPercent_=0.3); 674 675 // Accepts a lightweight Color Correction Collection 676 // (CCC) file which solely contains one or more color corrections and 677 // applies the correction to the image. 678 void cdl(const std::string &cdl_); 679 680 // Extract channel from image 681 void channel(const ChannelType channel_); 682 683 // Charcoal effect image (looks like charcoal sketch) 684 // The radius_ parameter specifies the radius of the Gaussian, in 685 // pixels, not counting the center pixel. The sigma_ parameter 686 // specifies the standard deviation of the Laplacian, in pixels. 687 void charcoal(const double radius_=0.0,const double sigma_=1.0); 688 689 // Chop image (remove vertical or horizontal subregion of image) 690 // FIXME: describe how geometry argument is used to select either 691 // horizontal or vertical subregion of image. 692 void chop(const Geometry &geometry_); 693 694 // Chromaticity blue primary point. 695 void chromaBluePrimary(const double x_,const double y_,const double z_); 696 void chromaBluePrimary(double *x_,double *y_,double *z_) const; 697 698 // Chromaticity green primary point. 699 void chromaGreenPrimary(const double x_,const double y_,const double z_); 700 void chromaGreenPrimary(double *x_,double *y_,double *z_) const; 701 702 // Chromaticity red primary point. 703 void chromaRedPrimary(const double x_,const double y_,const double z_); 704 void chromaRedPrimary(double *x_,double *y_,double *z_) const; 705 706 // Chromaticity white point. 707 void chromaWhitePoint(const double x_,const double y_,const double z_); 708 void chromaWhitePoint(double *x_,double *y_,double *z_) const; 709 710 // Set each pixel whose value is below zero to zero and any the 711 // pixel whose value is above the quantum range to the quantum range (e.g. 712 // 65535) otherwise the pixel value remains unchanged. 713 void clamp(void); 714 void clampChannel(const ChannelType channel_); 715 716 // Sets the image clip mask based on any clipping path information 717 // if it exists. 718 void clip(void); 719 void clipPath(const std::string pathname_,const bool inside_); 720 721 // Apply a color lookup table (CLUT) to the image. 722 void clut(const Image &clutImage_,const PixelInterpolateMethod method); 723 void clutChannel(const ChannelType channel_,const Image &clutImage_, 724 const PixelInterpolateMethod method); 725 726 // Colorize image with pen color, using specified percent alpha. 727 void colorize(const unsigned int alpha_,const Color &penColor_); 728 729 // Colorize image with pen color, using specified percent alpha 730 // for red, green, and blue quantums 731 void colorize(const unsigned int alphaRed_,const unsigned int alphaGreen_, 732 const unsigned int alphaBlue_,const Color &penColor_); 733 734 // Color at colormap position index_ 735 void colorMap(const size_t index_,const Color &color_); 736 Color colorMap(const size_t index_) const; 737 738 // Apply a color matrix to the image channels. The user supplied 739 // matrix may be of order 1 to 5 (1x1 through 5x5). 740 void colorMatrix(const size_t order_,const double *color_matrix_); 741 742 // Compare current image with another image 743 // False is returned if the images are not identical. 744 bool compare(const Image &reference_) const; 745 746 // Compare current image with another image 747 // Returns the distortion based on the specified metric. 748 double compare(const Image &reference_,const MetricType metric_); 749 double compareChannel(const ChannelType channel_, 750 const Image &reference_, 751 const MetricType metric_ ); 752 753 // Compare current image with another image 754 // Sets the distortion and returns the difference image. 755 Image compare(const Image &reference_,const MetricType metric_, 756 double *distortion); 757 Image compareChannel(const ChannelType channel_,const Image &reference_, 758 const MetricType metric_,double *distortion); 759 760 // Compose an image onto another at specified offset and using 761 // specified algorithm 762 void composite(const Image &compositeImage_,const Geometry &offset_, 763 const CompositeOperator compose_=InCompositeOp); 764 void composite(const Image &compositeImage_,const GravityType gravity_, 765 const CompositeOperator compose_=InCompositeOp); 766 void composite(const Image &compositeImage_,const ::ssize_t xOffset_, 767 const ::ssize_t yOffset_,const CompositeOperator compose_=InCompositeOp); 768 769 // Determines the connected-components of the image 770 void connectedComponents(const size_t connectivity_); 771 772 // Contrast image (enhance intensity differences in image) 773 void contrast(const bool sharpen_); 774 775 // A simple image enhancement technique that attempts to improve the 776 // contrast in an image by 'stretching' the range of intensity values 777 // it contains to span a desired range of values. It differs from the 778 // more sophisticated histogram equalization in that it can only apply a 779 // linear scaling function to the image pixel values. As a result the 780 // 'enhancement' is less harsh. 781 void contrastStretch(const double blackPoint_,const double whitePoint_); 782 void contrastStretchChannel(const ChannelType channel_, 783 const double blackPoint_,const double whitePoint_); 784 785 // Convolve image. Applies a user-specified convolution to the image. 786 // order_ represents the number of columns and rows in the filter kernel. 787 // kernel_ is an array of doubles representing the convolution kernel. 788 void convolve(const size_t order_,const double *kernel_); 789 790 // Copies pixels from the source image as defined by the geometry the 791 // destination image at the specified offset. 792 void copyPixels(const Image &source_,const Geometry &geometry_, 793 const Offset &offset_); 794 795 // Crop image (subregion of original image) 796 void crop(const Geometry &geometry_); 797 798 // Cycle image colormap 799 void cycleColormap(const ::ssize_t amount_); 800 801 // Converts cipher pixels to plain pixels. 802 void decipher(const std::string &passphrase_); 803 804 // Tagged image format define. Similar to the defineValue() method 805 // except that passing the flag_ value 'true' creates a value-less 806 // define with that format and key. Passing the flag_ value 'false' 807 // removes any existing matching definition. The method returns 'true' 808 // if a matching key exists, and 'false' if no matching key exists. 809 void defineSet(const std::string &magick_,const std::string &key_, 810 bool flag_); 811 bool defineSet(const std::string &magick_,const std::string &key_) const; 812 813 // Tagged image format define (set/access coder-specific option) The 814 // magick_ option specifies the coder the define applies to. The key_ 815 // option provides the key specific to that coder. The value_ option 816 // provides the value to set (if any). See the defineSet() method if the 817 // key must be removed entirely. 818 void defineValue(const std::string &magick_,const std::string &key_, 819 const std::string &value_); 820 std::string defineValue(const std::string &magick_, 821 const std::string &key_) const; 822 823 // Removes skew from the image. Skew is an artifact that occurs in scanned 824 // images because of the camera being misaligned, imperfections in the 825 // scanning or surface, or simply because the paper was not placed 826 // completely flat when scanned. The value of threshold_ ranges from 0 827 // to QuantumRange. 828 void deskew(const double threshold_); 829 830 // Despeckle image (reduce speckle noise) 831 void despeckle(void); 832 833 // Display image on screen 834 void display(void); 835 836 // Distort image. distorts an image using various distortion methods, by 837 // mapping color lookups of the source image to a new destination image 838 // usally of the same size as the source image, unless 'bestfit' is set to 839 // true. 840 void distort(const DistortMethod method_, 841 const size_t numberArguments_,const double *arguments_, 842 const bool bestfit_=false); 843 844 // Draw on image using a single drawable 845 void draw(const Drawable &drawable_); 846 847 // Draw on image using a drawable list 848 void draw(const std::vector<Magick::Drawable> &drawable_); 849 850 // Edge image (hilight edges in image) 851 void edge(const double radius_=0.0); 852 853 // Emboss image (hilight edges with 3D effect) 854 // The radius_ parameter specifies the radius of the Gaussian, in 855 // pixels, not counting the center pixel. The sigma_ parameter 856 // specifies the standard deviation of the Laplacian, in pixels. 857 void emboss(const double radius_=0.0,const double sigma_=1.0); 858 859 // Converts pixels to cipher-pixels. 860 void encipher(const std::string &passphrase_); 861 862 // Enhance image (minimize noise) 863 void enhance(void); 864 865 // Equalize image (histogram equalization) 866 void equalize(void); 867 868 // Erase image to current "background color" 869 void erase(void); 870 871 // Apply a value with an arithmetic, relational, or logical operator. 872 void evaluate(const ChannelType channel_, 873 const MagickEvaluateOperator operator_,double rvalue_); 874 875 // Apply a value with an arithmetic, relational, or logical operator. 876 void evaluate(const ChannelType channel_,const MagickFunction function_, 877 const size_t number_parameters_,const double *parameters_); 878 879 // Apply a value with an arithmetic, relational, or logical operator. 880 void evaluate(const ChannelType channel_,const ::ssize_t x_, 881 const ::ssize_t y_,const size_t columns_,const size_t rows_, 882 const MagickEvaluateOperator operator_,const double rvalue_); 883 884 // Extend the image as defined by the geometry. 885 void extent(const Geometry &geometry_); 886 void extent(const Geometry &geometry_,const Color &backgroundColor); 887 void extent(const Geometry &geometry_,const Color &backgroundColor, 888 const GravityType gravity_); 889 void extent(const Geometry &geometry_,const GravityType gravity_); 890 891 // Flip image (reflect each scanline in the vertical direction) 892 void flip(void); 893 894 // Floodfill pixels matching color (within fuzz factor) of target 895 // pixel(x,y) with replacement alpha value. 896 void floodFillAlpha(const ::ssize_t x_,const ::ssize_t y_, 897 const unsigned int alpha_,const bool invert_=false); 898 899 // Floodfill designated area with replacement alpha value 900 void floodFillAlpha(const ssize_t x_,const ssize_t y_, 901 const unsigned int alpha_,const Color &target_,const bool invert_=false); 902 903 // Flood-fill color across pixels that match the color of the 904 // target pixel and are neighbors of the target pixel. 905 // Uses current fuzz setting when determining color match. 906 void floodFillColor(const Geometry &point_,const Color &fillColor_, 907 const bool invert_=false); 908 void floodFillColor(const ::ssize_t x_,const ::ssize_t y_, 909 const Color &fillColor_,const bool invert_=false); 910 911 // Flood-fill color across pixels starting at target-pixel and 912 // stopping at pixels matching specified border color. 913 // Uses current fuzz setting when determining color match. 914 void floodFillColor(const Geometry &point_,const Color &fillColor_, 915 const Color &borderColor_,const bool invert_=false); 916 void floodFillColor(const ::ssize_t x_,const ::ssize_t y_, 917 const Color &fillColor_,const Color &borderColor_, 918 const bool invert_=false); 919 920 // Flood-fill texture across pixels that match the color of the 921 // target pixel and are neighbors of the target pixel. 922 // Uses current fuzz setting when determining color match. 923 void floodFillTexture(const Geometry &point_,const Image &texture_, 924 const bool invert_=false); 925 void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_, 926 const Image &texture_,const bool invert_=false); 927 928 // Flood-fill texture across pixels starting at target-pixel and 929 // stopping at pixels matching specified border color. 930 // Uses current fuzz setting when determining color match. 931 void floodFillTexture(const Geometry &point_,const Image &texture_, 932 const Color &borderColor_,const bool invert_=false); 933 void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_, 934 const Image &texture_,const Color &borderColor_, 935 const bool invert_=false); 936 937 // Flop image (reflect each scanline in the horizontal direction) 938 void flop(void); 939 940 // Obtain font metrics for text string given current font, 941 // pointsize, and density settings. 942 void fontTypeMetrics(const std::string &text_,TypeMetric *metrics); 943 944 // Obtain multi line font metrics for text string given current font, 945 // pointsize, and density settings. 946 void fontTypeMetricsMultiline(const std::string &text_, 947 TypeMetric *metrics); 948 949 // Frame image 950 void frame(const Geometry &geometry_=frameGeometryDefault); 951 void frame(const size_t width_,const size_t height_, 952 const ::ssize_t innerBevel_=6,const ::ssize_t outerBevel_=6); 953 954 // Applies a mathematical expression to the image. 955 void fx(const std::string expression_); 956 void fx(const std::string expression_,const Magick::ChannelType channel_); 957 958 // Gamma correct image 959 void gamma(const double gamma_); 960 void gamma(const double gammaRed_,const double gammaGreen_, 961 const double gammaBlue_); 962 963 // Gaussian blur image 964 // The number of neighbor pixels to be included in the convolution 965 // mask is specified by 'radius_'. The standard deviation of the 966 // gaussian bell curve is specified by 'sigma_'. 967 void gaussianBlur(const double radius_,const double sigma_); 968 void gaussianBlurChannel(const ChannelType channel_,const double radius_, 969 const double sigma_); 970 971 // Transfers read-only pixels from the image to the pixel cache as 972 // defined by the specified region 973 const Quantum *getConstPixels(const ::ssize_t x_, const ::ssize_t y_, 974 const size_t columns_,const size_t rows_) const; 975 976 // Obtain immutable image pixel metacontent (valid for PseudoClass images) 977 const void *getConstMetacontent(void) const; 978 979 // Obtain mutable image pixel metacontent (valid for PseudoClass images) 980 void *getMetacontent(void); 981 982 // Transfers pixels from the image to the pixel cache as defined 983 // by the specified region. Modified pixels may be subsequently 984 // transferred back to the image via syncPixels. This method is 985 // valid for DirectClass images. 986 Quantum *getPixels(const ::ssize_t x_,const ::ssize_t y_, 987 const size_t columns_,const size_t rows_); 988 989 // Converts the colors in the image to gray. 990 void grayscale(const PixelIntensityMethod method_); 991 992 // Apply a color lookup table (Hald CLUT) to the image. 993 void haldClut(const Image &clutImage_); 994 995 // Identifies lines in the image. 996 void houghLine(const size_t width_,const size_t height_, 997 const size_t threshold_=40); 998 999 // Identifies the potential color type of the image. This method can be 1000 // used to detect if the type can be changed to GrayScale. 1001 ImageType identifyType(void) const; 1002 1003 // Implode image (special effect) 1004 void implode(const double factor_); 1005 1006 // Implements the inverse discrete Fourier transform (DFT) of the image 1007 // either as a magnitude / phase or real / imaginary image pair. 1008 void inverseFourierTransform(const Image &phase_); 1009 void inverseFourierTransform(const Image &phase_,const bool magnitude_); 1010 1011 // An edge preserving noise reduction filter. 1012 void kuwahara(const double radius_=0.0,const double sigma_=1.0); 1013 void kuwaharaChannel(const ChannelType channel_,const double radius_=0.0, 1014 const double sigma_=1.0); 1015 1016 // Level image. Adjust the levels of the image by scaling the 1017 // colors falling between specified white and black points to the 1018 // full available quantum range. The parameters provided represent 1019 // the black, mid (gamma), and white points. The black point 1020 // specifies the darkest color in the image. Colors darker than 1021 // the black point are set to zero. Mid point (gamma) specifies a 1022 // gamma correction to apply to the image. White point specifies 1023 // the lightest color in the image. Colors brighter than the 1024 // white point are set to the maximum quantum value. The black and 1025 // white point have the valid range 0 to QuantumRange while mid (gamma) 1026 // has a useful range of 0 to ten. 1027 void level(const double blackPoint_,const double whitePoint_, 1028 const double gamma_=1.0); 1029 void levelChannel(const ChannelType channel_,const double blackPoint_, 1030 const double whitePoint_,const double gamma_=1.0); 1031 1032 // Maps the given color to "black" and "white" values, linearly spreading 1033 // out the colors, and level values on a channel by channel bases, as 1034 // per level(). The given colors allows you to specify different level 1035 // ranges for each of the color channels separately. 1036 void levelColors(const Color &blackColor_,const Color &whiteColor_, 1037 const bool invert_=true); 1038 void levelColorsChannel(const ChannelType channel_, 1039 const Color &blackColor_,const Color &whiteColor_, 1040 const bool invert_=true); 1041 1042 // Levelize applies the reversed level operation to just the specific 1043 // channels specified.It compresses the full range of color values, so 1044 // that they lie between the given black and white points. Gamma is 1045 // applied before the values are mapped. 1046 void levelize(const double blackPoint_,const double whitePoint_, 1047 const double gamma_=1.0); 1048 void levelizeChannel(const ChannelType channel_,const double blackPoint_, 1049 const double whitePoint_,const double gamma_=1.0); 1050 1051 // Discards any pixels below the black point and above the white point and 1052 // levels the remaining pixels. 1053 void linearStretch(const double blackPoint_,const double whitePoint_); 1054 1055 // Rescales image with seam carving. 1056 void liquidRescale(const Geometry &geometry_); 1057 1058 // Local contrast enhancement 1059 void localContrast(const double radius_,const double strength_); 1060 1061 // Magnify image by integral size 1062 void magnify(void); 1063 1064 // Remap image colors with closest color from reference image 1065 void map(const Image &mapImage_,const bool dither_=false); 1066 1067 // Filter image by replacing each pixel component with the median 1068 // color in a circular neighborhood 1069 void medianFilter(const double radius_=0.0); 1070 1071 // Reduce image by integral size 1072 void minify(void); 1073 1074 // Modulate percent hue, saturation, and brightness of an image 1075 void modulate(const double brightness_,const double saturation_, 1076 const double hue_); 1077 1078 // Returns the normalized moments of one or more image channels. 1079 ImageMoments moments(void) const; 1080 1081 // Applies a kernel to the image according to the given mophology method. 1082 void morphology(const MorphologyMethod method_,const std::string kernel_, 1083 const ssize_t iterations_=1); 1084 void morphology(const MorphologyMethod method_, 1085 const KernelInfoType kernel_,const std::string arguments_, 1086 const ssize_t iterations_=1); 1087 void morphologyChannel(const ChannelType channel_, 1088 const MorphologyMethod method_,const std::string kernel_, 1089 const ssize_t iterations_=1); 1090 void morphologyChannel(const ChannelType channel_, 1091 const MorphologyMethod method_,const KernelInfoType kernel_, 1092 const std::string arguments_,const ssize_t iterations_=1); 1093 1094 // Motion blur image with specified blur factor 1095 // The radius_ parameter specifies the radius of the Gaussian, in 1096 // pixels, not counting the center pixel. The sigma_ parameter 1097 // specifies the standard deviation of the Laplacian, in pixels. 1098 // The angle_ parameter specifies the angle the object appears 1099 // to be comming from (zero degrees is from the right). 1100 void motionBlur(const double radius_,const double sigma_, 1101 const double angle_); 1102 1103 // Negate colors in image. Set grayscale to only negate grayscale 1104 // values in image. 1105 void negate(const bool grayscale_=false); 1106 void negateChannel(const ChannelType channel_,const bool grayscale_=false); 1107 1108 // Normalize image (increase contrast by normalizing the pixel 1109 // values to span the full range of color values) 1110 void normalize(void); 1111 1112 // Oilpaint image (image looks like oil painting) 1113 void oilPaint(const double radius_=0.0,const double sigma=1.0); 1114 1115 // Change color of opaque pixel to specified pen color. 1116 void opaque(const Color &opaqueColor_,const Color &penColor_, 1117 const bool invert_=false); 1118 1119 // Perform a ordered dither based on a number of pre-defined dithering 1120 // threshold maps, but over multiple intensity levels. 1121 void orderedDither(std::string thresholdMap_); 1122 void orderedDitherChannel(const ChannelType channel_, 1123 std::string thresholdMap_); 1124 1125 // Set each pixel whose value is less than epsilon to epsilon or 1126 // -epsilon (whichever is closer) otherwise the pixel value remains 1127 // unchanged. 1128 void perceptible(const double epsilon_); 1129 void perceptibleChannel(const ChannelType channel_,const double epsilon_); 1130 1131 // Returns the perceptual hash for this image. 1132 Magick::ImagePerceptualHash perceptualHash() const; 1133 1134 // Ping is similar to read except only enough of the image is read 1135 // to determine the image columns, rows, and filesize. Access the 1136 // columns(), rows(), and fileSize() attributes after invoking 1137 // ping. The image data is not valid after calling ping. 1138 void ping(const std::string &imageSpec_); 1139 1140 // Ping is similar to read except only enough of the image is read 1141 // to determine the image columns, rows, and filesize. Access the 1142 // columns(), rows(), and fileSize() attributes after invoking 1143 // ping. The image data is not valid after calling ping. 1144 void ping(const Blob &blob_); 1145 1146 // Get/set pixel color at location x & y. 1147 void pixelColor(const ::ssize_t x_,const ::ssize_t y_,const Color &color_); 1148 Color pixelColor(const ::ssize_t x_,const ::ssize_t y_ ) const; 1149 1150 // Simulates a Polaroid picture. 1151 void polaroid(const std::string &caption_,const double angle_, 1152 const PixelInterpolateMethod method_); 1153 1154 // Reduces the image to a limited number of colors for a "poster" effect. 1155 void posterize(const size_t levels_,const DitherMethod method_); 1156 void posterizeChannel(const ChannelType channel_,const size_t levels_, 1157 const DitherMethod method_); 1158 1159 // Execute a named process module using an argc/argv syntax similar to 1160 // that accepted by a C 'main' routine. An exception is thrown if the 1161 // requested process module doesn't exist, fails to load, or fails during 1162 // execution. 1163 void process(std::string name_,const ::ssize_t argc_,const char **argv_); 1164 1165 // Add or remove a named profile to/from the image. Remove the 1166 // profile by passing an empty Blob (e.g. Blob()). Valid names are 1167 // "*", "8BIM", "ICM", "IPTC", or a user/format-defined profile name. 1168 void profile(const std::string name_,const Blob &colorProfile_); 1169 1170 // Retrieve a named profile from the image. Valid names are: 1171 // "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC" 1172 // or an existing user/format-defined profile name. 1173 Blob profile(const std::string name_) const; 1174 1175 // Quantize image (reduce number of colors) 1176 void quantize(const bool measureError_=false); 1177 1178 // Raise image (lighten or darken the edges of an image to give a 1179 // 3-D raised or lowered effect) 1180 void raise(const Geometry &geometry_=raiseGeometryDefault, 1181 const bool raisedFlag_=false); 1182 1183 // Random threshold image. 1184 // 1185 // Changes the value of individual pixels based on the intensity 1186 // of each pixel compared to a random threshold. The result is a 1187 // low-contrast, two color image. 1188 void randomThreshold(const double low_,const double high_); 1189 void randomThresholdChannel(const ChannelType channel_,const double low_, 1190 const double high_); 1191 1192 // Read single image frame from in-memory BLOB 1193 void read(const Blob &blob_); 1194 1195 // Read single image frame of specified size from in-memory BLOB 1196 void read(const Blob &blob_,const Geometry &size_); 1197 1198 // Read single image frame of specified size and depth from 1199 // in-memory BLOB 1200 void read(const Blob &blob_,const Geometry &size_,const size_t depth_); 1201 1202 // Read single image frame of specified size, depth, and format 1203 // from in-memory BLOB 1204 void read(const Blob &blob_,const Geometry &size_,const size_t depth_, 1205 const std::string &magick_); 1206 1207 // Read single image frame of specified size, and format from 1208 // in-memory BLOB 1209 void read(const Blob &blob_,const Geometry &size_, 1210 const std::string &magick_); 1211 1212 // Read single image frame of specified size into current object 1213 void read(const Geometry &size_,const std::string &imageSpec_); 1214 1215 // Read single image frame from an array of raw pixels, with 1216 // specified storage type (ConstituteImage), e.g. 1217 // image.read( 640, 480, "RGB", 0, pixels ); 1218 void read(const size_t width_,const size_t height_,const std::string &map_, 1219 const StorageType type_,const void *pixels_); 1220 1221 // Read single image frame into current object 1222 void read(const std::string &imageSpec_); 1223 1224 // Associate a mask with the image. The mask must be the same dimensions 1225 // as the image. Pass an invalid image to unset an existing mask. 1226 void readMask(const Image &mask_); 1227 Image readMask(void) const; 1228 1229 // Transfers one or more pixel components from a buffer or file 1230 // into the image pixel cache of an image. 1231 // Used to support image decoders. 1232 void readPixels(const QuantumType quantum_,const unsigned char *source_); 1233 1234 // Reduce noise in image using a noise peak elimination filter 1235 void reduceNoise(void); 1236 void reduceNoise(const size_t order_); 1237 1238 // Resets the image page canvas and position. 1239 void repage(); 1240 1241 // Resize image in terms of its pixel size. 1242 void resample(const Point &density_); 1243 1244 // Resize image to specified size. 1245 void resize(const Geometry &geometry_); 1246 1247 // Roll image (rolls image vertically and horizontally) by specified 1248 // number of columnms and rows) 1249 void roll(const Geometry &roll_); 1250 void roll(const size_t columns_,const size_t rows_); 1251 1252 // Rotate image counter-clockwise by specified number of degrees. 1253 void rotate(const double degrees_); 1254 1255 // Rotational blur image. 1256 void rotationalBlur(const double angle_); 1257 void rotationalBlurChannel(const ChannelType channel_,const double angle_); 1258 1259 // Resize image by using pixel sampling algorithm 1260 void sample(const Geometry &geometry_); 1261 1262 // Resize image by using simple ratio algorithm 1263 void scale(const Geometry &geometry_); 1264 1265 // Segment (coalesce similar image components) by analyzing the 1266 // histograms of the color components and identifying units that 1267 // are homogeneous with the fuzzy c-means technique. Also uses 1268 // QuantizeColorSpace and Verbose image attributes 1269 void segment(const double clusterThreshold_=1.0, 1270 const double smoothingThreshold_=1.5); 1271 1272 // Selectively blur pixels within a contrast threshold. It is similar to 1273 // the unsharpen mask that sharpens everything with contrast above a 1274 // certain threshold. 1275 void selectiveBlur(const double radius_,const double sigma_, 1276 const double threshold_); 1277 void selectiveBlurChannel(const ChannelType channel_,const double radius_, 1278 const double sigma_,const double threshold_); 1279 1280 // Separates a channel from the image and returns it as a grayscale image. 1281 Image separate(const ChannelType channel_) const; 1282 1283 // Applies a special effect to the image, similar to the effect achieved in 1284 // a photo darkroom by sepia toning. Threshold ranges from 0 to 1285 // QuantumRange and is a measure of the extent of the sepia toning. 1286 // A threshold of 80% is a good starting point for a reasonable tone. 1287 void sepiaTone(const double threshold_); 1288 1289 // Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError 1290 // in the current image. False is returned if the images are not identical. 1291 bool setColorMetric(const Image &reference_); 1292 1293 // Allocates a pixel cache region to store image pixels as defined 1294 // by the region rectangle. This area is subsequently transferred 1295 // from the pixel cache to the image via syncPixels. 1296 Quantum *setPixels(const ::ssize_t x_, const ::ssize_t y_, 1297 const size_t columns_,const size_t rows_); 1298 1299 // Shade image using distant light source 1300 void shade(const double azimuth_=30,const double elevation_=30, 1301 const bool colorShading_=false); 1302 1303 // Simulate an image shadow 1304 void shadow(const double percentAlpha_=80.0,const double sigma_=0.5, 1305 const ssize_t x_=5,const ssize_t y_=5); 1306 1307 // Sharpen pixels in image 1308 // The radius_ parameter specifies the radius of the Gaussian, in 1309 // pixels, not counting the center pixel. The sigma_ parameter 1310 // specifies the standard deviation of the Laplacian, in pixels. 1311 void sharpen(const double radius_=0.0,const double sigma_=1.0); 1312 void sharpenChannel(const ChannelType channel_,const double radius_=0.0, 1313 const double sigma_=1.0); 1314 1315 // Shave pixels from image edges. 1316 void shave(const Geometry &geometry_); 1317 1318 // Shear image (create parallelogram by sliding image by X or Y axis) 1319 void shear(const double xShearAngle_,const double yShearAngle_); 1320 1321 // adjust the image contrast with a non-linear sigmoidal contrast algorithm 1322 void sigmoidalContrast(const bool sharpen_,const double contrast, 1323 const double midpoint=QuantumRange/2.0); 1324 1325 // Image signature. Set force_ to true in order to re-calculate 1326 // the signature regardless of whether the image data has been 1327 // modified. 1328 std::string signature(const bool force_=false) const; 1329 1330 // Simulates a pencil sketch. We convolve the image with a Gaussian 1331 // operator of the given radius and standard deviation (sigma). For 1332 // reasonable results, radius should be larger than sigma. Use a 1333 // radius of 0 and SketchImage() selects a suitable radius for you. 1334 void sketch(const double radius_=0.0,const double sigma_=1.0, 1335 const double angle_=0.0); 1336 1337 // Solarize image (similar to effect seen when exposing a 1338 // photographic film to light during the development process) 1339 void solarize(const double factor_=50.0); 1340 1341 // Sparse color image, given a set of coordinates, interpolates the colors 1342 // found at those coordinates, across the whole image, using various 1343 // methods. 1344 void sparseColor(const ChannelType channel_, 1345 const SparseColorMethod method_,const size_t numberArguments_, 1346 const double *arguments_); 1347 1348 // Splice the background color into the image. 1349 void splice(const Geometry &geometry_); 1350 void splice(const Geometry &geometry_,const Color &backgroundColor_); 1351 void splice(const Geometry &geometry_,const Color &backgroundColor_, 1352 const GravityType gravity_); 1353 1354 // Spread pixels randomly within image by specified ammount 1355 void spread(const double amount_=3.0); 1356 1357 // Returns the statistics for this image. 1358 Magick::ImageStatistics statistics() const; 1359 1360 // Add a digital watermark to the image (based on second image) 1361 void stegano(const Image &watermark_); 1362 1363 // Create an image which appears in stereo when viewed with 1364 // red-blue glasses (Red image on left, blue on right) 1365 void stereo(const Image &rightImage_); 1366 1367 // Strip strips an image of all profiles and comments. 1368 void strip(void); 1369 1370 // Search for the specified image at EVERY possible location in this image. 1371 // This is slow! very very slow.. It returns a similarity image such that 1372 // an exact match location is completely white and if none of the pixels 1373 // match, black, otherwise some gray level in-between. 1374 Image subImageSearch(const Image &reference_,const MetricType metric_, 1375 Geometry *offset_,double *similarityMetric_, 1376 const double similarityThreshold=(-1.0)); 1377 1378 // Swirl image (image pixels are rotated by degrees) 1379 void swirl(const double degrees_); 1380 1381 // Transfers the image cache pixels to the image. 1382 void syncPixels(void); 1383 1384 // Channel a texture on image background 1385 void texture(const Image &texture_); 1386 1387 // Threshold image 1388 void threshold(const double threshold_); 1389 1390 // Resize image to thumbnail size 1391 void thumbnail(const Geometry &geometry_); 1392 1393 // Applies a color vector to each pixel in the image. The length of the 1394 // vector is 0 for black and white and at its maximum for the midtones. 1395 // The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5)))) 1396 void tint(const std::string opacity_); 1397 1398 // Origin of coordinate system to use when annotating with text or drawing 1399 void transformOrigin(const double x_,const double y_); 1400 1401 // Reset transformation parameters to default 1402 void transformReset(void); 1403 1404 // Scale to use when annotating with text or drawing 1405 void transformScale(const double sx_,const double sy_); 1406 1407 // Add matte image to image, setting pixels matching color to 1408 // transparent 1409 void transparent(const Color &color_,const bool inverse_=false); 1410 1411 // Add matte image to image, for all the pixels that lies in between 1412 // the given two color 1413 void transparentChroma(const Color &colorLow_,const Color &colorHigh_); 1414 1415 // Creates a horizontal mirror image by reflecting the pixels around the 1416 // central y-axis while rotating them by 90 degrees. 1417 void transpose(void); 1418 1419 // Creates a vertical mirror image by reflecting the pixels around the 1420 // central x-axis while rotating them by 270 degrees. 1421 void transverse(void); 1422 1423 // Trim edges that are the background color from the image 1424 void trim(void); 1425 1426 // Returns the unique colors of an image. 1427 Image uniqueColors(void) const; 1428 1429 // Replace image with a sharpened version of the original image 1430 // using the unsharp mask algorithm. 1431 // radius_ 1432 // the radius of the Gaussian, in pixels, not counting the 1433 // center pixel. 1434 // sigma_ 1435 // the standard deviation of the Gaussian, in pixels. 1436 // amount_ 1437 // the percentage of the difference between the original and 1438 // the blur image that is added back into the original. 1439 // threshold_ 1440 // the threshold in pixels needed to apply the diffence amount. 1441 void unsharpmask(const double radius_,const double sigma_, 1442 const double amount_,const double threshold_); 1443 void unsharpmaskChannel(const ChannelType channel_,const double radius_, 1444 const double sigma_,const double amount_,const double threshold_); 1445 1446 // Softens the edges of the image in vignette style. 1447 void vignette(const double radius_=0.0,const double sigma_=1.0, 1448 const ssize_t x_=0,const ssize_t y_=0); 1449 1450 // Map image pixels to a sine wave 1451 void wave(const double amplitude_=25.0,const double wavelength_=150.0); 1452 1453 // Removes noise from the image using a wavelet transform. 1454 void waveletDenoise(const double threshold_,const double softness_); 1455 1456 // Forces all pixels above the threshold into white while leaving all 1457 // pixels at or below the threshold unchanged. 1458 void whiteThreshold(const std::string &threshold_); 1459 void whiteThresholdChannel(const ChannelType channel_, 1460 const std::string &threshold_); 1461 1462 // Write single image frame to in-memory BLOB, with optional 1463 // format and adjoin parameters. 1464 void write(Blob *blob_); 1465 void write(Blob *blob_,const std::string &magick_); 1466 void write(Blob *blob_,const std::string &magick_,const size_t depth_); 1467 1468 // Write single image frame to an array of pixels with storage 1469 // type specified by user (DispatchImage), e.g. 1470 // image.write( 0, 0, 640, 1, "RGB", 0, pixels ); 1471 void write(const ::ssize_t x_,const ::ssize_t y_,const size_t columns_, 1472 const size_t rows_,const std::string &map_,const StorageType type_, 1473 void *pixels_); 1474 1475 // Write single image frame to a file 1476 void write(const std::string &imageSpec_); 1477 1478 // Associate a mask with the image. The mask must be the same dimensions 1479 // as the image. Pass an invalid image to unset an existing mask. 1480 void writeMask(const Image &mask_); 1481 Image writeMask(void) const; 1482 1483 // Transfers one or more pixel components from the image pixel 1484 // cache to a buffer or file. 1485 // Used to support image encoders. 1486 void writePixels(const QuantumType quantum_,unsigned char *destination_); 1487 1488 // Zoom image to specified size. 1489 void zoom(const Geometry &geometry_); 1490 1491 ////////////////////////////////////////////////////////////////////// 1492 // 1493 // No user-serviceable parts beyond this point 1494 // 1495 ////////////////////////////////////////////////////////////////////// 1496 1497 // Construct with MagickCore::Image and default options 1498 Image(MagickCore::Image *image_); 1499 1500 // Retrieve Image* 1501 MagickCore::Image *&image(void); 1502 const MagickCore::Image *constImage(void) const; 1503 1504 // Retrieve ImageInfo* 1505 MagickCore::ImageInfo *imageInfo(void); 1506 const MagickCore::ImageInfo *constImageInfo(void) const; 1507 1508 // Retrieve Options* 1509 Options *options(void); 1510 const Options *constOptions(void) const; 1511 1512 // Retrieve QuantizeInfo* 1513 MagickCore::QuantizeInfo *quantizeInfo(void); 1514 const MagickCore::QuantizeInfo *constQuantizeInfo(void) const; 1515 1516 // Prepare to update image (copy if reference > 1) 1517 void modifyImage(void); 1518 1519 // Replace current image (reference counted) 1520 MagickCore::Image *replaceImage(MagickCore::Image *replacement_); 1521 1522 private: 1523 1524 void floodFill(const ssize_t x_,const ssize_t y_, 1525 const Magick::Image *fillPattern_,const Color &fill_, 1526 const PixelInfo *target,const bool invert_); 1527 1528 void mask(const Image &mask_,const PixelMask); 1529 Image mask(const PixelMask) const; 1530 1531 void read(MagickCore::Image *image, 1532 MagickCore::ExceptionInfo *exceptionInfo); 1533 1534 ImageRef *_imgRef; 1535 }; 1536 1537 } // end of namespace Magick 1538 1539 #endif // Magick_Image_header 1540
