Magick++ 7.0.10

Image.h
Go to the documentation of this file.
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-2017
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 matteColor(const Color &matteColor_);
110 Color matteColor(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 // Number of iterations to loop an animation (e.g. Netscape loop
118 // extension) for.
119 void animationIterations(const size_t iterations_);
120 size_t animationIterations(void) const;
121
122 // Image background color
123 void backgroundColor(const Color &color_);
124 Color backgroundColor(void) const;
125
126 // Name of texture image to tile onto the image background
127 void backgroundTexture(const std::string &backgroundTexture_);
128 std::string backgroundTexture(void) const;
129
130 // Base image width (before transformations)
131 size_t baseColumns(void) const;
132
133 // Base image filename (before transformations)
134 std::string baseFilename(void) const;
135
136 // Base image height (before transformations)
137 size_t baseRows(void) const;
138
139 // Use black point compensation.
140 void blackPointCompensation(const bool flag_);
141 bool blackPointCompensation(void) const;
142
143 // Image border color
144 void borderColor(const Color &color_);
145 Color borderColor(void) const;
146
147 // Return smallest bounding box enclosing non-border pixels. The
148 // current fuzz value is used when discriminating between pixels.
149 // This is the crop bounding box used by crop(Geometry(0,0));
150 Geometry boundingBox(void) const;
151
152 // Text bounding-box base color (default none)
153 void boxColor(const Color &boxColor_);
154 Color boxColor(void) const;
155
156 // Set or obtain modulus channel depth
157 void channelDepth(const ChannelType channel_,const size_t depth_);
158 size_t channelDepth(const ChannelType channel_);
159
160 // Returns the number of channels in this image.
161 size_t channels() const;
162
163 // Image class (DirectClass or PseudoClass)
164 // NOTE: setting a DirectClass image to PseudoClass will result in
165 // the loss of color information if the number of colors in the
166 // image is greater than the maximum palette size (either 256 or
167 // 65536 entries depending on the value of MAGICKCORE_QUANTUM_DEPTH when
168 // ImageMagick was built).
169 void classType(const ClassType class_);
170 ClassType classType(void) const;
171
172 // Colors within this distance are considered equal
173 void colorFuzz(const double fuzz_);
174 double colorFuzz(void) const;
175
176 // Colormap size (number of colormap entries)
177 void colorMapSize(const size_t entries_);
178 size_t colorMapSize(void) const;
179
180 // Image Color Space
181 void colorSpace(const ColorspaceType colorSpace_);
182 ColorspaceType colorSpace(void) const;
183
184 void colorSpaceType(const ColorspaceType colorSpace_);
185 ColorspaceType colorSpaceType(void) const;
186
187 // Image width
188 size_t columns(void) const;
189
190 // Comment image (add comment string to image)
191 void comment(const std::string &comment_);
192 std::string comment(void) const;
193
194 // Composition operator to be used when composition is implicitly
195 // used (such as for image flattening).
196 void compose(const CompositeOperator compose_);
197 CompositeOperator compose(void) const;
198
199 // Compression type
200 void compressType(const CompressionType compressType_);
201 CompressionType compressType(void) const;
202
203 // Enable printing of debug messages from ImageMagick
204 void debug(const bool flag_);
205 bool debug(void) const;
206
207 // Vertical and horizontal resolution in pixels of the image
208 void density(const Point &density_);
209 Point density(void) const;
210
211 // Image depth (bits allocated to red/green/blue components)
212 void depth(const size_t depth_);
213 size_t depth(void) const;
214
215 // Tile names from within an image montage
216 std::string directory(void) const;
217
218 // Endianness (little like Intel or big like SPARC) for image
219 // formats which support endian-specific options.
220 void endian(const EndianType endian_);
221 EndianType endian(void) const;
222
223 // Exif profile (BLOB)
224 void exifProfile(const Blob &exifProfile_);
225 Blob exifProfile(void) const;
226
227 // Image file name
228 void fileName(const std::string &fileName_);
229 std::string fileName(void) const;
230
231 // Number of bytes of the image on disk
232 MagickSizeType fileSize(void) const;
233
234 // Color to use when filling drawn objects
235 void fillColor(const Color &fillColor_);
236 Color fillColor(void) const;
237
238 // Rule to use when filling drawn objects
239 void fillRule(const FillRule &fillRule_);
240 FillRule fillRule(void) const;
241
242 // Pattern to use while filling drawn objects.
243 void fillPattern(const Image &fillPattern_);
244 Image fillPattern(void) const;
245
246 // Filter to use when resizing image
247 void filterType(const FilterType filterType_);
248 FilterType filterType(void) const;
249
250 // Text rendering font
251 void font(const std::string &font_);
252 std::string font(void) const;
253
254 // Font family
255 void fontFamily(const std::string &family_);
256 std::string fontFamily(void) const;
257
258 // Font point size
259 void fontPointsize(const double pointSize_);
260 double fontPointsize(void) const;
261
262 // Font style
263 void fontStyle(const StyleType style_);
264 StyleType fontStyle(void) const;
265
266 // Font weight
267 void fontWeight(const size_t weight_);
268 size_t fontWeight(void) const;
269
270 // Long image format description
271 std::string format(void) const;
272
273 // Formats the specified expression
274 // More info here: https://imagemagick.org/script/escape.php
275 std::string formatExpression(const std::string expression);
276
277 // Gamma level of the image
278 double gamma(void) const;
279
280 // Preferred size of the image when encoding
281 Geometry geometry(void) const;
282
283 // GIF disposal method
284 void gifDisposeMethod(const DisposeType disposeMethod_);
285 DisposeType gifDisposeMethod(void) const;
286
287 bool hasChannel(const PixelChannel channel) const;
288
289 // When comparing images, emphasize pixel differences with this color.
290 void highlightColor(const Color color_);
291
292 // ICC color profile (BLOB)
293 void iccColorProfile(const Blob &colorProfile_);
294 Blob iccColorProfile(void) const;
295
296 // Type of interlacing to use
297 void interlaceType(const InterlaceType interlace_);
298 InterlaceType interlaceType(void) const;
299
300 // Pixel color interpolation method to use
301 void interpolate(const PixelInterpolateMethod interpolate_);
302 PixelInterpolateMethod interpolate(void) const;
303
304 // IPTC profile (BLOB)
305 void iptcProfile(const Blob &iptcProfile_);
306 Blob iptcProfile(void) const;
307
308 // Returns true if none of the pixels in the image have an alpha value
309 // other than OpaqueAlpha (QuantumRange).
310 bool isOpaque(void) const;
311
312 // Does object contain valid image?
313 void isValid(const bool isValid_);
314 bool isValid(void) const;
315
316 // Image label
317 void label(const std::string &label_);
318 std::string label(void) const;
319
320 // When comparing images, de-emphasize pixel differences with this color.
321 void lowlightColor(const Color color_);
322
323 // File type magick identifier (.e.g "GIF")
324 void magick(const std::string &magick_);
325 std::string magick(void) const;
326
327 // When comparing images, set pixels with a read mask to this color.
328 void masklightColor(const Color color_);
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_,const double attenuate_=1.0);
569 void addNoiseChannel(const ChannelType channel_,
570 const NoiseType noiseType_,const double attenuate_=1.0);
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 char *value_);
628 void attribute(const std::string name_,const std::string value_);
629 std::string attribute(const std::string name_) const;
630
631 // Extracts the 'mean' from the image and adjust the image to try
632 // make set its gamma appropriatally.
633 void autoGamma(void);
634 void autoGammaChannel(const ChannelType channel_);
635
636 // Adjusts the levels of a particular image channel by scaling the
637 // minimum and maximum values to the full quantum range.
638 void autoLevel(void);
639 void autoLevelChannel(const ChannelType channel_);
640
641 // Adjusts an image so that its orientation is suitable for viewing.
642 void autoOrient(void);
643
644 // Automatically selects a threshold and replaces each pixel in the image
645 // with a black pixel if the image intentsity is less than the selected
646 // threshold otherwise white.
647 void autoThreshold(const AutoThresholdMethod method_);
648
649 // Forces all pixels below the threshold into black while leaving all
650 // pixels at or above the threshold unchanged.
651 void blackThreshold(const std::string &threshold_);
652 void blackThresholdChannel(const ChannelType channel_,
653 const std::string &threshold_);
654
655 // Simulate a scene at nighttime in the moonlight.
656 void blueShift(const double factor_=1.5);
657
658 // Blur image with specified blur factor
659 // The radius_ parameter specifies the radius of the Gaussian, in
660 // pixels, not counting the center pixel. The sigma_ parameter
661 // specifies the standard deviation of the Laplacian, in pixels.
662 void blur(const double radius_=0.0,const double sigma_=1.0);
663 void blurChannel(const ChannelType channel_,const double radius_=0.0,
664 const double sigma_=1.0);
665
666 // Border image (add border to image)
667 void border(const Geometry &geometry_=borderGeometryDefault);
668
669 // Changes the brightness and/or contrast of an image. It converts the
670 // brightness and contrast parameters into slope and intercept and calls
671 // a polynomical function to apply to the image.
672 void brightnessContrast(const double brightness_=0.0,
673 const double contrast_=0.0);
674 void brightnessContrastChannel(const ChannelType channel_,
675 const double brightness_=0.0,const double contrast_=0.0);
676
677 // Uses a multi-stage algorithm to detect a wide range of edges in images.
678 void cannyEdge(const double radius_=0.0,const double sigma_=1.0,
679 const double lowerPercent_=0.1,const double upperPercent_=0.3);
680
681 // Accepts a lightweight Color Correction Collection
682 // (CCC) file which solely contains one or more color corrections and
683 // applies the correction to the image.
684 void cdl(const std::string &cdl_);
685
686 // Extract channel from image
687 void channel(const ChannelType channel_);
688
689 // Charcoal effect image (looks like charcoal sketch)
690 // The radius_ parameter specifies the radius of the Gaussian, in
691 // pixels, not counting the center pixel. The sigma_ parameter
692 // specifies the standard deviation of the Laplacian, in pixels.
693 void charcoal(const double radius_=0.0,const double sigma_=1.0);
694 void charcoalChannel(const ChannelType channel_,const double radius_=0.0,
695 const double sigma_=1.0);
696
697 // Chop image (remove vertical or horizontal subregion of image)
698 // FIXME: describe how geometry argument is used to select either
699 // horizontal or vertical subregion of image.
700 void chop(const Geometry &geometry_);
701
702 // Chromaticity blue primary point.
703 void chromaBluePrimary(const double x_,const double y_,const double z_);
704 void chromaBluePrimary(double *x_,double *y_,double *z_) const;
705
706 // Chromaticity green primary point.
707 void chromaGreenPrimary(const double x_,const double y_,const double z_);
708 void chromaGreenPrimary(double *x_,double *y_,double *z_) const;
709
710 // Chromaticity red primary point.
711 void chromaRedPrimary(const double x_,const double y_,const double z_);
712 void chromaRedPrimary(double *x_,double *y_,double *z_) const;
713
714 // Chromaticity white point.
715 void chromaWhitePoint(const double x_,const double y_,const double z_);
716 void chromaWhitePoint(double *x_,double *y_,double *z_) const;
717
718 // Set each pixel whose value is below zero to zero and any the
719 // pixel whose value is above the quantum range to the quantum range (e.g.
720 // 65535) otherwise the pixel value remains unchanged.
721 void clamp(void);
722 void clampChannel(const ChannelType channel_);
723
724 // Sets the image clip mask based on any clipping path information
725 // if it exists.
726 void clip(void);
727 void clipPath(const std::string pathname_,const bool inside_);
728
729 // Apply a color lookup table (CLUT) to the image.
730 void clut(const Image &clutImage_,const PixelInterpolateMethod method);
731 void clutChannel(const ChannelType channel_,const Image &clutImage_,
732 const PixelInterpolateMethod method);
733
734 // Colorize image with pen color, using specified percent alpha.
735 void colorize(const unsigned int alpha_,const Color &penColor_);
736
737 // Colorize image with pen color, using specified percent alpha
738 // for red, green, and blue quantums
739 void colorize(const unsigned int alphaRed_,const unsigned int alphaGreen_,
740 const unsigned int alphaBlue_,const Color &penColor_);
741
742 // Color at colormap position index_
743 void colorMap(const size_t index_,const Color &color_);
744 Color colorMap(const size_t index_) const;
745
746 // Apply a color matrix to the image channels. The user supplied
747 // matrix may be of order 1 to 5 (1x1 through 5x5).
748 void colorMatrix(const size_t order_,const double *color_matrix_);
749
750 // Compare current image with another image
751 // False is returned if the images are not identical.
752 bool compare(const Image &reference_) const;
753
754 // Compare current image with another image
755 // Returns the distortion based on the specified metric.
756 double compare(const Image &reference_,const MetricType metric_);
757 double compareChannel(const ChannelType channel_,
758 const Image &reference_,
759 const MetricType metric_ );
760
761 // Compare current image with another image
762 // Sets the distortion and returns the difference image.
763 Image compare(const Image &reference_,const MetricType metric_,
764 double *distortion);
765 Image compareChannel(const ChannelType channel_,const Image &reference_,
766 const MetricType metric_,double *distortion);
767
768 // Compose an image onto another at specified offset and using
769 // specified algorithm
770 void composite(const Image &compositeImage_,const Geometry &offset_,
771 const CompositeOperator compose_=InCompositeOp);
772 void composite(const Image &compositeImage_,const GravityType gravity_,
773 const CompositeOperator compose_=InCompositeOp);
774 void composite(const Image &compositeImage_,const ::ssize_t xOffset_,
775 const ::ssize_t yOffset_,const CompositeOperator compose_=InCompositeOp);
776
777 // Determines the connected-components of the image
778 void connectedComponents(const size_t connectivity_);
779
780 // Contrast image (enhance intensity differences in image)
781 void contrast(const bool sharpen_);
782
783 // A simple image enhancement technique that attempts to improve the
784 // contrast in an image by 'stretching' the range of intensity values
785 // it contains to span a desired range of values. It differs from the
786 // more sophisticated histogram equalization in that it can only apply a
787 // linear scaling function to the image pixel values. As a result the
788 // 'enhancement' is less harsh.
789 void contrastStretch(const double blackPoint_,const double whitePoint_);
790 void contrastStretchChannel(const ChannelType channel_,
791 const double blackPoint_,const double whitePoint_);
792
793 // Convolve image. Applies a user-specified convolution to the image.
794 // order_ represents the number of columns and rows in the filter kernel.
795 // kernel_ is an array of doubles representing the convolution kernel.
796 void convolve(const size_t order_,const double *kernel_);
797
798 // Copies pixels from the source image as defined by the geometry the
799 // destination image at the specified offset.
800 void copyPixels(const Image &source_,const Geometry &geometry_,
801 const Offset &offset_);
802
803 // Crop image (subregion of original image)
804 void crop(const Geometry &geometry_);
805
806 // Cycle image colormap
807 void cycleColormap(const ::ssize_t amount_);
808
809 // Converts cipher pixels to plain pixels.
810 void decipher(const std::string &passphrase_);
811
812 // Tagged image format define. Similar to the defineValue() method
813 // except that passing the flag_ value 'true' creates a value-less
814 // define with that format and key. Passing the flag_ value 'false'
815 // removes any existing matching definition. The method returns 'true'
816 // if a matching key exists, and 'false' if no matching key exists.
817 void defineSet(const std::string &magick_,const std::string &key_,
818 bool flag_);
819 bool defineSet(const std::string &magick_,const std::string &key_) const;
820
821 // Tagged image format define (set/access coder-specific option) The
822 // magick_ option specifies the coder the define applies to. The key_
823 // option provides the key specific to that coder. The value_ option
824 // provides the value to set (if any). See the defineSet() method if the
825 // key must be removed entirely.
826 void defineValue(const std::string &magick_,const std::string &key_,
827 const std::string &value_);
828 std::string defineValue(const std::string &magick_,
829 const std::string &key_) const;
830
831 // Removes skew from the image. Skew is an artifact that occurs in scanned
832 // images because of the camera being misaligned, imperfections in the
833 // scanning or surface, or simply because the paper was not placed
834 // completely flat when scanned. The value of threshold_ ranges from 0
835 // to QuantumRange.
836 void deskew(const double threshold_);
837
838 // Despeckle image (reduce speckle noise)
839 void despeckle(void);
840
841 // Display image on screen
842 void display(void);
843
844 // Distort image. distorts an image using various distortion methods, by
845 // mapping color lookups of the source image to a new destination image
846 // usally of the same size as the source image, unless 'bestfit' is set to
847 // true.
848 void distort(const DistortMethod method_,
849 const size_t numberArguments_,const double *arguments_,
850 const bool bestfit_=false);
851
852 // Draw on image using a single drawable
853 void draw(const Drawable &drawable_);
854
855 // Draw on image using a drawable list
856 void draw(const std::vector<Magick::Drawable> &drawable_);
857
858 // Edge image (hilight edges in image)
859 void edge(const double radius_=0.0);
860
861 // Emboss image (hilight edges with 3D effect)
862 // The radius_ parameter specifies the radius of the Gaussian, in
863 // pixels, not counting the center pixel. The sigma_ parameter
864 // specifies the standard deviation of the Laplacian, in pixels.
865 void emboss(const double radius_=0.0,const double sigma_=1.0);
866
867 // Converts pixels to cipher-pixels.
868 void encipher(const std::string &passphrase_);
869
870 // Enhance image (minimize noise)
871 void enhance(void);
872
873 // Equalize image (histogram equalization)
874 void equalize(void);
875
876 // Erase image to current "background color"
877 void erase(void);
878
879 // Apply a value with an arithmetic, relational, or logical operator.
880 void evaluate(const ChannelType channel_,
881 const MagickEvaluateOperator operator_,double rvalue_);
882
883 // Apply a value with an arithmetic, relational, or logical operator.
884 void evaluate(const ChannelType channel_,const MagickFunction function_,
885 const size_t number_parameters_,const double *parameters_);
886
887 // Apply a value with an arithmetic, relational, or logical operator.
888 void evaluate(const ChannelType channel_,const ::ssize_t x_,
889 const ::ssize_t y_,const size_t columns_,const size_t rows_,
890 const MagickEvaluateOperator operator_,const double rvalue_);
891
892 // Extend the image as defined by the geometry.
893 void extent(const Geometry &geometry_);
894 void extent(const Geometry &geometry_,const Color &backgroundColor);
895 void extent(const Geometry &geometry_,const Color &backgroundColor,
896 const GravityType gravity_);
897 void extent(const Geometry &geometry_,const GravityType gravity_);
898
899 // Flip image (reflect each scanline in the vertical direction)
900 void flip(void);
901
902 // Floodfill pixels matching color (within fuzz factor) of target
903 // pixel(x,y) with replacement alpha value.
904 void floodFillAlpha(const ::ssize_t x_,const ::ssize_t y_,
905 const unsigned int alpha_,const bool invert_=false);
906
907 // Floodfill designated area with replacement alpha value
908 void floodFillAlpha(const ssize_t x_,const ssize_t y_,
909 const unsigned int alpha_,const Color &target_,const bool invert_=false);
910
911 // Flood-fill color across pixels that match the color of the
912 // target pixel and are neighbors of the target pixel.
913 // Uses current fuzz setting when determining color match.
914 void floodFillColor(const Geometry &point_,const Color &fillColor_,
915 const bool invert_=false);
916 void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
917 const Color &fillColor_,const bool invert_=false);
918
919 // Flood-fill color across pixels starting at target-pixel and
920 // stopping at pixels matching specified border color.
921 // Uses current fuzz setting when determining color match.
922 void floodFillColor(const Geometry &point_,const Color &fillColor_,
923 const Color &borderColor_,const bool invert_=false);
924 void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
925 const Color &fillColor_,const Color &borderColor_,
926 const bool invert_=false);
927
928 // Flood-fill texture across pixels that match the color of the
929 // target pixel and are neighbors of the target pixel.
930 // Uses current fuzz setting when determining color match.
931 void floodFillTexture(const Geometry &point_,const Image &texture_,
932 const bool invert_=false);
933 void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
934 const Image &texture_,const bool invert_=false);
935
936 // Flood-fill texture across pixels starting at target-pixel and
937 // stopping at pixels matching specified border color.
938 // Uses current fuzz setting when determining color match.
939 void floodFillTexture(const Geometry &point_,const Image &texture_,
940 const Color &borderColor_,const bool invert_=false);
941 void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
942 const Image &texture_,const Color &borderColor_,
943 const bool invert_=false);
944
945 // Flop image (reflect each scanline in the horizontal direction)
946 void flop(void);
947
948 // Obtain font metrics for text string given current font,
949 // pointsize, and density settings.
950 void fontTypeMetrics(const std::string &text_,TypeMetric *metrics);
951
952 // Obtain multi line font metrics for text string given current font,
953 // pointsize, and density settings.
954 void fontTypeMetricsMultiline(const std::string &text_,
955 TypeMetric *metrics);
956
957 // Frame image
958 void frame(const Geometry &geometry_=frameGeometryDefault);
959 void frame(const size_t width_,const size_t height_,
960 const ::ssize_t innerBevel_=6,const ::ssize_t outerBevel_=6);
961
962 // Applies a mathematical expression to the image.
963 void fx(const std::string expression_);
964 void fx(const std::string expression_,const Magick::ChannelType channel_);
965
966 // Gamma correct image
967 void gamma(const double gamma_);
968 void gamma(const double gammaRed_,const double gammaGreen_,
969 const double gammaBlue_);
970
971 // Gaussian blur image
972 // The number of neighbor pixels to be included in the convolution
973 // mask is specified by 'radius_'. The standard deviation of the
974 // gaussian bell curve is specified by 'sigma_'.
975 void gaussianBlur(const double radius_,const double sigma_);
976 void gaussianBlurChannel(const ChannelType channel_,const double radius_,
977 const double sigma_);
978
979 // Transfers read-only pixels from the image to the pixel cache as
980 // defined by the specified region
981 const Quantum *getConstPixels(const ::ssize_t x_, const ::ssize_t y_,
982 const size_t columns_,const size_t rows_) const;
983
984 // Obtain immutable image pixel metacontent (valid for PseudoClass images)
985 const void *getConstMetacontent(void) const;
986
987 // Obtain mutable image pixel metacontent (valid for PseudoClass images)
988 void *getMetacontent(void);
989
990 // Transfers pixels from the image to the pixel cache as defined
991 // by the specified region. Modified pixels may be subsequently
992 // transferred back to the image via syncPixels. This method is
993 // valid for DirectClass images.
994 Quantum *getPixels(const ::ssize_t x_,const ::ssize_t y_,
995 const size_t columns_,const size_t rows_);
996
997 // Converts the colors in the image to gray.
998 void grayscale(const PixelIntensityMethod method_);
999
1000 // Apply a color lookup table (Hald CLUT) to the image.
1001 void haldClut(const Image &clutImage_);
1002
1003 // Identifies lines in the image.
1004 void houghLine(const size_t width_,const size_t height_,
1005 const size_t threshold_=40);
1006
1007 // Identifies the potential color type of the image. This method can be
1008 // used to detect if the type can be changed to GrayScale.
1009 ImageType identifyType(void) const;
1010
1011 // Implode image (special effect)
1012 void implode(const double factor_);
1013
1014 // Implements the inverse discrete Fourier transform (DFT) of the image
1015 // either as a magnitude / phase or real / imaginary image pair.
1016 void inverseFourierTransform(const Image &phase_);
1017 void inverseFourierTransform(const Image &phase_,const bool magnitude_);
1018
1019 // An edge preserving noise reduction filter.
1020 void kuwahara(const double radius_=0.0,const double sigma_=1.0);
1021 void kuwaharaChannel(const ChannelType channel_,const double radius_=0.0,
1022 const double sigma_=1.0);
1023
1024 // Level image. Adjust the levels of the image by scaling the
1025 // colors falling between specified white and black points to the
1026 // full available quantum range. The parameters provided represent
1027 // the black, mid (gamma), and white points. The black point
1028 // specifies the darkest color in the image. Colors darker than
1029 // the black point are set to zero. Mid point (gamma) specifies a
1030 // gamma correction to apply to the image. White point specifies
1031 // the lightest color in the image. Colors brighter than the
1032 // white point are set to the maximum quantum value. The black and
1033 // white point have the valid range 0 to QuantumRange while mid (gamma)
1034 // has a useful range of 0 to ten.
1035 void level(const double blackPoint_,const double whitePoint_,
1036 const double gamma_=1.0);
1037 void levelChannel(const ChannelType channel_,const double blackPoint_,
1038 const double whitePoint_,const double gamma_=1.0);
1039
1040 // Maps the given color to "black" and "white" values, linearly spreading
1041 // out the colors, and level values on a channel by channel bases, as
1042 // per level(). The given colors allows you to specify different level
1043 // ranges for each of the color channels separately.
1044 void levelColors(const Color &blackColor_,const Color &whiteColor_,
1045 const bool invert_=true);
1046 void levelColorsChannel(const ChannelType channel_,
1047 const Color &blackColor_,const Color &whiteColor_,
1048 const bool invert_=true);
1049
1050 // Levelize applies the reversed level operation to just the specific
1051 // channels specified.It compresses the full range of color values, so
1052 // that they lie between the given black and white points. Gamma is
1053 // applied before the values are mapped.
1054 void levelize(const double blackPoint_,const double whitePoint_,
1055 const double gamma_=1.0);
1056 void levelizeChannel(const ChannelType channel_,const double blackPoint_,
1057 const double whitePoint_,const double gamma_=1.0);
1058
1059 // Discards any pixels below the black point and above the white point and
1060 // levels the remaining pixels.
1061 void linearStretch(const double blackPoint_,const double whitePoint_);
1062
1063 // Rescales image with seam carving.
1064 void liquidRescale(const Geometry &geometry_);
1065
1066 // Local contrast enhancement
1067 void localContrast(const double radius_,const double strength_);
1068 void localContrastChannel(const ChannelType channel_,const double radius_,
1069 const double strength_);
1070
1071 // Magnify image by integral size
1072 void magnify(void);
1073
1074 // Remap image colors with closest color from reference image
1075 void map(const Image &mapImage_,const bool dither_=false);
1076
1077 // Delineate arbitrarily shaped clusters in the image.
1078 void meanShift(const size_t width_,const size_t height_,
1079 const double color_distance_);
1080
1081 // Filter image by replacing each pixel component with the median
1082 // color in a circular neighborhood
1083 void medianFilter(const double radius_=0.0);
1084
1085 // Reduce image by integral size
1086 void minify(void);
1087
1088 // Modulate percent hue, saturation, and brightness of an image
1089 void modulate(const double brightness_,const double saturation_,
1090 const double hue_);
1091
1092 // Returns the normalized moments of one or more image channels.
1093 ImageMoments moments(void) const;
1094
1095 // Applies a kernel to the image according to the given mophology method.
1096 void morphology(const MorphologyMethod method_,const std::string kernel_,
1097 const ssize_t iterations_=1);
1098 void morphology(const MorphologyMethod method_,
1099 const KernelInfoType kernel_,const std::string arguments_,
1100 const ssize_t iterations_=1);
1101 void morphologyChannel(const ChannelType channel_,
1102 const MorphologyMethod method_,const std::string kernel_,
1103 const ssize_t iterations_=1);
1104 void morphologyChannel(const ChannelType channel_,
1105 const MorphologyMethod method_,const KernelInfoType kernel_,
1106 const std::string arguments_,const ssize_t iterations_=1);
1107
1108 // Motion blur image with specified blur factor
1109 // The radius_ parameter specifies the radius of the Gaussian, in
1110 // pixels, not counting the center pixel. The sigma_ parameter
1111 // specifies the standard deviation of the Laplacian, in pixels.
1112 // The angle_ parameter specifies the angle the object appears
1113 // to be comming from (zero degrees is from the right).
1114 void motionBlur(const double radius_,const double sigma_,
1115 const double angle_);
1116
1117 // Negate colors in image. Set grayscale to only negate grayscale
1118 // values in image.
1119 void negate(const bool grayscale_=false);
1120 void negateChannel(const ChannelType channel_,const bool grayscale_=false);
1121
1122 // Normalize image (increase contrast by normalizing the pixel
1123 // values to span the full range of color values)
1124 void normalize(void);
1125
1126 // Oilpaint image (image looks like oil painting)
1127 void oilPaint(const double radius_=0.0,const double sigma=1.0);
1128
1129 // Change color of opaque pixel to specified pen color.
1130 void opaque(const Color &opaqueColor_,const Color &penColor_,
1131 const bool invert_=false);
1132
1133 // Perform a ordered dither based on a number of pre-defined dithering
1134 // threshold maps, but over multiple intensity levels.
1135 void orderedDither(std::string thresholdMap_);
1136 void orderedDitherChannel(const ChannelType channel_,
1137 std::string thresholdMap_);
1138
1139 // Set each pixel whose value is less than epsilon to epsilon or
1140 // -epsilon (whichever is closer) otherwise the pixel value remains
1141 // unchanged.
1142 void perceptible(const double epsilon_);
1143 void perceptibleChannel(const ChannelType channel_,const double epsilon_);
1144
1145 // Returns the perceptual hash for this image.
1146 Magick::ImagePerceptualHash perceptualHash() const;
1147
1148 // Ping is similar to read except only enough of the image is read
1149 // to determine the image columns, rows, and filesize. Access the
1150 // columns(), rows(), and fileSize() attributes after invoking
1151 // ping. The image data is not valid after calling ping.
1152 void ping(const std::string &imageSpec_);
1153
1154 // Ping is similar to read except only enough of the image is read
1155 // to determine the image columns, rows, and filesize. Access the
1156 // columns(), rows(), and fileSize() attributes after invoking
1157 // ping. The image data is not valid after calling ping.
1158 void ping(const Blob &blob_);
1159
1160 // Get/set pixel color at location x & y.
1161 void pixelColor(const ::ssize_t x_,const ::ssize_t y_,const Color &color_);
1162 Color pixelColor(const ::ssize_t x_,const ::ssize_t y_ ) const;
1163
1164 // Simulates a Polaroid picture.
1165 void polaroid(const std::string &caption_,const double angle_,
1166 const PixelInterpolateMethod method_);
1167
1168 // Reduces the image to a limited number of colors for a "poster" effect.
1169 void posterize(const size_t levels_,const DitherMethod method_);
1170 void posterizeChannel(const ChannelType channel_,const size_t levels_,
1171 const DitherMethod method_);
1172
1173 // Execute a named process module using an argc/argv syntax similar to
1174 // that accepted by a C 'main' routine. An exception is thrown if the
1175 // requested process module doesn't exist, fails to load, or fails during
1176 // execution.
1177 void process(std::string name_,const ::ssize_t argc_,const char **argv_);
1178
1179 // Add or remove a named profile to/from the image. Remove the
1180 // profile by passing an empty Blob (e.g. Blob()). Valid names are
1181 // "*", "8BIM", "ICM", "IPTC", or a user/format-defined profile name.
1182 void profile(const std::string name_,const Blob &colorProfile_);
1183
1184 // Retrieve a named profile from the image. Valid names are:
1185 // "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC"
1186 // or an existing user/format-defined profile name.
1187 Blob profile(const std::string name_) const;
1188
1189 // Quantize image (reduce number of colors)
1190 void quantize(const bool measureError_=false);
1191
1192 // Raise image (lighten or darken the edges of an image to give a
1193 // 3-D raised or lowered effect)
1194 void raise(const Geometry &geometry_=raiseGeometryDefault,
1195 const bool raisedFlag_=false);
1196
1197 // Random threshold image.
1198 //
1199 // Changes the value of individual pixels based on the intensity
1200 // of each pixel compared to a random threshold. The result is a
1201 // low-contrast, two color image.
1202 void randomThreshold(const double low_,const double high_);
1203 void randomThresholdChannel(const ChannelType channel_,const double low_,
1204 const double high_);
1205
1206 // Read single image frame from in-memory BLOB
1207 void read(const Blob &blob_);
1208
1209 // Read single image frame of specified size from in-memory BLOB
1210 void read(const Blob &blob_,const Geometry &size_);
1211
1212 // Read single image frame of specified size and depth from
1213 // in-memory BLOB
1214 void read(const Blob &blob_,const Geometry &size_,const size_t depth_);
1215
1216 // Read single image frame of specified size, depth, and format
1217 // from in-memory BLOB
1218 void read(const Blob &blob_,const Geometry &size_,const size_t depth_,
1219 const std::string &magick_);
1220
1221 // Read single image frame of specified size, and format from
1222 // in-memory BLOB
1223 void read(const Blob &blob_,const Geometry &size_,
1224 const std::string &magick_);
1225
1226 // Read single image frame of specified size into current object
1227 void read(const Geometry &size_,const std::string &imageSpec_);
1228
1229 // Read single image frame from an array of raw pixels, with
1230 // specified storage type (ConstituteImage), e.g.
1231 // image.read( 640, 480, "RGB", 0, pixels );
1232 void read(const size_t width_,const size_t height_,const std::string &map_,
1233 const StorageType type_,const void *pixels_);
1234
1235 // Read single image frame into current object
1236 void read(const std::string &imageSpec_);
1237
1238 // Associate a mask with the image. The mask must be the same dimensions
1239 // as the image. Pass an invalid image to unset an existing mask.
1240 void readMask(const Image &mask_);
1241 Image readMask(void) const;
1242
1243 // Transfers one or more pixel components from a buffer or file
1244 // into the image pixel cache of an image.
1245 // Used to support image decoders.
1246 void readPixels(const QuantumType quantum_,const unsigned char *source_);
1247
1248 // Reduce noise in image using a noise peak elimination filter
1249 void reduceNoise(void);
1250 void reduceNoise(const size_t order_);
1251
1252 // Resets the image page canvas and position.
1253 void repage();
1254
1255 // Resize image in terms of its pixel size.
1256 void resample(const Point &density_);
1257
1258 // Resize image to specified size.
1259 void resize(const Geometry &geometry_);
1260
1261 // Roll image (rolls image vertically and horizontally) by specified
1262 // number of columnms and rows)
1263 void roll(const Geometry &roll_);
1264 void roll(const size_t columns_,const size_t rows_);
1265
1266 // Rotate image clockwise by specified number of degrees. Specify a
1267 // negative number for degrees to rotate counter-clockwise.
1268 void rotate(const double degrees_);
1269
1270 // Rotational blur image.
1271 void rotationalBlur(const double angle_);
1272 void rotationalBlurChannel(const ChannelType channel_,const double angle_);
1273
1274 // Resize image by using pixel sampling algorithm
1275 void sample(const Geometry &geometry_);
1276
1277 // Resize image by using simple ratio algorithm
1278 void scale(const Geometry &geometry_);
1279
1280 // Segment (coalesce similar image components) by analyzing the
1281 // histograms of the color components and identifying units that
1282 // are homogeneous with the fuzzy c-means technique. Also uses
1283 // QuantizeColorSpace and Verbose image attributes
1284 void segment(const double clusterThreshold_=1.0,
1285 const double smoothingThreshold_=1.5);
1286
1287 // Selectively blur pixels within a contrast threshold. It is similar to
1288 // the unsharpen mask that sharpens everything with contrast above a
1289 // certain threshold.
1290 void selectiveBlur(const double radius_,const double sigma_,
1291 const double threshold_);
1292 void selectiveBlurChannel(const ChannelType channel_,const double radius_,
1293 const double sigma_,const double threshold_);
1294
1295 // Separates a channel from the image and returns it as a grayscale image.
1296 Image separate(const ChannelType channel_) const;
1297
1298 // Applies a special effect to the image, similar to the effect achieved in
1299 // a photo darkroom by sepia toning. Threshold ranges from 0 to
1300 // QuantumRange and is a measure of the extent of the sepia toning.
1301 // A threshold of 80% is a good starting point for a reasonable tone.
1302 void sepiaTone(const double threshold_);
1303
1304 // Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError
1305 // in the current image. False is returned if the images are not identical.
1306 bool setColorMetric(const Image &reference_);
1307
1308 // Allocates a pixel cache region to store image pixels as defined
1309 // by the region rectangle. This area is subsequently transferred
1310 // from the pixel cache to the image via syncPixels.
1311 Quantum *setPixels(const ::ssize_t x_, const ::ssize_t y_,
1312 const size_t columns_,const size_t rows_);
1313
1314 // Shade image using distant light source
1315 void shade(const double azimuth_=30,const double elevation_=30,
1316 const bool colorShading_=false);
1317
1318 // Simulate an image shadow
1319 void shadow(const double percentAlpha_=80.0,const double sigma_=0.5,
1320 const ssize_t x_=5,const ssize_t y_=5);
1321
1322 // Sharpen pixels in image
1323 // The radius_ parameter specifies the radius of the Gaussian, in
1324 // pixels, not counting the center pixel. The sigma_ parameter
1325 // specifies the standard deviation of the Laplacian, in pixels.
1326 void sharpen(const double radius_=0.0,const double sigma_=1.0);
1327 void sharpenChannel(const ChannelType channel_,const double radius_=0.0,
1328 const double sigma_=1.0);
1329
1330 // Shave pixels from image edges.
1331 void shave(const Geometry &geometry_);
1332
1333 // Shear image (create parallelogram by sliding image by X or Y axis)
1334 void shear(const double xShearAngle_,const double yShearAngle_);
1335
1336 // adjust the image contrast with a non-linear sigmoidal contrast algorithm
1337 void sigmoidalContrast(const bool sharpen_,const double contrast,
1338 const double midpoint=QuantumRange/2.0);
1339
1340 // Image signature. Set force_ to true in order to re-calculate
1341 // the signature regardless of whether the image data has been
1342 // modified.
1343 std::string signature(const bool force_=false) const;
1344
1345 // Simulates a pencil sketch. We convolve the image with a Gaussian
1346 // operator of the given radius and standard deviation (sigma). For
1347 // reasonable results, radius should be larger than sigma. Use a
1348 // radius of 0 and SketchImage() selects a suitable radius for you.
1349 void sketch(const double radius_=0.0,const double sigma_=1.0,
1350 const double angle_=0.0);
1351
1352 // Solarize image (similar to effect seen when exposing a
1353 // photographic film to light during the development process)
1354 void solarize(const double factor_=50.0);
1355
1356 // Sparse color image, given a set of coordinates, interpolates the colors
1357 // found at those coordinates, across the whole image, using various
1358 // methods.
1359 void sparseColor(const ChannelType channel_,
1360 const SparseColorMethod method_,const size_t numberArguments_,
1361 const double *arguments_);
1362
1363 // Splice the background color into the image.
1364 void splice(const Geometry &geometry_);
1365 void splice(const Geometry &geometry_,const Color &backgroundColor_);
1366 void splice(const Geometry &geometry_,const Color &backgroundColor_,
1367 const GravityType gravity_);
1368
1369 // Spread pixels randomly within image by specified ammount
1370 void spread(const double amount_=3.0);
1371
1372 // Returns the statistics for this image.
1373 Magick::ImageStatistics statistics() const;
1374
1375 // Add a digital watermark to the image (based on second image)
1376 void stegano(const Image &watermark_);
1377
1378 // Create an image which appears in stereo when viewed with
1379 // red-blue glasses (Red image on left, blue on right)
1380 void stereo(const Image &rightImage_);
1381
1382 // Strip strips an image of all profiles and comments.
1383 void strip(void);
1384
1385 // Search for the specified image at EVERY possible location in this image.
1386 // This is slow! very very slow.. It returns a similarity image such that
1387 // an exact match location is completely white and if none of the pixels
1388 // match, black, otherwise some gray level in-between.
1389 Image subImageSearch(const Image &reference_,const MetricType metric_,
1390 Geometry *offset_,double *similarityMetric_,
1391 const double similarityThreshold=(-1.0));
1392
1393 // Swirl image (image pixels are rotated by degrees)
1394 void swirl(const double degrees_);
1395
1396 // Transfers the image cache pixels to the image.
1397 void syncPixels(void);
1398
1399 // Channel a texture on image background
1400 void texture(const Image &texture_);
1401
1402 // Threshold image
1403 void threshold(const double threshold_);
1404
1405 // Resize image to thumbnail size
1406 void thumbnail(const Geometry &geometry_);
1407
1408 // Applies a color vector to each pixel in the image. The length of the
1409 // vector is 0 for black and white and at its maximum for the midtones.
1410 // The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5))))
1411 void tint(const std::string opacity_);
1412
1413 // Origin of coordinate system to use when annotating with text or drawing
1414 void transformOrigin(const double x_,const double y_);
1415
1416 // Reset transformation parameters to default
1417 void transformReset(void);
1418
1419 // Scale to use when annotating with text or drawing
1420 void transformScale(const double sx_,const double sy_);
1421
1422 // Add matte image to image, setting pixels matching color to
1423 // transparent
1424 void transparent(const Color &color_,const bool inverse_=false);
1425
1426 // Add matte image to image, for all the pixels that lies in between
1427 // the given two color
1428 void transparentChroma(const Color &colorLow_,const Color &colorHigh_);
1429
1430 // Creates a horizontal mirror image by reflecting the pixels around the
1431 // central y-axis while rotating them by 90 degrees.
1432 void transpose(void);
1433
1434 // Creates a vertical mirror image by reflecting the pixels around the
1435 // central x-axis while rotating them by 270 degrees.
1436 void transverse(void);
1437
1438 // Trim edges that are the background color from the image
1439 void trim(void);
1440
1441 // Returns the unique colors of an image.
1442 Image uniqueColors(void) const;
1443
1444 // Replace image with a sharpened version of the original image
1445 // using the unsharp mask algorithm.
1446 // radius_
1447 // the radius of the Gaussian, in pixels, not counting the
1448 // center pixel.
1449 // sigma_
1450 // the standard deviation of the Gaussian, in pixels.
1451 // amount_
1452 // the percentage of the difference between the original and
1453 // the blur image that is added back into the original.
1454 // threshold_
1455 // the threshold in pixels needed to apply the diffence amount.
1456 void unsharpmask(const double radius_,const double sigma_,
1457 const double amount_,const double threshold_);
1458 void unsharpmaskChannel(const ChannelType channel_,const double radius_,
1459 const double sigma_,const double amount_,const double threshold_);
1460
1461 // Softens the edges of the image in vignette style.
1462 void vignette(const double radius_=0.0,const double sigma_=1.0,
1463 const ssize_t x_=0,const ssize_t y_=0);
1464
1465 // Map image pixels to a sine wave
1466 void wave(const double amplitude_=25.0,const double wavelength_=150.0);
1467
1468 // Removes noise from the image using a wavelet transform.
1469 void waveletDenoise(const double threshold_,const double softness_);
1470
1471 // Forces all pixels above the threshold into white while leaving all
1472 // pixels at or below the threshold unchanged.
1473 void whiteThreshold(const std::string &threshold_);
1474 void whiteThresholdChannel(const ChannelType channel_,
1475 const std::string &threshold_);
1476
1477 // Write single image frame to in-memory BLOB, with optional
1478 // format and adjoin parameters.
1479 void write(Blob *blob_);
1480 void write(Blob *blob_,const std::string &magick_);
1481 void write(Blob *blob_,const std::string &magick_,const size_t depth_);
1482
1483 // Write single image frame to an array of pixels with storage
1484 // type specified by user (DispatchImage), e.g.
1485 // image.write( 0, 0, 640, 1, "RGB", 0, pixels );
1486 void write(const ::ssize_t x_,const ::ssize_t y_,const size_t columns_,
1487 const size_t rows_,const std::string &map_,const StorageType type_,
1488 void *pixels_);
1489
1490 // Write single image frame to a file
1491 void write(const std::string &imageSpec_);
1492
1493 // Associate a mask with the image. The mask must be the same dimensions
1494 // as the image. Pass an invalid image to unset an existing mask.
1495 void writeMask(const Image &mask_);
1496 Image writeMask(void) const;
1497
1498 // Transfers one or more pixel components from the image pixel
1499 // cache to a buffer or file.
1500 // Used to support image encoders.
1501 void writePixels(const QuantumType quantum_,unsigned char *destination_);
1502
1503 // Zoom image to specified size.
1504 void zoom(const Geometry &geometry_);
1505
1507 //
1508 // No user-serviceable parts beyond this point
1509 //
1511
1512 // Construct with MagickCore::Image and default options
1513 Image(MagickCore::Image *image_);
1514
1515 // Retrieve Image*
1516 MagickCore::Image *&image(void);
1517 const MagickCore::Image *constImage(void) const;
1518
1519 // Retrieve ImageInfo*
1520 MagickCore::ImageInfo *imageInfo(void);
1521 const MagickCore::ImageInfo *constImageInfo(void) const;
1522
1523 // Retrieve Options*
1524 Options *options(void);
1525 const Options *constOptions(void) const;
1526
1527 // Retrieve QuantizeInfo*
1528 MagickCore::QuantizeInfo *quantizeInfo(void);
1529 const MagickCore::QuantizeInfo *constQuantizeInfo(void) const;
1530
1531 // Prepare to update image (copy if reference > 1)
1532 void modifyImage(void);
1533
1534 // Replace current image (reference counted)
1535 MagickCore::Image *replaceImage(MagickCore::Image *replacement_);
1536
1537 private:
1538
1539 void floodFill(const ssize_t x_,const ssize_t y_,
1540 const Magick::Image *fillPattern_,const Color &fill_,
1541 const PixelInfo *target,const bool invert_);
1542
1543 void mask(const Image &mask_,const PixelMask);
1544 Image mask(const PixelMask) const;
1545
1546 void read(MagickCore::Image *image,
1547 MagickCore::ExceptionInfo *exceptionInfo);
1548
1549 ImageRef *_imgRef;
1550 };
1551
1552 } // end of namespace Magick
1553
1554 #endif // Magick_Image_header
Magick::borderGeometryDefault
MagickPPExport const char * borderGeometryDefault
Definition: Image.cpp:32
Magick::raiseGeometryDefault
MagickPPExport const char * raiseGeometryDefault
Definition: Image.cpp:34
Magick::ImagePerceptualHash
Definition: Statistic.h:243
Magick::Point
Definition: Geometry.h:206
Magick::Options
Definition: Options.h:28
Magick::ImageMoments
Definition: Statistic.h:218
Statistic.h
Magick::ImageRef
Definition: ImageRef.h:26
TypeMetric.h
Drawable.h
Magick::Blob
Definition: Blob.h:20
MagickPPExport
#define MagickPPExport
Definition: Include.h:281
Magick::Offset
Definition: Geometry.h:149
Magick::Color
Definition: Color.h:34
Magick::frameGeometryDefault
MagickPPExport const char * frameGeometryDefault
Definition: Image.cpp:33
Magick::DrawableAffine
Definition: Drawable.h:224
Magick::Geometry
Definition: Geometry.h:35
Color.h
Include.h
Magick::ImageStatistics
Definition: Statistic.h:281
Magick::Drawable
Definition: Drawable.h:118
Magick::Image
class MagickPPExport Image
Definition: Drawable.h:720
Magick
Definition: Blob.h:15
Blob.h
Exception.h
Magick::Image
Definition: Image.h:53
Magick::TypeMetric
Definition: TypeMetric.h:19
Geometry.h