// 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 int x_,                            const int y_,                            const unsigned int columns_,                            const unsigned int rows_,                            const std::string& map_,                            const StorageType type_,                            void *pixels_ );        // Zoom image to specified size.    void            zoom ( const Geometry &geometry_ );    //////////////////////////////////////////////////////////////////////    //    // Image Attributes and Options    //    //////////////////////////////////////////////////////////////////////    // 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 );        // Time in 1/100ths of a second which must expire before    // displaying the next image in an animated sequence.    void            animationDelay ( const unsigned int delay_ );    unsigned int    animationDelay ( void ) const;        // Number of iterations to loop an animation (e.g. Netscape loop    // extension) for.    void            animationIterations ( const unsigned int iterations_ );    unsigned int    animationIterations ( void ) const;    // Access/Update a named image attribute    void            attribute ( const std::string name_,                                const std::string value_ );    std::string     attribute ( const std::string name_ );        // 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)    unsigned int    baseColumns ( void ) const;        // Base image filename (before transformations)    std::string     baseFilename ( void ) const;        // Base image height (before transformations)    unsigned int    baseRows ( 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;    // Pixel cache threshold in megabytes.  Once this memory threshold    // is exceeded, all subsequent pixels cache operations are to/from    // disk.  This setting is shared by all Image objects.    static void     cacheThreshold ( const unsigned int threshold_ );        // 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;        // 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 QuantumDepth 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;        // Color at colormap position index_    void            colorMap ( const unsigned int index_,                               const Color &color_ );    Color           colorMap ( const unsigned int index_ ) const;    // Colormap size (number of colormap entries)    void            colorMapSize ( const unsigned int entries_ );    unsigned int    colorMapSize ( void );    // Image Color Space    void            colorSpace( const ColorspaceType colorSpace_ );    ColorspaceType  colorSpace ( void ) const;    // Image width    unsigned int    columns ( void ) const;        // Image 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;    // 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;    // 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;    // 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 unsigned int depth_ );    unsigned int    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;    // 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 point size    void            fontPointsize ( const double pointSize_ );    double          fontPointsize ( void ) const;    // Obtain font metrics for text string given current font,    // pointsize, and density settings.    void            fontTypeMetrics( const std::string &text_,                                     TypeMetric *metrics );    // Long image format description    std::string     format ( void ) const;    // 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 unsigned int disposeMethod_ );    unsigned int    gifDisposeMethod ( void ) const;    // 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;    // IPTC profile (BLOB)    void            iptcProfile( const Blob& iptcProfile_ );    Blob            iptcProfile( void ) const;    // Does object contain valid image?    void            isValid ( const bool isValid_ );    bool            isValid ( void ) const;    // Image 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;    // File type magick identifier (.e.g "GIF")    void            magick ( const std::string &magick_ );    std::string     magick ( 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 unsigned int modulusDepth_ );    unsigned int    modulusDepth ( void ) const;    // Tile size and offset within an image montage    Geometry        montageGeometry ( void ) const;    // Transform image to black and white    void            monochrome ( const bool monochromeFlag_ );    bool            monochrome ( 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;    // Get/set pixel color at location x & y.    void            pixelColor ( const unsigned int x_,                                 const unsigned int y_,				 const Color &color_ );    Color           pixelColor ( const unsigned int x_,                                 const unsigned int y_ ) const;    // 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_,