22

✏️ Editing: Image.h

// This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
// Copyright Dirk Lemstra 2013-2015
//
// Definition of Image, the representation of a single image in Magick++
//

#if !defined(Magick_Image_header)
#define Magick_Image_header

#include "Magick++/Include.h"
#include <string>
#include <list>
#include "Magick++/Blob.h"
#include "Magick++/ChannelMoments.h"
#include "Magick++/Color.h"
#include "Magick++/Drawable.h"
#include "Magick++/Exception.h"
#include "Magick++/Geometry.h"
#include "Magick++/TypeMetric.h"

namespace Magick
{
  // Forward declarations
  class Options;
  class ImageRef;

extern MagickPPExport const char *borderGeometryDefault;
  extern MagickPPExport const char *frameGeometryDefault;
  extern MagickPPExport const char *raiseGeometryDefault;

// Compare two Image objects regardless of LHS/RHS
  // Image sizes and signatures are used as basis of comparison
  MagickPPExport int operator ==
    (const Magick::Image &left_,const Magick::Image &right_);
  MagickPPExport int operator !=
    (const Magick::Image &left_,const Magick::Image &right_);
  MagickPPExport int operator >
    (const Magick::Image &left_,const Magick::Image &right_);
  MagickPPExport int operator <
    (const Magick::Image &left_,const Magick::Image &right_);
  MagickPPExport int operator >=
    (const Magick::Image &left_,const Magick::Image &right_);
  MagickPPExport int operator <=
    (const Magick::Image &left_,const Magick::Image &right_);

//
  // Image is the representation of an image. In reality, it actually
  // a handle object which contains a pointer to a shared reference
  // object (ImageRef). As such, this object is extremely space efficient.
  //
  class MagickPPExport Image
  {
  public:

// Obtain image statistics. Statistics are normalized to the range
    // of 0.0 to 1.0 and are output to the specified ImageStatistics
    // structure.
    typedef struct _ImageChannelStatistics
    {
      /* Minimum value observed */
      double maximum;
      /* Maximum value observed */
      double minimum;
      /* Average (mean) value observed */
      double mean;
      /* Standard deviation, sqrt(variance) */
      double standard_deviation;
      /* Variance */
      double variance;
      /* Kurtosis */
      double kurtosis;
      /* Skewness */
      double skewness;
    } ImageChannelStatistics;

typedef struct _ImageStatistics
    {
      ImageChannelStatistics red;
      ImageChannelStatistics green;
      ImageChannelStatistics blue;
      ImageChannelStatistics opacity;
    } ImageStatistics;

// Default constructor
    Image(void);

// Construct Image from in-memory BLOB
    Image(const Blob &blob_);

// Construct Image of specified size from in-memory BLOB
    Image(const Blob &blob_,const Geometry &size_);

// Construct Image of specified size and depth from in-memory BLOB
    Image(const Blob &blob_,const Geometry &size_,const size_t depth_);

// Construct Image of specified size, depth, and format from
    // in-memory BLOB
    Image(const Blob &blob_,const Geometry &size_,const size_t depth_,
      const std::string &magick_);

// Construct Image of specified size, and format from in-memory BLOB
    Image(const Blob &blob_,const Geometry &size_,const std::string &magick_);

// Construct a blank image canvas of specified size and color
    Image(const Geometry &size_,const Color &color_);

// Copy constructor
    Image(const Image &image_);

// Copy constructor to copy part of the image
    Image(const Image &image_,const Geometry &geometry_);

// Construct an image based on an array of raw pixels, of
    // specified type and mapping, in memory
    Image(const size_t width_,const size_t height_,const std::string &map_,
      const StorageType type_,const void *pixels_);

// Construct from image file or image specification
    Image(const std::string &imageSpec_);

// Destructor
    virtual ~Image();

// Assignment operator
    Image& operator=(const Image &image_);

// Join images into a single multi-image file
    void adjoin(const bool flag_);
    bool adjoin(void) const;

// Anti-alias Postscript and TrueType fonts (default true)
    void antiAlias(const bool flag_);
    bool antiAlias(void) const;

// Time in 1/100ths of a second which must expire before
    // displaying the next image in an animated sequence.
    void animationDelay(const size_t delay_);
    size_t animationDelay(void) const;

// Number of iterations to loop an animation (e.g. Netscape loop
    // extension) for.
    void animationIterations(const size_t iterations_);
    size_t animationIterations(void) const;

// Lessen (or intensify) when adding noise to an image.
    void attenuate(const double attenuate_);

// Image background color
    void backgroundColor(const Color &color_);
    Color backgroundColor(void) const;

// Name of texture image to tile onto the image background
    void backgroundTexture(const std::string &backgroundTexture_);
    std::string backgroundTexture(void) const;

// Base image width (before transformations)
    size_t baseColumns(void) const;

// Base image filename (before transformations)
    std::string baseFilename(void) const;

// Base image height (before transformations)
    size_t baseRows(void) const;

// Use black point compensation.
    void blackPointCompensation(const bool flag_);
    bool blackPointCompensation(void) const;

// Image border color
    void borderColor(const Color &color_);
    Color borderColor(void) const;

// Return smallest bounding box enclosing non-border pixels. The
    // current fuzz value is used when discriminating between pixels.
    // This is the crop bounding box used by crop(Geometry(0,0));
    Geometry boundingBox(void) const;

// Text bounding-box base color (default none)
    void boxColor(const Color &boxColor_);
    Color boxColor(void) const;

// This method is now deprecated. Please use ResourceLimits instead.
    static void cacheThreshold(const size_t threshold_);

// Image class (DirectClass or PseudoClass)
    // NOTE: setting a DirectClass image to PseudoClass will result in
    // the loss of color information if the number of colors in the
    // image is greater than the maximum palette size (either 256 or
    // 65536 entries depending on the value of MAGICKCORE_QUANTUM_DEPTH when
    // ImageMagick was built).
    void classType(const ClassType class_);
    ClassType classType(void) const;

// Associate a clip mask with the image. The clip mask must be the
    // same dimensions as the image. Pass an invalid image to unset an
    // existing clip mask.
    void clipMask(const Image &clipMask_);
    Image clipMask(void) const;

// Colors within this distance are considered equal
    void colorFuzz(const double fuzz_);
    double colorFuzz(void) const;

// Colormap size (number of colormap entries)
    void colorMapSize(const size_t entries_);
    size_t colorMapSize(void) const;

// Image Color Space
    void colorSpace(const ColorspaceType colorSpace_);
    ColorspaceType colorSpace(void) const;

void colorspaceType(const ColorspaceType colorSpace_);
    ColorspaceType colorspaceType(void) const;

// Image width
    size_t columns(void) const;

// Comment image (add comment string to image)
    void comment(const std::string &comment_);
    std::string comment(void) const;

// Composition operator to be used when composition is implicitly
    // used (such as for image flattening).
    void compose(const CompositeOperator compose_);
    CompositeOperator compose(void) const;

// Compression type
    void compressType(const CompressionType compressType_);
    CompressionType compressType(void) const;

// Enable printing of debug messages from ImageMagick
    void debug(const bool flag_);
    bool debug(void) const;

// Vertical and horizontal resolution in pixels of the image
    void density(const Geometry &geomery_);
    Geometry density(void) const;

// Image depth (bits allocated to red/green/blue components)
    void depth(const size_t depth_);
    size_t depth(void) const;

// Tile names from within an image montage
    std::string directory(void) const;

// Endianness (little like Intel or big like SPARC) for image
    // formats which support endian-specific options.
    void endian(const EndianType endian_);
    EndianType endian(void) const;

// Exif profile (BLOB)
    void exifProfile(const Blob &exifProfile_);
    Blob exifProfile(void) const;

// Image file name
    void fileName(const std::string &fileName_);
    std::string fileName(void) const;

// Number of bytes of the image on disk
    off_t fileSize(void) const;

// Color to use when filling drawn objects
    void fillColor(const Color &fillColor_);
    Color fillColor(void) const;

// Rule to use when filling drawn objects
    void fillRule(const FillRule &fillRule_);
    FillRule fillRule(void) const;

// Pattern to use while filling drawn objects.
    void fillPattern(const Image &fillPattern_);
    Image fillPattern(void) const;

// Filter to use when resizing image
    void filterType(const FilterTypes filterType_);
    FilterTypes filterType(void) const;

// Text rendering font
    void font(const std::string &font_);
    std::string font(void) const;

// Font family
    void fontFamily(const std::string &family_);
    std::string fontFamily(void) const;

// Font point size
    void fontPointsize(const double pointSize_);
    double fontPointsize(void) const;

// Font style
    void fontStyle(const StyleType style_);
    StyleType fontStyle(void) const;

// Font weight
    void fontWeight(const size_t weight_);
    size_t fontWeight(void) const;

// Long image format description
    std::string format(void) const;

// Formats the specified expression
    // More info here: https://imagemagick.org/script/escape.php
    std::string formatExpression(const std::string expression);

// Gamma level of the image
    double gamma(void) const;

// Preferred size of the image when encoding
    Geometry geometry(void) const;

// GIF disposal method
    void gifDisposeMethod(const size_t disposeMethod_);
    size_t gifDisposeMethod(void) const;

// When comparing images, emphasize pixel differences with this color.
    void highlightColor(const Color color_);

// ICC color profile (BLOB)
    void iccColorProfile(const Blob &colorProfile_);
    Blob iccColorProfile(void) const;

// Type of interlacing to use
    void interlaceType(const InterlaceType interlace_);
    InterlaceType interlaceType(void) const;

// Pixel color interpolation method to use
    void interpolate(const InterpolatePixelMethod interpolate_);
    InterpolatePixelMethod interpolate(void) const;

// IPTC profile (BLOB)
    void iptcProfile(const Blob &iptcProfile_);
    Blob iptcProfile(void) const;

// Returns true if none of the pixels in the image have an alpha value
    // other than OpaqueAlpha (QuantumRange).
    bool isOpaque(void) const;

// Does object contain valid image?
    void isValid(const bool isValid_);
    bool isValid(void) const;

// Image label
    void label(const std::string &label_);
    std::string label(void) const;

// Stroke width for drawing vector objects (default one)
    // This method is now deprecated. Please use strokeWidth instead.
    void lineWidth(const double lineWidth_);
    double lineWidth(void) const;

// When comparing images, de-emphasize pixel differences with this color.
    void lowlightColor(const Color color_);

// File type magick identifier (.e.g "GIF")
    void magick(const std::string &magick_);
    std::string magick(void) const;

// Associate a mask with the image. The mask must be the same dimensions
    // as the image. Pass an invalid image to unset an existing clip mask.
    void mask(const Image &mask_);
    Image mask(void) const;

// Image supports transparency (matte channel)
    void matte(const bool matteFlag_);
    bool matte(void) const;

// Transparent color
    void matteColor(const Color &matteColor_);
    Color matteColor(void) const;

// The mean error per pixel computed when an image is color reduced
    double meanErrorPerPixel(void) const;

// Image modulus depth (minimum number of bits required to support
    // red/green/blue components without loss of accuracy)
    void modulusDepth(const size_t modulusDepth_);
    size_t modulusDepth(void) const;

// Transform image to black and white
    void monochrome(const bool monochromeFlag_);
    bool monochrome(void) const;

// Tile size and offset within an image montage
    Geometry montageGeometry(void) const;

// The normalized max error per pixel computed when an image is
    // color reduced.
    double normalizedMaxError(void) const;

// The normalized mean error per pixel computed when an image is
    // color reduced.
    double normalizedMeanError(void) const;

// Image orientation
    void orientation(const OrientationType orientation_);
    OrientationType orientation(void) const;

// Preferred size and location of an image canvas.
    void page(const Geometry &pageSize_);
    Geometry page(void) const;

// Pen color (deprecated, don't use any more)
    void penColor(const Color &penColor_);
    Color penColor(void) const;

// Pen texture image (deprecated, don't use any more)
    void penTexture(const Image &penTexture_);
    Image penTexture(void) const;

// JPEG/MIFF/PNG compression level (default 75).
    void quality(const size_t quality_);
    size_t quality(void) const;

// Maximum number of colors to quantize to
    void quantizeColors(const size_t colors_);
    size_t quantizeColors(void) const;

// Colorspace to quantize in.
    void quantizeColorSpace(const ColorspaceType colorSpace_);
    ColorspaceType quantizeColorSpace(void) const;

// Dither image during quantization (default true).
    void quantizeDither(const bool ditherFlag_);
    bool quantizeDither(void) const;

// Dither method
    void quantizeDitherMethod(const DitherMethod ditherMethod_);
    DitherMethod quantizeDitherMethod(void) const;

// Quantization tree-depth
    void quantizeTreeDepth(const size_t treeDepth_);
    size_t quantizeTreeDepth(void) const;

// Suppress all warning messages. Error messages are still reported.
    void quiet(const bool quiet_);
    bool quiet(void) const;

// The type of rendering intent
    void renderingIntent(const RenderingIntent renderingIntent_);
    RenderingIntent renderingIntent(void) const;

// Units of image resolution
    void resolutionUnits(const ResolutionType resolutionUnits_);
    ResolutionType resolutionUnits(void) const;

// The number of pixel rows in the image
    size_t rows(void) const;

// Image scene number
    void scene(const size_t scene_);
    size_t scene(void) const;

// Width and height of a raw image 
    void size(const Geometry &geometry_);
    Geometry size(void) const;

// enabled/disable stroke anti-aliasing
    void strokeAntiAlias(const bool flag_);
    bool strokeAntiAlias(void) const;

// Color to use when drawing object outlines
    void strokeColor(const Color &strokeColor_);
    Color strokeColor(void) const;

// Specify the pattern of dashes and gaps used to stroke
    // paths. The strokeDashArray represents a zero-terminated array
    // of numbers that specify the lengths of alternating dashes and
    // gaps in pixels. If an odd number of values is provided, then
    // the list of values is repeated to yield an even number of
    // values.  A typical strokeDashArray_ array might contain the
    // members 5 3 2 0, where the zero value indicates the end of the
    // pattern array.
    void strokeDashArray(const double *strokeDashArray_);
    const double *strokeDashArray(void) const;

// While drawing using a dash pattern, specify distance into the
    // dash pattern to start the dash (default 0).
    void strokeDashOffset(const double strokeDashOffset_);
    double strokeDashOffset(void) const;

// Specify the shape to be used at the end of open subpaths when
    // they are stroked. Values of LineCap are UndefinedCap, ButtCap,
    // RoundCap, and SquareCap.
    void strokeLineCap(const LineCap lineCap_);
    LineCap strokeLineCap(void) const;

// Specify the shape to be used at the corners of paths (or other
    // vector shapes) when they are stroked. Values of LineJoin are
    // UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
    void strokeLineJoin(const LineJoin lineJoin_);
    LineJoin strokeLineJoin(void) const;

// Specify miter limit. When two line segments meet at a sharp
    // angle and miter joins have been specified for 'lineJoin', it is
    // possible for the miter to extend far beyond the thickness of
    // the line stroking the path. The miterLimit' imposes a limit on
    // the ratio of the miter length to the 'lineWidth'. The default
    // value of this parameter is 4.
    void strokeMiterLimit(const size_t miterLimit_);
    size_t strokeMiterLimit(void) const;

// Pattern image to use while stroking object outlines.
    void strokePattern(const Image &strokePattern_);
    Image strokePattern(void) const;

// Stroke width for drawing vector objects (default one)
    void strokeWidth(const double strokeWidth_);
    double strokeWidth(void) const;

// Subimage of an image sequence
    void subImage(const size_t subImage_);
    size_t subImage(void) const;

// Number of images relative to the base image
    void subRange(const size_t subRange_);
    size_t subRange(void) const;

// Render text right-to-left or left-to-right.
    void textDirection(DirectionType direction_);
    DirectionType textDirection() const;

// Annotation text encoding (e.g. "UTF-16")
    void textEncoding(const std::string &encoding_);
    std::string textEncoding(void) const;

// Text gravity.
    void textGravity(GravityType gravity_);
    GravityType textGravity() const;

// Text inter-line spacing
    void textInterlineSpacing(double spacing_);
    double textInterlineSpacing(void) const;

// Text inter-word spacing
    void textInterwordSpacing(double spacing_);
    double textInterwordSpacing(void) const;

// Text inter-character kerning
    void textKerning(double kerning_);
    double textKerning(void) const;

// Text undercolor box
    void textUnderColor(const Color &underColor_);
    Color textUnderColor(void) const;

// Tile name
    void tileName(const std::string &tileName_);
    std::string tileName(void) const;

// Number of colors in the image
    size_t totalColors(void) const;

// Rotation to use when annotating with text or drawing
    void transformRotation(const double angle_);

// Skew to use in X axis when annotating with text or drawing
    void transformSkewX(const double skewx_);

// Skew to use in Y axis when annotating with text or drawing
    void transformSkewY(const double skewy_);

// Image representation type (also see type operation)
    //   Available types:
    //    Bilevel        Grayscale       GrayscaleMatte
    //    Palette        PaletteMatte    TrueColor
    //    TrueColorMatte ColorSeparation ColorSeparationMatte
    void type(const ImageType type_);
    ImageType type(void) const;

// Print detailed information about the image
    void verbose(const bool verboseFlag_);
    bool verbose(void) const;
    
    // FlashPix viewing parameters
    void view(const std::string &view_);
    std::string view(void) const;

// Virtual pixel method
    void virtualPixelMethod(const VirtualPixelMethod virtual_pixel_method_);
    VirtualPixelMethod virtualPixelMethod(void) const;

// X11 display to display to, obtain fonts from, or to capture
    // image from
    void x11Display(const std::string &display_);
    std::string x11Display(void) const;

// x resolution of the image
    double xResolution(void) const;

// y resolution of the image
    double yResolution(void) const;

// Adaptive-blur image with specified blur factor
    // The radius_ parameter specifies the radius of the Gaussian, in
    // pixels, not counting the center pixel.  The sigma_ parameter
    // specifies the standard deviation of the Laplacian, in pixels.
    void adaptiveBlur(const double radius_=0.0,const double sigma_=1.0);

// This is shortcut function for a fast interpolative resize using mesh
    // interpolation. It works well for small resizes of less than +/- 50%
    // of the original image size. For larger resizing on images a full
    // filtered and slower resize function should be used instead.
    void adaptiveResize(const Geometry &geometry_);

// Adaptively sharpens the image by sharpening more intensely near image
    // edges and less intensely far from edges. We sharpen the image with a 
    // Gaussian operator of the given radius and standard deviation (sigma).
    // For reasonable results, radius should be larger than sigma.
    void adaptiveSharpen(const double radius_=0.0,const double sigma_=1.0);
    void adaptiveSharpenChannel(const ChannelType channel_,
      const double radius_=0.0,const double sigma_=1.0);

// Local adaptive threshold image
    // http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm
    // Width x height define the size of the pixel neighborhood
    // offset = constant to subtract from pixel neighborhood mean
    void adaptiveThreshold(const size_t width,const size_t height,
      const ::ssize_t offset=0);

// Add noise to image with specified noise type
    void addNoise(const NoiseType noiseType_);
    void addNoiseChannel(const ChannelType channel_,
      const NoiseType noiseType_);

// Transform image by specified affine (or free transform) matrix.
    void affineTransform(const DrawableAffine &affine);

// Activates, deactivates, resets, or sets the alpha channel.
    void alphaChannel(AlphaChannelType alphaType_);

//
    // Annotate image (draw text on image)
    //
    // Gravity effects text placement in bounding area according to rules:
    //  NorthWestGravity  text bottom-left corner placed at top-left
    //  NorthGravity      text bottom-center placed at top-center
    //  NorthEastGravity  text bottom-right corner placed at top-right
    //  WestGravity       text left-center placed at left-center
    //  CenterGravity     text center placed at center
    //  EastGravity       text right-center placed at right-center
    //  SouthWestGravity  text top-left placed at bottom-left
    //  SouthGravity      text top-center placed at bottom-center
    //  SouthEastGravity  text top-right placed at bottom-right

// Annotate using specified text, and placement location
    void annotate(const std::string &text_,const Geometry &location_);

// Annotate using specified text, bounding area, and placement
    // gravity
    void annotate(const std::string &text_,const Geometry &boundingArea_,
      const GravityType gravity_);

// Annotate with text using specified text, bounding area,
    // placement gravity, and rotation.
    void annotate(const std::string &text_,const Geometry &boundingArea_,
      const GravityType gravity_,const double degrees_);

// Annotate with text (bounding area is entire image) and placement
    // gravity.
    void annotate(const std::string &text_,const GravityType gravity_);

// Inserts the artifact with the specified name and value into
    // the artifact tree of the image.
    void artifact(const std::string &name_,const std::string &value_);

// Returns the value of the artifact with the specified name.
    std::string artifact(const std::string &name_) const;

// Access/Update a named image attribute
    void attribute(const std::string name_,const char *value_);
    void attribute(const std::string name_,const std::string value_);
    std::string attribute(const std::string name_ ) const;

// Extracts the 'mean' from the image and adjust the image to try
    // make set its gamma appropriately.
    void autoGamma(void);
    void autoGammaChannel(const ChannelType channel_);

// Adjusts the levels of a particular image channel by scaling the
    // minimum and maximum values to the full quantum range.
    void autoLevel(void);
    void autoLevelChannel(const ChannelType channel_);

// Adjusts an image so that its orientation is suitable for viewing.
    void autoOrient(void);

// Forces all pixels below the threshold into black while leaving all
    // pixels at or above the threshold unchanged.
    void blackThreshold(const std::string &threshold_);
    void blackThresholdChannel(const ChannelType channel_,
      const std::string &threshold_);

// Simulate a scene at nighttime in the moonlight.
    void blueShift(const double factor_=1.5);

// Blur image with specified blur factor
    // The radius_ parameter specifies the radius of the Gaussian, in
    // pixels, not counting the center pixel.  The sigma_ parameter
    // specifies the standard deviation of the Laplacian, in pixels.
    void blur(const double radius_=0.0,const double sigma_=1.0);
    void blurChannel(const ChannelType channel_,const double radius_=0.0,
      const double sigma_=1.0);

// Border image (add border to image)
    void border(const Geometry &geometry_=borderGeometryDefault);

// Changes the brightness and/or contrast of an image. It converts the
    // brightness and contrast parameters into slope and intercept and calls
    // a polynomial function to apply to the image.
    void brightnessContrast(const double brightness_=0.0,
      const double contrast_=0.0);
    void brightnessContrastChannel(const ChannelType channel_,
      const double brightness_=0.0,const double contrast_=0.0);

// Uses a multi-stage algorithm to detect a wide range of edges in images.
    void cannyEdge(const double radius_=0.0,const double sigma_=1.0,
      const double lowerPercent_=0.1,const double upperPercent_=0.3);

// Accepts a lightweight Color Correction Collection
    // (CCC) file which solely contains one or more color corrections and
    // applies the correction to the image.
    void cdl(const std::string &cdl_);

// Extract channel from image
    void channel(const ChannelType channel_);

// Set or obtain modulus channel depth
    void channelDepth(const ChannelType channel_,const size_t depth_);
    size_t channelDepth(const ChannelType channel_);

// Charcoal effect image (looks like charcoal sketch)
    // The radius_ parameter specifies the radius of the Gaussian, in
    // pixels, not counting the center pixel.  The sigma_ parameter
    // specifies the standard deviation of the Laplacian, in pixels.
    void charcoal(const double radius_=0.0,const double sigma_=1.0);

// Chop image (remove vertical or horizontal subregion of image)
    // FIXME: describe how geometry argument is used to select either
    // horizontal or vertical subregion of image.
    void chop(const Geometry &geometry_);

// Chromaticity blue primary point (e.g. x=0.15, y=0.06)
    void chromaBluePrimary(const double x_,const double y_);
    void chromaBluePrimary(double *x_, double *y_) const;

// Chromaticity green primary point (e.g. x=0.3, y=0.6)
    void chromaGreenPrimary(const double x_,const double y_);
    void chromaGreenPrimary(double *x_,double *y_) const;

// Chromaticity red primary point (e.g. x=0.64, y=0.33)
    void chromaRedPrimary(const double x_,const double y_);
    void chromaRedPrimary(double *x_,double *y_) const;

// Chromaticity white point (e.g. x=0.3127, y=0.329)
    void chromaWhitePoint(const double x_,const double y_);
    void chromaWhitePoint(double *x_,double *y_) const;

// Set each pixel whose value is below zero to zero and any the
    // pixel whose value is above the quantum range to the quantum range (e.g.
    // 65535) otherwise the pixel value remains unchanged.
    void clamp(void);
    void clampChannel(const ChannelType channel_);

// Sets the image clip mask based on any clipping path information
    // if it exists.
    void clip(void);

void clipPath(const std::string pathname_,const bool inside_);

// Apply a color lookup table (CLUT) to the image.
    void clut(const Image &clutImage_);
    void clutChannel(const ChannelType channel_,const Image &clutImage_);

// Colorize image with pen color, using specified percent opacity.
    void colorize(const unsigned int opacity_,const Color &penColor_);

// Colorize image with pen color, using specified percent opacity
    // for red, green, and blue quantums
    void colorize(const unsigned int opacityRed_,
      const unsigned int opacityGreen_,const unsigned int opacityBlue_,
      const Color &penColor_);

// Color at colormap position index_
    void colorMap(const size_t index_,const Color &color_);
    Color colorMap(const size_t index_) const;

// Apply a color matrix to the image channels.  The user supplied
    // matrix may be of order 1 to 5 (1x1 through 5x5).
    void colorMatrix(const size_t order_,const double *color_matrix_);

// Compare current image with another image
    // Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError
    // in the current image. True is returned if the images are identical.
    bool compare(const Image &reference_);

// Compare current image with another image
    // Returns the distortion based on the specified metric.
    double compare(const Image &reference_,const MetricType metric_);
    double compareChannel(const ChannelType channel_,const Image &reference_,
      const MetricType metric_);

// Compare current image with another image
    // Sets the distortion and returns the difference image.
    Image compare(const Image &reference_,const MetricType metric_,
      double *distortion);
    Image compareChannel(const ChannelType channel_,const Image &reference_,
      const MetricType metric_,double *distortion );

// Compose an image onto another at specified offset and using
    // specified algorithm
    void composite(const Image &compositeImage_,const Geometry &offset_,
      const CompositeOperator compose_=InCompositeOp);
    void composite(const Image &compositeImage_,const GravityType gravity_,
      const CompositeOperator compose_=InCompositeOp);
    void composite(const Image &compositeImage_,const ::ssize_t xOffset_,
      const ::ssize_t yOffset_,const CompositeOperator compose_=InCompositeOp);

// Determines the connected-components of the image
    void connectedComponents(const size_t connectivity_);

// Contrast image (enhance intensity differences in image)
    void contrast(const size_t sharpen_);

// A simple image enhancement technique that attempts to improve the
    // contrast in an image by 'stretching' the range of intensity values
    // it contains to span a desired range of values. It differs from the
    // more sophisticated histogram equalization in that it can only apply a
    // linear scaling function to the image pixel values. As a result the
    // 'enhancement' is less harsh.
    void contrastStretch(const double black_point_,const double white_point_);
    void contrastStretchChannel(const ChannelType channel_,
      const double black_point_,const double white_point_);

// Convolve image.  Applies a user-specified convolution to the image.
    //  order_ represents the number of columns and rows in the filter kernel.
    //  kernel_ is an array of doubles representing the convolution kernel.
    void convolve(const size_t order_,const double *kernel_);

// Copies pixels from the source image as defined by the geometry the
    // destination image at the specified offset.
    void copyPixels(const Image &source_,const Geometry &geometry_,
      const Offset &offset_);

// Crop image (subregion of original image)
    void crop(const Geometry &geometry_);

// Cycle image colormap
    void cycleColormap(const ::ssize_t amount_);

// Converts cipher pixels to plain pixels.
    void decipher(const std::string &passphrase_);

// Tagged image format define. Similar to the defineValue() method
    // except that passing the flag_ value 'true' creates a value-less
    // define with that format and key. Passing the flag_ value 'false'
    // removes any existing matching definition. The method returns 'true'
    // if a matching key exists, and 'false' if no matching key exists.
    void defineSet(const std::string &magick_,const std::string &key_,
      bool flag_);
    bool defineSet(const std::string &magick_,const std::string &key_) const;

// Tagged image format define (set/access coder-specific option) The
    // magick_ option specifies the coder the define applies to.  The key_
    // option provides the key specific to that coder.  The value_ option
    // provides the value to set (if any). See the defineSet() method if the
    // key must be removed entirely.
    void defineValue(const std::string &magick_,const std::string &key_,
      const std::string &value_);
    std::string defineValue(const std::string &magick_,
      const std::string &key_) const;

// Removes skew from the image. Skew is an artifact that occurs in scanned
    // images because of the camera being misaligned, imperfections in the
    // scanning or surface, or simply because the paper was not placed
    // completely flat when scanned. The value of threshold_ ranges from 0
    // to QuantumRange.
    void deskew(const double threshold_);

// Despeckle image (reduce speckle noise)
    void despeckle(void);

// Determines the color type of the image. This method can be used to
    // automaticly make the type GrayScale.
    ImageType determineType(void) const;

// Display image on screen
    void display(void);

// Distort image.  distorts an image using various distortion methods, by
    // mapping color lookups of the source image to a new destination image
    // usually of the same size as the source image, unless 'bestfit' is set to
    // true.
    void distort(const DistortImageMethod method_,
      const size_t number_arguments_,const double *arguments_,
      const bool bestfit_=false);

// Draw on image using a single drawable
    void draw(const Drawable &drawable_);

// Draw on image using a drawable list
    void draw(const std::list<Magick::Drawable> &drawable_);

// Edge image (highlight edges in image)
    void edge(const double radius_=0.0);

// Emboss image (highlight edges with 3D effect)
    // The radius_ parameter specifies the radius of the Gaussian, in
    // pixels, not counting the center pixel.  The sigma_ parameter
    // specifies the standard deviation of the Laplacian, in pixels.
    void emboss(const double radius_=0.0,const double sigma_=1.0);

// Converts pixels to cipher-pixels.
    void encipher(const std::string &passphrase_);

// Enhance image (minimize noise)
    void enhance(void);

// Equalize image (histogram equalization)
    void equalize(void);

// Erase image to current "background color"
    void erase(void);

// Extend the image as defined by the geometry.
    void extent(const Geometry &geometry_);
    void extent(const Geometry &geometry_,const Color &backgroundColor);
    void extent(const Geometry &geometry_,const Color &backgroundColor,
      const GravityType gravity_ );
    void extent(const Geometry &geometry_,const GravityType gravity_);

// Flip image (reflect each scanline in the vertical direction)
    void flip(void);

// Flood-fill color across pixels that match the color of the
    // target pixel and are neighbors of the target pixel.
    // Uses current fuzz setting when determining color match.
    void floodFillColor(const Geometry &point_,const Color &fillColor_);
    void floodFillColor(const Geometry &point_,const Color &fillColor_,
      const bool invert_);
    void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
      const Color &fillColor_);
    void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
      const Color &fillColor_,const bool invert_);

// Flood-fill color across pixels starting at target-pixel and
    // stopping at pixels matching specified border color.
    // Uses current fuzz setting when determining color match.
    void floodFillColor(const Geometry &point_,const Color &fillColor_,
      const Color &borderColor_);
    void floodFillColor(const Geometry &point_,const Color &fillColor_,
      const Color &borderColor_,const bool invert_);
    void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
      const Color &fillColor_,const Color &borderColor_);
    void floodFillColor(const ::ssize_t x_,const ::ssize_t y_,
      const Color &fillColor_,const Color &borderColor_,const bool invert_);

// Floodfill pixels matching color (within fuzz factor) of target
    // pixel(x,y) with replacement opacity value using method.
    void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
      const unsigned int opacity_,const bool invert_=false);
    void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
      const unsigned int opacity_,const PaintMethod method_);
    void floodFillOpacity(const ::ssize_t x_,const ::ssize_t y_,
      const unsigned int opacity_,const Color &target_,
      const bool invert_=false);

// Flood-fill texture across pixels that match the color of the
    // target pixel and are neighbors of the target pixel.
    // Uses current fuzz setting when determining color match.
    void floodFillTexture(const Geometry &point_,const Image &texture_);
    void floodFillTexture(const Geometry &point_,const Image &texture_,
      const bool invert_);
    void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
       const Image &texture_);
    void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
       const Image &texture_,const bool invert_);

// Flood-fill texture across pixels starting at target-pixel and
    // stopping at pixels matching specified border color.
    // Uses current fuzz setting when determining color match.
    void floodFillTexture(const Geometry &point_,const Image &texture_,
       const Color &borderColor_);
    void floodFillTexture(const Geometry &point_,const Image &texture_,
       const Color &borderColor_,const bool invert_);
    void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
      const Image &texture_,const Color &borderColor_);
    void floodFillTexture(const ::ssize_t x_,const ::ssize_t y_,
      const Image &texture_,const Color &borderColor_,const bool invert_);

// Flop image (reflect each scanline in the horizontal direction)
    void flop(void);

// Obtain font metrics for text string given current font,
    // pointsize, and density settings.
    void fontTypeMetrics(const std::string &text_,TypeMetric *metrics);

// Obtain multi line font metrics for text string given current font,
    // pointsize, and density settings.
    void fontTypeMetricsMultiline(const std::string &text_,
      TypeMetric *metrics);

// Frame image
    void frame(const Geometry &geometry_=frameGeometryDefault);
    void frame(const size_t width_,const size_t height_,
      const ::ssize_t innerBevel_=6, const ::ssize_t outerBevel_=6);

// Applies a mathematical expression to the image.
    void fx(const std::string expression);
    void fx(const std::string expression,const Magick::ChannelType channel);

// Gamma correct image
    void gamma(const double gamma_);
    void gamma(const double gammaRed_,const double gammaGreen_,
      const double gammaBlue_);

// Gaussian blur image
    // The number of neighbor pixels to be included in the convolution
    // mask is specified by 'width_'. The standard deviation of the
    // gaussian bell curve is specified by 'sigma_'.
    void gaussianBlur(const double width_,const double sigma_);
    void gaussianBlurChannel(const ChannelType channel_,const double width_,
      const double sigma_);

// Obtain immutable image pixel indexes (valid for PseudoClass images)
    const IndexPacket *getConstIndexes(void) const;

// Transfers read-only pixels from the image to the pixel cache as
    // defined by the specified region
    const PixelPacket *getConstPixels(const ::ssize_t x_,const ::ssize_t y_,
      const size_t columns_,const size_t rows_) const;

// Obtain mutable image pixel indexes (valid for PseudoClass images)
    IndexPacket *getIndexes(void);

// Transfers pixels from the image to the pixel cache as defined
    // by the specified region. Modified pixels may be subsequently
    // transferred back to the image via syncPixels.  This method is
    // valid for DirectClass images.
    PixelPacket *getPixels(const ::ssize_t x_,const ::ssize_t y_,
      const size_t columns_,const size_t rows_);

// Converts the colors in the image to gray.
    void grayscale(const PixelIntensityMethod method_);

// Apply a color lookup table (Hald CLUT) to the image.
    void haldClut(const Image &clutImage_);

// Identifies lines in the image.
    void houghLine(const size_t width_,const size_t height_,
      const size_t threshold_=40);

// Implode image (special effect)
    void implode(const double factor_);

// Implements the inverse discrete Fourier transform (DFT) of the image
    // either as a magnitude / phase or real / imaginary image pair.
    void inverseFourierTransform(const Image &phase_);
    void inverseFourierTransform(const Image &phase_,const bool magnitude_);

// An edge preserving noise reduction filter.
    void kuwahara(const double radius_=0.0,const double sigma_=1.0);
    void kuwaharaChannel(const ChannelType channel_,const double radius_=0.0,
      const double sigma_=1.0);

// Level image. Adjust the levels of the image by scaling the
    // colors falling between specified white and black points to the
    // full available quantum range. The parameters provided represent
    // the black, mid (gamma), and white points.  The black point
    // specifies the darkest color in the image. Colors darker than
    // the black point are set to zero. Mid point (gamma) specifies a
    // gamma correction to apply to the image. White point specifies
    // the lightest color in the image.  Colors brighter than the
    // white point are set to the maximum quantum value. The black and
    // white point have the valid range 0 to QuantumRange while mid (gamma)
    // has a useful range of 0 to ten.
    void level(const double black_point,const double white_point,
       const double mid_point=1.0);
    void levelChannel(const ChannelType channel,const double black_point,
       const double white_point,const double mid_point=1.0);

// Maps the given color to "black" and "white" values, linearly spreading
    // out the colors, and level values on a channel by channel bases, as
    // per level(). The given colors allows you to specify different level
    // ranges for each of the color channels separately.
    void levelColors(const Color &blackColor_,const Color &whiteColor_,
      const bool invert_=true);
    void levelColorsChannel(const ChannelType channel_,
      const Color &blackColor_,const Color &whiteColor_,
      const bool invert_=true);

// Levelize applies the reversed level operation to just the specific
    // channels specified.It compresses the full range of color values, so
    // that they lie between the given black and white points. Gamma is
    // applied before the values are mapped.
    void levelize(const double blackPoint_,const double whitePoint_,
      const double gamma_=1.0);
    void levelizeChannel(const ChannelType channel_,const double blackPoint_,
      const double whitePoint_,const double gamma_=1.0);

// Discards any pixels below the black point and above the white point and
    // levels the remaining pixels.
    void linearStretch(const double blackPoint_,const double whitePoint_);

// Rescales image with seam carving.
    void liquidRescale(const Geometry &geometry_);

// Local contrast enhancement
    void localContrast(const double radius_,const double strength_);

// Magnify image by integral size
    void magnify(void);
    
    // Remap image colors with closest color from reference image
    void map(const Image &mapImage_,const bool dither_=false);

// Floodfill designated area with replacement opacity value
    void matteFloodfill(const Color &target_,const unsigned int opacity_,
      const ::ssize_t x_,const ::ssize_t y_,const PaintMethod method_);

// Filter image by replacing each pixel component with the median
    // color in a circular neighborhood
    void medianFilter(const double radius_=0.0);

// Merge image layers (deprecated, don't use any more)
    void mergeLayers(const ImageLayerMethod layerType_);

// Reduce image by integral size
    void minify(void);

// Modulate percent hue, saturation, and brightness of an image
    void modulate(const double brightness_,const double saturation_,
      const double hue_);

// Returns the normalized moments of one or more image channels.
    ImageMoments moments(void) const;

// Applies a kernel to the image according to the given morphology method.
    void morphology(const MorphologyMethod method_,const std::string kernel_,
      const ssize_t iterations_=1);
    void morphology(const MorphologyMethod method_,
      const KernelInfoType kernel_,const std::string arguments_,
      const ssize_t iterations_=1);
    void morphologyChannel(const ChannelType channel_,
      const MorphologyMethod method_,const std::string kernel_,
      const ssize_t iterations_=1);
    void morphologyChannel(const ChannelType channel_,
      const MorphologyMethod method_,const KernelInfoType kernel_,
      const std::string arguments_,const ssize_t iterations_=1);

// Motion blur image with specified blur factor
    // The radius_ parameter specifies the radius of the Gaussian, in
    // pixels, not counting the center pixel.  The sigma_ parameter
    // specifies the standard deviation of the Laplacian, in pixels.
    // The angle_ parameter specifies the angle the object appears
    // to be coming from (zero degrees is from the right).
    void motionBlur(const double radius_,const double sigma_,
      const double angle_);

// Negate colors in image.  Set grayscale to only negate grayscale
    // values in image.
    void negate(const bool grayscale_=false);
    void negateChannel(const ChannelType channel_,const bool grayscale_=false);

// Normalize image (increase contrast by normalizing the pixel
    // values to span the full range of color values)
    void normalize(void);

// Oilpaint image (image looks like oil painting)
    void oilPaint(const double radius_=3.0);

// Set or attenuate the opacity channel in the image. If the image
    // pixels are opaque then they are set to the specified opacity
    // value, otherwise they are blended with the supplied opacity
    // value.  The value of opacity_ ranges from 0 (completely opaque)
    // to QuantumRange. The defines OpaqueOpacity and TransparentOpacity are
    // available to specify completely opaque or completely
    // transparent, respectively.
    void opacity(const unsigned int opacity_);

// Change color of opaque pixel to specified pen color.
    void opaque(const Color &opaqueColor_,const Color &penColor_,
      const bool invert_=MagickFalse);

// Perform a ordered dither based on a number of pre-defined dithering
    // threshold maps, but over multiple intensity levels.
    void orderedDither(std::string thresholdMap_);
    void orderedDitherChannel(const ChannelType channel_,
      std::string thresholdMap_);

// Set each pixel whose value is less than epsilon to epsilon or
    // -epsilon (whichever is closer) otherwise the pixel value remains
    // unchanged.
    void perceptible(const double epsilon_);
    void perceptibleChannel(const ChannelType channel_,const double epsilon_);
    
    // Ping is similar to read except only enough of the image is read
    // to determine the image columns, rows, and filesize.  Access the
    // columns(), rows(), and fileSize() attributes after invoking
    // ping.  The image data is not valid after calling ping.
    void ping(const Blob &blob_);

// Ping is similar to read except only enough of the image is read
    // to determine the image columns, rows, and filesize.  Access the
    // columns(), rows(), and fileSize() attributes after invoking
    // ping.  The image data is not valid after calling ping.
    void ping(const std::string &imageSpec_);

// Get/set pixel color at location x & y.
    void pixelColor(const ::ssize_t x_,const ::ssize_t y_,const Color &color_);
    Color pixelColor(const ::ssize_t x_,const ::ssize_t y_ ) const;

// Simulates a Polaroid picture.
    void polaroid(const std::string &caption_,const double angle_);

// Reduces the image to a limited number of colors for a "poster" effect.
    void posterize(const size_t levels_,const bool dither_=false);
    void posterizeChannel(const ChannelType channel_, const size_t levels_,
       const bool dither_=false);

// Execute a named process module using an argc/argv syntax similar to
    // that accepted by a C 'main' routine. An exception is thrown if the
    // requested process module doesn't exist, fails to load, or fails during
    // execution.
    void process(std::string name_,const ::ssize_t argc_,const char **argv_);

// Add or remove a named profile to/from the image. Remove the
    // profile by passing an empty Blob (e.g. Blob()). Valid names are
    // "*", "8BIM", "ICM", "IPTC", or a user/format-defined profile name.
    void profile(const std::string name_,const Blob &colorProfile_);

// Retrieve a named profile from the image. Valid names are:
    // "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC"
    // or an existing user/format-defined profile name.
    Blob profile(const std::string name_) const;

// Quantize image (reduce number of colors)
    void quantize(const bool measureError_=false);

// Apply a value with an arithmetic, relational, or logical operator.
    void quantumOperator(const ChannelType channel_,
       const MagickEvaluateOperator operator_,double rvalue_);

// Apply a value with an arithmetic, relational, or logical operator.
    void quantumOperator(const ChannelType channel_,
      const MagickFunction function_,const size_t number_parameters_,
      const double *parameters_);

// Apply a value with an arithmetic, relational, or logical operator.
    void quantumOperator(const ::ssize_t x_,const ::ssize_t y_,
      const size_t columns_,const size_t rows_,const ChannelType channel_,
      const MagickEvaluateOperator operator_,const double rvalue_);

// Raise image (lighten or darken the edges of an image to give a
    // 3-D raised or lowered effect)
    void raise(const Geometry &geometry_=raiseGeometryDefault,
       const bool raisedFlag_=false);
    
    // Random threshold image.
    //
    // Changes the value of individual pixels based on the intensity
    // of each pixel compared to a random threshold.  The result is a
    // low-contrast, two color image.  The thresholds_ argument is a
    // geometry containing LOWxHIGH thresholds.  If the string
    // contains 2x2, 3x3, or 4x4, then an ordered dither of order 2,
    // 3, or 4 will be performed instead.  If a channel_ argument is
    // specified then only the specified channel is altered.  This is
    // a very fast alternative to 'quantize' based dithering.
    void randomThreshold(const Geometry &thresholds_);
    void randomThresholdChannel(const Geometry &thresholds_,
      const ChannelType channel_);

// Read single image frame from in-memory BLOB
    void read(const Blob &blob_);

// Read single image frame of specified size from in-memory BLOB
    void read(const Blob &blob_,const Geometry &size_);

// Read single image frame of specified size and depth from
    // in-memory BLOB
    void read(const Blob &blob_,const Geometry &size_,const size_t depth_);

// Read single image frame of specified size, depth, and format
    // from in-memory BLOB
    void read(const Blob &blob_,const Geometry &size_,const size_t depth_,
      const std::string &magick_);

// Read single image frame of specified size, and format from
    // in-memory BLOB
    void read(const Blob &blob_,const Geometry &size_,
      const std::string &magick_);

// Read single image frame of specified size into current object
    void read(const Geometry &size_,const std::string &imageSpec_);

// Read single image frame from an array of raw pixels, with
    // specified storage type (ConstituteImage), e.g.
    // image.read( 640, 480, "RGB", 0, pixels );
    void read(const size_t width_,const size_t height_,const std::string &map_,
      const StorageType type_,const void *pixels_);

// Read single image frame into current object
    void read(const std::string &imageSpec_);

// Transfers one or more pixel components from a buffer or file
    // into the image pixel cache of an image.
    // Used to support image decoders.
    void readPixels(const QuantumType quantum_,const unsigned char *source_);

// Reduce noise in image using a noise peak elimination filter
    void reduceNoise(void);
    void reduceNoise(const double order_);

// Resets the image page canvas and position.
    void repage();

// Resize image in terms of its pixel size.
    void resample(const Geometry &geometry_);

// Resize image to specified size.
    void resize(const Geometry &geometry_);

// Roll image (rolls image vertically and horizontally) by specified
    // number of columns and rows)
    void roll(const Geometry &roll_);
    void roll(const size_t columns_,const size_t rows_);

// Rotate image clockwise by specified number of degrees. Specify a
    // negative number for degrees to rotate counter-clockwise.
    void rotate(const double degrees_);

// Rotational blur image.
    void rotationalBlur(const double angle_);
    void rotationalBlurChannel(const ChannelType channel_,
      const double angle_);

// Resize image by using pixel sampling algorithm
    void sample(const Geometry &geometry_);

// Resize image by using simple ratio algorithm
    void scale(const Geometry &geometry_);

// Segment (coalesce similar image components) by analyzing the
    // histograms of the color components and identifying units that
    // are homogeneous with the fuzzy c-means technique.  Also uses
    // QuantizeColorSpace and Verbose image attributes
    void segment(const double clusterThreshold_=1.0,
      const double smoothingThreshold_=1.5);

// Selectively blur pixels within a contrast threshold. It is similar to
    // the unsharpen mask that sharpens everything with contrast above a
    // certain threshold.
    void selectiveBlur(const double radius_,const double sigma_,
      const double threshold_);
    void selectiveBlurChannel(const ChannelType channel_,const double radius_,
      const double sigma_,const double threshold_);

// Separates a channel from the image and returns it as a grayscale image.
    Image separate(const ChannelType channel_) const;

// Applies a special effect to the image, similar to the effect achieved in
    // a photo darkroom by sepia toning.  Threshold ranges from 0 to 
    // QuantumRange and is a measure of the extent of the sepia toning.
    // A threshold of 80% is a good starting point for a reasonable tone.
    void sepiaTone(const double threshold_);

// Allocates a pixel cache region to store image pixels as defined
    // by the region rectangle.  This area is subsequently transferred
    // from the pixel cache to the image via syncPixels.
    PixelPacket *setPixels(const ::ssize_t x_,const ::ssize_t y_,
      const size_t columns_,const size_t rows_);

// Shade image using distant light source
    void shade(const double azimuth_=30,const double elevation_=30,
      const bool colorShading_=false);

// Simulate an image shadow
    void shadow(const double percent_opacity_=80.0,const double sigma_=0.5,
      const ssize_t x_=5,const ssize_t y_=5);

// Sharpen pixels in image
    // The radius_ parameter specifies the radius of the Gaussian, in
    // pixels, not counting the center pixel.  The sigma_ parameter
    // specifies the standard deviation of the Laplacian, in pixels.
    void sharpen(const double radius_=0.0,const double sigma_=1.0);
    void sharpenChannel(const ChannelType channel_,const double radius_=0.0,
      const double sigma_=1.0);

// Shave pixels from image edges.
    void shave(const Geometry &geometry_);

// Shear image (create parallelogram by sliding image by X or Y axis)
    void shear(const double xShearAngle_,const double yShearAngle_);

// adjust the image contrast with a non-linear sigmoidal contrast algorithm
    void sigmoidalContrast(const size_t sharpen_,const double contrast,
      const double midpoint=QuantumRange/2.0);

// Image signature. Set force_ to true in order to re-calculate
    // the signature regardless of whether the image data has been
    // modified.
    std::string signature(const bool force_=false) const;

// Simulates a pencil sketch. We convolve the image with a Gaussian
    // operator of the given radius and standard deviation (sigma). For
    // reasonable results, radius should be larger than sigma. Use a
    // radius of 0 and SketchImage() selects a suitable radius for you.
    void sketch(const double radius_=0.0,const double sigma_=1.0,
      const double angle_=0.0);

// Solarize image (similar to effect seen when exposing a
    // photographic film to light during the development process)
    void solarize(const double factor_=50.0);

// Sparse color image, given a set of coordinates, interpolates the colors
    // found at those coordinates, across the whole image, using various
    // methods.
    void sparseColor(const ChannelType channel,const SparseColorMethod method,
      const size_t number_arguments,const double *arguments);

// Splice the background color into the image.
    void splice(const Geometry &geometry_);
    void splice(const Geometry &geometry_,const Color &backgroundColor_);
    void splice(const Geometry &geometry_,const Color &backgroundColor_,
      const GravityType gravity_);

// Spread pixels randomly within image by specified ammount
    void spread(const size_t amount_=3);

void statistics(ImageStatistics *statistics) const;

// Add a digital watermark to the image (based on second image)
    void stegano(const Image &watermark_);
    
    // Create an image which appears in stereo when viewed with
    // red-blue glasses (Red image on left, blue on right)
    void stereo(const Image &rightImage_);

// Strip strips an image of all profiles and comments.
    void strip(void);

// Search for the specified image at EVERY possible location in this image.
    // This is slow! very very slow.. It returns a similarity image such that
    // an exact match location is completely white and if none of the pixels
    // match, black, otherwise some gray level in-between.
    Image subImageSearch(const Image &reference_,const MetricType metric_,
      Geometry *offset_,double *similarityMetric_,
      const double similarityThreshold=(-1.0));

// Swirl image (image pixels are rotated by degrees)
    void swirl(const double degrees_);

// Transfers the image cache pixels to the image.
    void syncPixels(void);

// Channel a texture on image background
    void texture(const Image &texture_);

// Threshold image
    void threshold(const double threshold_);

// Resize image to thumbnail size
    void thumbnail(const Geometry &geometry_);

// Applies a color vector to each pixel in the image. The length of the
    // vector is 0 for black and white and at its maximum for the midtones.
    // The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5))))
    void tint(const std::string opacity_);

// Transform image based on image and crop geometries
    // Crop geometry is optional
    void transform(const Geometry &imageGeometry_);
    void transform(const Geometry &imageGeometry_,
      const Geometry &cropGeometry_);

// Origin of coordinate system to use when annotating with text or drawing
    void transformOrigin(const double x_,const  double y_);

// Reset transformation parameters to default
    void transformReset(void);

// Scale to use when annotating with text or drawing
    void transformScale(const double sx_,const double sy_);

// Add matte image to image, setting pixels matching color to
    // transparent
    void transparent(const Color &color_);

// Add matte image to image, for all the pixels that lies in between
    // the given two color
    void transparentChroma(const Color &colorLow_,const Color &colorHigh_);

// Creates a horizontal mirror image by reflecting the pixels around the
    // central y-axis while rotating them by 90 degrees.
    void transpose(void);

// Creates a vertical mirror image by reflecting the pixels around the
    // central x-axis while rotating them by 270 degrees.
    void transverse(void);

// Trim edges that are the background color from the image
    void trim(void);

// Returns the unique colors of an image.
    Image uniqueColors(void) const;

// Replace image with a sharpened version of the original image
    // using the unsharp mask algorithm.
    //  radius_
    //    the radius of the Gaussian, in pixels, not counting the
    //    center pixel.
    //  sigma_
    //    the standard deviation of the Gaussian, in pixels.
    //  amount_
    //    the percentage of the difference between the original and
    //    the blur image that is added back into the original.
    // threshold_
    //   the threshold in pixels needed to apply the difference amount.
    void unsharpmask(const double radius_,const double sigma_,
      const double amount_,const double threshold_);
    void unsharpmaskChannel(const ChannelType channel_,const double radius_,
      const double sigma_,const double amount_,const double threshold_);

// Softens the edges of the image in vignette style.
    void vignette(const double radius_=0.0,const double sigma_=1.0,
      const ssize_t x_=0,const ssize_t y_=0);

// Map image pixels to a sine wave
    void wave(const double amplitude_=25.0,const double wavelength_=150.0);

// Removes noise from the image using a wavelet transform.
    void waveletDenoise(const double threshold_,const double softness_);

// Forces all pixels above the threshold into white while leaving all
    // pixels at or below the threshold unchanged.
    void whiteThreshold(const std::string &threshold_);
    void whiteThresholdChannel(const ChannelType channel_,
      const std::string &threshold_);

// Write single image frame to in-memory BLOB, with optional
    // format and adjoin parameters.
    void write(Blob *blob_);
    void write(Blob *blob_,const std::string &magick_);
    void write(Blob *blob_,const std::string &magick_,const size_t depth_);

// Write single image frame to an array of pixels with storage
    // type specified by user (DispatchImage), e.g.
    // image.write( 0, 0, 640, 1, "RGB", 0, pixels );
    void write(const ::ssize_t x_,const ::ssize_t y_,const size_t columns_,
      const size_t rows_,const std::string& map_,const StorageType type_,
      void *pixels_);

// Write single image frame to a file
    void write(const std::string &imageSpec_);

// Transfers one or more pixel components from the image pixel
    // cache to a buffer or file.
    // Used to support image encoders.
    void writePixels(const QuantumType quantum_,unsigned char *destination_);

// Zoom image to specified size.
    void zoom(const Geometry &geometry_);

//////////////////////////////////////////////////////////////////////
    //
    // No user-serviceable parts beyond this point
    //
    //////////////////////////////////////////////////////////////////////

// Construct with MagickCore::Image and default options
    Image(MagickCore::Image *image_);

// Retrieve Image*
    MagickCore::Image *&image(void);
    const MagickCore::Image *constImage(void) const;

// Retrieve ImageInfo*
    MagickCore::ImageInfo *imageInfo(void);
    const MagickCore::ImageInfo *constImageInfo(void) const;

// Retrieve Options*
    Options *options(void);
    const Options *constOptions(void) const;

// Retrieve QuantizeInfo*
    MagickCore::QuantizeInfo *quantizeInfo(void);
    const MagickCore::QuantizeInfo *constQuantizeInfo(void) const;

// Prepare to update image (copy if reference > 1)
    void modifyImage(void);

// Replace current image (reference counted)
    MagickCore::Image *replaceImage(MagickCore::Image *replacement_);

// Test for ImageMagick error and throw exception if error
    void throwImageException(void) const;

private:

void read(MagickCore::Image *image,
      MagickCore::ExceptionInfo *exceptionInfo);

void floodFill(const ssize_t x_,const ssize_t y_,
      const Magick::Image *fillPattern_,const Color &fill_,
      const MagickCore::PixelPacket *target,const bool invert_);

ImageRef *_imgRef;
  };

} // end of namespace Magick

//
// Inlines
//

inline Magick::ClassType Magick::Image::classType(void) const
{
  return static_cast<Magick::ClassType>(constImage()->storage_class);
}

inline size_t Magick::Image::columns(void) const
{
  return constImage()->columns;
}

inline void Magick::Image::lineWidth(const double lineWidth_)
{
  strokeWidth(lineWidth_);
}
inline double Magick::Image::lineWidth(void) const
{
  return strokeWidth();
}

inline void Magick::Image::reduceNoise(void)
{
  reduceNoise(3.0);
}

inline size_t Magick::Image::rows(void) const
{
  return constImage()->rows;
}

#endif // Magick_Image_header

MR SKB