�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2F'>ImageMagick-7.1.2-30</a>/<a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2FPerlMagick%2F'>PerlMagick</a>/</p><hr><h3>✏️ Editing: Magick.xs</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                         PPPP   EEEEE  RRRR   L                              %
%                         P   P  E      R   R  L                              %
%                         PPPP   EEE    RRRR   L                              %
%                         P      E      R  R   L                              %
%                         P      EEEEE  R   R  LLLLL                          %
%                                                                             %
%                  M   M   AAA    GGGG  IIIII   CCCC  K   K                   %
%                  MM MM  A   A  G        I    C      K  K                    %
%                  M M M  AAAAA  G GGG    I    C      KKK                     %
%                  M   M  A   A  G   G    I    C      K  K                    %
%                  M   M  A   A   GGGG  IIIII   CCCC  K   K                   %
%                                                                             %
%                                                                             %
%                Object-oriented Perl interface to ImageMagick                %
%                                                                             %
%                            Software Design                                  %
%                              Kyle Shorter                                   %
%                                 Cristy                                      %
%                             February 1997                                   %
%                                                                             %
%                                                                             %
%  Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization         %
%  dedicated to making software imaging solutions freely available.           %
%                                                                             %
%  You may not use this file except in compliance with the License.  You may  %
%  obtain a copy of the License at                                            %
%                                                                             %
%    https://imagemagick.org/script/license.php                               %
%                                                                             %
%  Unless required by applicable law or agreed to in writing, software        %
%  distributed under the License is distributed on an &quot;AS IS&quot; BASIS,          %
%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
%  See the License for the specific language governing permissions and        %
%  limitations under the License.                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  PerlMagick is an objected-oriented Perl interface to ImageMagick.  Use
%  the module to read, manipulate, or write an image or image sequence from
%  within a Perl script.  This makes PerlMagick suitable for Web CGI scripts.
%
*/

/*
  Include declarations.
*/
#if defined(__cplusplus) || defined(c_plusplus)
extern &quot;C&quot; {
#endif

#define PERL_NO_GET_CONTEXT
#include &lt;MagickCore/MagickCore.h&gt;
#include &quot;EXTERN.h&quot;
#include &quot;perl.h&quot;
#include &quot;XSUB.h&quot;
#include &lt;math.h&gt;
#undef tainted

#if defined(__cplusplus) || defined(c_plusplus)
}
#endif

/*
  Define declarations.
*/
#ifndef aTHX_
#define aTHX_
#define pTHX_
#define dTHX
#endif
#define DegreesToRadians(x)  (MagickPI*(x)/180.0)
#define EndOf(array)  (&amp;array[NumberOf(array)])
#define MagickPI  3.14159265358979323846264338327950288419716939937510
#define MaxArguments  35
#ifndef na
#define na  PL_na
#endif
#define NumberOf(array)  (sizeof(array)/sizeof(*array))
#define PackageName   &quot;Image::Magick&quot;
#if PERL_VERSION &lt;= 6
#define PerlIO  FILE
#define PerlIO_importFILE(f, fl)  (f)
#define PerlIO_findFILE(f)  NULL
#endif
#ifndef sv_undef
#define sv_undef  PL_sv_undef
#endif

#define AddImageToRegistry(sv,image) \
{ \
  if (magick_registry != (SplayTreeInfo *) NULL) \
    { \
      (void) AddValueToSplayTree(magick_registry,image,image); \
      (sv)=newSViv(PTR2IV(image)); \
    } \
}

#define DeleteImageFromRegistry(reference,image) \
{ \
  if (magick_registry != (SplayTreeInfo *) NULL) \
    { \
      if (GetImageReferenceCount(image) == 1) \
       (void) DeleteNodeByValueFromSplayTree(magick_registry,image); \
      image=DestroyImage(image); \
      sv_setiv(reference,0); \
    } \
}

#define InheritPerlException(exception,perl_exception) \
{ \
  char \
    message[MagickPathExtent]; \
 \
  if ((exception)-&gt;severity != UndefinedException) \
    { \
      (void) FormatLocaleString(message,MagickPathExtent,&quot;Exception %d: %s%s%s%s&quot;,\
        (exception)-&gt;severity, (exception)-&gt;reason ? \
        GetLocaleExceptionMessage((exception)-&gt;severity,(exception)-&gt;reason) : \
        &quot;Unknown&quot;, (exception)-&gt;description ? &quot; (&quot; : &quot;&quot;, \
        (exception)-&gt;description ? GetLocaleExceptionMessage( \
        (exception)-&gt;severity,(exception)-&gt;description) : &quot;&quot;, \
        (exception)-&gt;description ? &quot;)&quot; : &quot;&quot;); \
      if ((perl_exception) != (SV *) NULL) \
        { \
          if (SvCUR(perl_exception)) \
            sv_catpv(perl_exception,&quot;\n&quot;); \
          sv_catpv(perl_exception,message); \
        } \
    } \
}

#define ThrowPerlException(exception,severity,tag,reason) \
  (void) ThrowMagickException(exception,GetMagickModule(),severity, \
    tag,&quot;`%s&#039;&quot;,reason); \

/*
  Typedef and structure declarations.
*/
typedef enum
{
  NullReference = 0,
  ArrayReference = (~0),
  RealReference = (~0)-1,
  FileReference = (~0)-2,
  ImageReference = (~0)-3,
  IntegerReference = (~0)-4,
  StringReference = (~0)-5
} MagickReference;

typedef struct _Arguments
{
  const char
    *method;

  ssize_t
    type;
} Arguments;

struct ArgumentList
{
  ssize_t
    integer_reference;

  double
    real_reference;

  const char
    *string_reference;

  Image
    *image_reference;

  SV
    *array_reference;

  FILE
    *file_reference;

  size_t
    length;
};

struct PackageInfo
{
  ImageInfo
    *image_info;
};

typedef void
  *Image__Magick;  /* data type for the Image::Magick package */

/*
  Static declarations.
*/
static struct
  Methods
  {
    const char
      *name;

    Arguments
      arguments[MaxArguments];
  } Methods[] =
  {
    { &quot;Comment&quot;, { {&quot;comment&quot;, StringReference} } },
    { &quot;Label&quot;, { {&quot;label&quot;, StringReference} } },
    { &quot;AddNoise&quot;, { {&quot;noise&quot;, MagickNoiseOptions}, {&quot;attenuate&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Colorize&quot;, { {&quot;fill&quot;, StringReference}, {&quot;blend&quot;, StringReference} } },
    { &quot;Border&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;fill&quot;, StringReference},
      {&quot;bordercolor&quot;, StringReference}, {&quot;color&quot;, StringReference},
      {&quot;compose&quot;, MagickComposeOptions} } },
    { &quot;Blur&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;radius&quot;, RealReference},
      {&quot;sigma&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Chop&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference}, {&quot;gravity&quot;, MagickGravityOptions} } },
    { &quot;Crop&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference}, {&quot;fuzz&quot;, StringReference},
      {&quot;gravity&quot;, MagickGravityOptions} } },
    { &quot;Despeckle&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Edge&quot;, { {&quot;radius&quot;, RealReference} } },
    { &quot;Emboss&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;radius&quot;, RealReference},
      {&quot;sigma&quot;, RealReference} } },
    { &quot;Enhance&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Flip&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Flop&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Frame&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;inner&quot;, IntegerReference},
      {&quot;outer&quot;, IntegerReference}, {&quot;fill&quot;, StringReference},
      {&quot;color&quot;, StringReference}, {&quot;compose&quot;, MagickComposeOptions} } },
    { &quot;Implode&quot;, { {&quot;amount&quot;, RealReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions} } },
    { &quot;Magnify&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;MedianFilter&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Minify&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;OilPaint&quot;, { {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference} } },
    { &quot;ReduceNoise&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference},{&quot;height&quot;, IntegerReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Roll&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference} } },
    { &quot;Rotate&quot;, { {&quot;degrees&quot;, RealReference},
      {&quot;background&quot;, StringReference} } },
    { &quot;Sample&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference} } },
    { &quot;Scale&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference} } },
    { &quot;Shade&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;azimuth&quot;, RealReference},
      {&quot;elevation&quot;, RealReference}, {&quot;gray&quot;, MagickBooleanOptions} } },
    { &quot;Sharpen&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;radius&quot;, RealReference},
      {&quot;sigma&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Shear&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;x&quot;, RealReference},
      {&quot;y&quot;, RealReference}, { &quot;fill&quot;, StringReference},
      {&quot;color&quot;, StringReference} } },
    { &quot;Spread&quot;, { {&quot;radius&quot;, RealReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions} } },
    { &quot;Swirl&quot;, { {&quot;degrees&quot;, RealReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions} } },
    { &quot;Resize&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;filter&quot;, MagickFilterOptions},
      {&quot;support&quot;, StringReference } } },
    { &quot;Zoom&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;filter&quot;, MagickFilterOptions},
      {&quot;support&quot;, RealReference } } },
    { &quot;Annotate&quot;, { {&quot;text&quot;, StringReference}, {&quot;font&quot;, StringReference},
      {&quot;pointsize&quot;, RealReference}, {&quot;density&quot;, StringReference},
      {&quot;undercolor&quot;, StringReference}, {&quot;stroke&quot;, StringReference},
      {&quot;fill&quot;, StringReference}, {&quot;geometry&quot;, StringReference},
      {&quot;sans&quot;, StringReference}, {&quot;x&quot;, RealReference},
      {&quot;y&quot;, RealReference}, {&quot;gravity&quot;, MagickGravityOptions},
      {&quot;translate&quot;, StringReference}, {&quot;scale&quot;, StringReference},
      {&quot;rotate&quot;, RealReference}, {&quot;skewX&quot;, RealReference},
      {&quot;skewY&quot;, RealReference}, {&quot;strokewidth&quot;, RealReference},
      {&quot;antialias&quot;, MagickBooleanOptions}, {&quot;family&quot;, StringReference},
      {&quot;style&quot;, MagickStyleOptions}, {&quot;stretch&quot;, MagickStretchOptions},
      {&quot;weight&quot;, IntegerReference}, {&quot;align&quot;, MagickAlignOptions},
      {&quot;encoding&quot;, StringReference}, {&quot;affine&quot;, ArrayReference},
      {&quot;fill-pattern&quot;, ImageReference}, {&quot;stroke-pattern&quot;, ImageReference},
      {&quot;tile&quot;, ImageReference}, {&quot;kerning&quot;, RealReference},
      {&quot;interline-spacing&quot;, RealReference},
      {&quot;interword-spacing&quot;, RealReference},
      {&quot;direction&quot;, MagickDirectionOptions},
      {&quot;decorate&quot;, MagickDecorateOptions},
      {&quot;word-break&quot;, MagickWordBreakOptions} } },
    { &quot;ColorFloodfill&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;x&quot;, IntegerReference}, {&quot;y&quot;, IntegerReference},
      {&quot;fill&quot;, StringReference}, {&quot;bordercolor&quot;, StringReference},
      {&quot;fuzz&quot;, StringReference}, {&quot;invert&quot;, MagickBooleanOptions} } },
    { &quot;Composite&quot;, { {&quot;image&quot;, ImageReference},
      {&quot;compose&quot;, MagickComposeOptions}, {&quot;geometry&quot;, StringReference},
      {&quot;x&quot;, IntegerReference}, {&quot;y&quot;, IntegerReference},
      {&quot;gravity&quot;, MagickGravityOptions}, {&quot;opacity&quot;, StringReference},
      {&quot;tile&quot;, MagickBooleanOptions}, {&quot;rotate&quot;, RealReference},
      {&quot;color&quot;, StringReference}, {&quot;mask&quot;, ImageReference},
      {&quot;channel&quot;, MagickChannelOptions},
      {&quot;interpolate&quot;, MagickInterpolateOptions}, {&quot;args&quot;, StringReference},
      {&quot;blend&quot;, StringReference}, {&quot;clip-to-self&quot;, MagickBooleanOptions} } },
    { &quot;Contrast&quot;, { {&quot;sharpen&quot;, MagickBooleanOptions} } },
    { &quot;CycleColormap&quot;, { {&quot;display&quot;, IntegerReference} } },
    { &quot;Draw&quot;, { {&quot;primitive&quot;, MagickPrimitiveOptions},
      {&quot;points&quot;, StringReference}, {&quot;method&quot;, MagickMethodOptions},
      {&quot;stroke&quot;, StringReference}, {&quot;fill&quot;, StringReference},
      {&quot;strokewidth&quot;, RealReference}, {&quot;font&quot;, StringReference},
      {&quot;bordercolor&quot;, StringReference}, {&quot;x&quot;, RealReference},
      {&quot;y&quot;, RealReference}, {&quot;translate&quot;, StringReference},
      {&quot;scale&quot;, StringReference}, {&quot;rotate&quot;, RealReference},
      {&quot;skewX&quot;, RealReference}, {&quot;skewY&quot;, RealReference},
      {&quot;tile&quot;, ImageReference}, {&quot;pointsize&quot;, RealReference},
      {&quot;antialias&quot;, MagickBooleanOptions}, {&quot;density&quot;, StringReference},
      {&quot;linewidth&quot;, RealReference}, {&quot;affine&quot;, ArrayReference},
      {&quot;stroke-dashoffset&quot;, RealReference},
      {&quot;stroke-dasharray&quot;, ArrayReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions},
      {&quot;origin&quot;, StringReference}, {&quot;text&quot;, StringReference},
      {&quot;fill-pattern&quot;, ImageReference}, {&quot;stroke-pattern&quot;, ImageReference},
      {&quot;vector-graphics&quot;, StringReference}, {&quot;kerning&quot;, RealReference},
      {&quot;interline-spacing&quot;, RealReference},
      {&quot;interword-spacing&quot;, RealReference},
      {&quot;direction&quot;, MagickDirectionOptions},
      {&quot;word-break&quot;, MagickWordBreakOptions} } },
    { &quot;Equalize&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Gamma&quot;, { {&quot;gamma&quot;, StringReference}, {&quot;channel&quot;, MagickChannelOptions},
      {&quot;red&quot;, RealReference}, {&quot;green&quot;, RealReference},
      {&quot;blue&quot;, RealReference} } },
    { &quot;Map&quot;, { {&quot;image&quot;, ImageReference},
      {&quot;dither-method&quot;, MagickDitherOptions} } },
    { &quot;MatteFloodfill&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;x&quot;, IntegerReference}, {&quot;y&quot;, IntegerReference},
      {&quot;opacity&quot;, StringReference}, {&quot;bordercolor&quot;, StringReference},
      {&quot;fuzz&quot;, StringReference}, {&quot;invert&quot;, MagickBooleanOptions} } },
    { &quot;Modulate&quot;, { {&quot;factor&quot;, StringReference}, {&quot;hue&quot;, RealReference},
      {&quot;saturation&quot;, RealReference}, {&quot;whiteness&quot;, RealReference},
      {&quot;brightness&quot;, RealReference}, {&quot;lightness&quot;, RealReference},
      {&quot;blackness&quot;, RealReference} } },
    { &quot;Negate&quot;, { {&quot;gray&quot;, MagickBooleanOptions},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Normalize&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;NumberColors&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Opaque&quot;, { {&quot;color&quot;, StringReference}, {&quot;fill&quot;, StringReference},
      {&quot;fuzz&quot;, StringReference}, {&quot;channel&quot;, MagickChannelOptions},
      {&quot;invert&quot;, MagickBooleanOptions} } },
    { &quot;Quantize&quot;, { {&quot;colors&quot;, IntegerReference},
      {&quot;treedepth&quot;, IntegerReference}, {&quot;colorspace&quot;, MagickColorspaceOptions},
      {&quot;dither&quot;, MagickDitherOptions}, {&quot;measure&quot;, MagickBooleanOptions},
      {&quot;global&quot;, MagickBooleanOptions}, {&quot;transparent-color&quot;, StringReference},
      {&quot;dither-method&quot;, MagickDitherOptions} } },
    { &quot;Raise&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;raise&quot;, MagickBooleanOptions} } },
    { &quot;Segment&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;cluster-threshold&quot;, RealReference},
      {&quot;smoothing-threshold&quot;, RealReference},
      {&quot;colorspace&quot;, MagickColorspaceOptions},
      {&quot;verbose&quot;, MagickBooleanOptions} } },
    { &quot;Signature&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Solarize&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;threshold&quot;, StringReference} } },
    { &quot;Sync&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Texture&quot;, { {&quot;texture&quot;, ImageReference} } },
    { &quot;Evaluate&quot;, { {&quot;value&quot;, RealReference},
      {&quot;operator&quot;, MagickEvaluateOptions},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Transparent&quot;, { {&quot;color&quot;, StringReference}, {&quot;opacity&quot;, StringReference},
      {&quot;fuzz&quot;, StringReference}, {&quot;invert&quot;, MagickBooleanOptions} } },
    { &quot;Threshold&quot;, { {&quot;threshold&quot;, StringReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Charcoal&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;radius&quot;, RealReference},
      {&quot;sigma&quot;, RealReference} } },
    { &quot;Trim&quot;, { {&quot;fuzz&quot;, StringReference} } },
    { &quot;Wave&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;amplitude&quot;, RealReference},
      {&quot;wavelength&quot;, RealReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions} } },
    { &quot;Separate&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Condense&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Stereo&quot;, { {&quot;image&quot;, ImageReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference} } },
    { &quot;Stegano&quot;, { {&quot;image&quot;, ImageReference}, {&quot;offset&quot;, IntegerReference} } },
    { &quot;Deconstruct&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;GaussianBlur&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Convolve&quot;, { {&quot;coefficients&quot;, ArrayReference},
      {&quot;channel&quot;, MagickChannelOptions}, {&quot;bias&quot;, StringReference},
      {&quot;kernel&quot;, StringReference} } },
    { &quot;Profile&quot;, { {&quot;name&quot;, StringReference}, {&quot;profile&quot;, StringReference},
      { &quot;rendering-intent&quot;, MagickIntentOptions},
      { &quot;black-point-compensation&quot;, MagickBooleanOptions} } },
    { &quot;UnsharpMask&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;gain&quot;, RealReference}, {&quot;threshold&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;MotionBlur&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;angle&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;OrderedDither&quot;, { {&quot;threshold&quot;, StringReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Shave&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference} } },
    { &quot;Level&quot;, { {&quot;levels&quot;, StringReference}, {&quot;black-point&quot;, RealReference},
      {&quot;white-point&quot;, RealReference}, {&quot;gamma&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions}, {&quot;level&quot;, StringReference} } },
    { &quot;Clip&quot;, { {&quot;id&quot;, StringReference}, {&quot;inside&quot;, MagickBooleanOptions} } },
    { &quot;AffineTransform&quot;, { {&quot;affine&quot;, ArrayReference},
      {&quot;translate&quot;, StringReference}, {&quot;scale&quot;, StringReference},
      {&quot;rotate&quot;, RealReference}, {&quot;skewX&quot;, RealReference},
      {&quot;skewY&quot;, RealReference}, {&quot;interpolate&quot;, MagickInterpolateOptions},
      {&quot;background&quot;, StringReference} } },
    { &quot;Difference&quot;, { {&quot;image&quot;, ImageReference}, {&quot;fuzz&quot;, StringReference} } },
    { &quot;AdaptiveThreshold&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;bias&quot;, RealReference} } },
    { &quot;Resample&quot;, { {&quot;density&quot;, StringReference}, {&quot;x&quot;, RealReference},
      {&quot;y&quot;, RealReference}, {&quot;filter&quot;, MagickFilterOptions},
      {&quot;support&quot;, RealReference } } },
    { &quot;Describe&quot;, { {&quot;file&quot;, FileReference} } },
    { &quot;BlackThreshold&quot;, { {&quot;threshold&quot;, StringReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;WhiteThreshold&quot;, { {&quot;threshold&quot;, StringReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;RotationalBlur&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;angle&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Thumbnail&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference} } },
    { &quot;Strip&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Tint&quot;, { {&quot;fill&quot;, StringReference}, {&quot;blend&quot;, StringReference} } },
    { &quot;Channel&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Splice&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference}, {&quot;fuzz&quot;, StringReference},
      {&quot;background&quot;, StringReference}, {&quot;gravity&quot;, MagickGravityOptions} } },
    { &quot;Posterize&quot;, { {&quot;levels&quot;, IntegerReference},
      {&quot;dither&quot;, MagickBooleanOptions} } },
    { &quot;Shadow&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;alpha&quot;, RealReference},
      {&quot;sigma&quot;, RealReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference} } },
    { &quot;Identify&quot;, { {&quot;file&quot;, FileReference}, {&quot;features&quot;, StringReference},
      {&quot;moments&quot;, MagickBooleanOptions}, {&quot;unique&quot;, MagickBooleanOptions} } },
    { &quot;SepiaTone&quot;, { {&quot;threshold&quot;, RealReference} } },
    { &quot;SigmoidalContrast&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;contrast&quot;, RealReference}, {&quot;mid-point&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions}, {&quot;sharpen&quot;, MagickBooleanOptions} } },
    { &quot;Extent&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference}, {&quot;fuzz&quot;, StringReference},
      {&quot;background&quot;, StringReference}, {&quot;gravity&quot;, MagickGravityOptions} } },
    { &quot;Vignette&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;radius&quot;, RealReference},
      {&quot;sigma&quot;, RealReference}, {&quot;x&quot;, IntegerReference},
      {&quot;y&quot;, IntegerReference}, {&quot;background&quot;, StringReference} } },
    { &quot;ContrastStretch&quot;, { {&quot;levels&quot;, StringReference},
      {&quot;black-point&quot;, RealReference},{&quot;white-point&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Sans0&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Sans1&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;AdaptiveSharpen&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;bias&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Transpose&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Transverse&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;AutoOrient&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;AdaptiveBlur&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Sketch&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;angle&quot;, RealReference} } },
    { &quot;UniqueColors&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;AdaptiveResize&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;filter&quot;, MagickFilterOptions}, {&quot;support&quot;, StringReference },
      {&quot;blur&quot;, RealReference } } },
    { &quot;ClipMask&quot;, { {&quot;mask&quot;, ImageReference} } },
    { &quot;LinearStretch&quot;, { {&quot;levels&quot;, StringReference},
      {&quot;black-point&quot;, RealReference},{&quot;white-point&quot;, RealReference} } },
    { &quot;ColorMatrix&quot;, { {&quot;matrix&quot;, ArrayReference} } },
    { &quot;Mask&quot;, { {&quot;mask&quot;, ImageReference} } },
    { &quot;Polaroid&quot;, { {&quot;caption&quot;, StringReference}, {&quot;angle&quot;, RealReference},
      {&quot;font&quot;, StringReference}, {&quot;stroke&quot;, StringReference},
      {&quot;fill&quot;, StringReference}, {&quot;strokewidth&quot;, RealReference},
      {&quot;pointsize&quot;, RealReference}, {&quot;gravity&quot;, MagickGravityOptions},
      {&quot;background&quot;, StringReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions} } },
    { &quot;FloodfillPaint&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;x&quot;, IntegerReference}, {&quot;y&quot;, IntegerReference},
      {&quot;fill&quot;, StringReference}, {&quot;bordercolor&quot;, StringReference},
      {&quot;fuzz&quot;, StringReference}, {&quot;channel&quot;, MagickChannelOptions},
      {&quot;invert&quot;, MagickBooleanOptions} } },
    { &quot;Distort&quot;, { {&quot;points&quot;, ArrayReference}, {&quot;method&quot;, MagickDistortOptions},
      {&quot;virtual-pixel&quot;, MagickVirtualPixelOptions},
      {&quot;best-fit&quot;, MagickBooleanOptions} } },
    { &quot;Clut&quot;, { {&quot;image&quot;, ImageReference},
      {&quot;interpolate&quot;, MagickInterpolateOptions},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;LiquidRescale&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;delta-x&quot;, RealReference}, {&quot;rigidity&quot;, RealReference } } },
    { &quot;Encipher&quot;, { {&quot;passphrase&quot;, StringReference} } },
    { &quot;Decipher&quot;, { {&quot;passphrase&quot;, StringReference} } },
    { &quot;Deskew&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;threshold&quot;, StringReference} } },
    { &quot;Remap&quot;, { {&quot;image&quot;, ImageReference},
      {&quot;dither-method&quot;, MagickDitherOptions} } },
    { &quot;SparseColor&quot;, { {&quot;points&quot;, ArrayReference},
      {&quot;method&quot;, MagickSparseColorOptions},
      {&quot;virtual-pixel&quot;, MagickVirtualPixelOptions},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Function&quot;, { {&quot;parameters&quot;, ArrayReference},
      {&quot;function&quot;, MagickFunctionOptions},
      {&quot;virtual-pixel&quot;, MagickVirtualPixelOptions} } },
    { &quot;SelectiveBlur&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;threshold&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;HaldClut&quot;, { {&quot;image&quot;, ImageReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;BlueShift&quot;, { {&quot;factor&quot;, StringReference} } },
    { &quot;ForwardFourierTransform&quot;, { {&quot;magnitude&quot;, MagickBooleanOptions} } },
    { &quot;InverseFourierTransform&quot;, { {&quot;magnitude&quot;, MagickBooleanOptions} } },
    { &quot;ColorDecisionList&quot;, {
      {&quot;color-correction-collection&quot;, StringReference} } },
    { &quot;AutoGamma&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;AutoLevel&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;LevelColors&quot;, { {&quot;invert&quot;, MagickBooleanOptions},
      {&quot;black-point&quot;, StringReference}, {&quot;white-point&quot;, StringReference},
      {&quot;channel&quot;, MagickChannelOptions}, {&quot;invert&quot;, MagickBooleanOptions} } },
    { &quot;Clamp&quot;, { {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;BrightnessContrast&quot;, { {&quot;levels&quot;, StringReference},
      {&quot;brightness&quot;, RealReference},{&quot;contrast&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Morphology&quot;, { {&quot;kernel&quot;, StringReference},
      {&quot;channel&quot;, MagickChannelOptions}, {&quot;method&quot;, MagickMorphologyOptions},
      {&quot;iterations&quot;, IntegerReference} } },
    { &quot;Mode&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference},{&quot;height&quot;, IntegerReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Statistic&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference},{&quot;height&quot;, IntegerReference},
      {&quot;channel&quot;, MagickChannelOptions}, {&quot;type&quot;, MagickStatisticOptions} } },
    { &quot;Perceptible&quot;, { {&quot;epsilon&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Poly&quot;, { {&quot;terms&quot;, ArrayReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Grayscale&quot;, { {&quot;method&quot;, MagickNoiseOptions} } },
    { &quot;CannyEdge&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;radius&quot;, RealReference}, {&quot;sigma&quot;, RealReference},
      {&quot;lower-percent&quot;, RealReference}, {&quot;upper-percent&quot;, RealReference} } },
    { &quot;HoughLine&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;threshold&quot;, IntegerReference} } },
    { &quot;MeanShift&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;distance&quot;, RealReference} } },
    { &quot;Kuwahara&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;radius&quot;, RealReference},
      {&quot;sigma&quot;, RealReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;ConnectedComponents&quot;, { {&quot;connectivity&quot;, IntegerReference} } },
    { &quot;CopyPixels&quot;, { {&quot;image&quot;, ImageReference}, {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;x&quot;, IntegerReference}, {&quot;y&quot;, IntegerReference},
      {&quot;gravity&quot;, MagickGravityOptions}, {&quot;offset&quot;, StringReference},
      {&quot;dx&quot;, IntegerReference}, {&quot;dy&quot;, IntegerReference} } },
    { &quot;Color&quot;, { {&quot;color&quot;, StringReference} } },
    { &quot;WaveletDenoise&quot;, {  {&quot;geometry&quot;, StringReference},
      {&quot;threshold&quot;, RealReference}, {&quot;softness&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;Colorspace&quot;, { {&quot;colorspace&quot;, MagickColorspaceOptions} } },
    { &quot;AutoThreshold&quot;, { {&quot;method&quot;, MagickAutoThresholdOptions} } },
    { &quot;RangeThreshold&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;low-black&quot;, RealReference}, {&quot;low-white&quot;, RealReference},
      {&quot;high-white&quot;, RealReference}, {&quot;high-black&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;CLAHE&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;width&quot;, IntegerReference},
      {&quot;height&quot;, IntegerReference}, {&quot;number-bins&quot;, IntegerReference},
      {&quot;clip-limit&quot;, RealReference} } },
    { &quot;Kmeans&quot;, { {&quot;geometry&quot;, StringReference}, {&quot;colors&quot;, IntegerReference},
      {&quot;iterations&quot;, IntegerReference}, {&quot;tolerance&quot;, RealReference} } },
    { &quot;ColorThreshold&quot;, { {&quot;start-color&quot;, StringReference},
      {&quot;stop-color&quot;, StringReference}, {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;WhiteBalance&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;BilateralBlur&quot;, { {&quot;geometry&quot;, StringReference},
      {&quot;width&quot;, IntegerReference}, {&quot;height&quot;, IntegerReference},
      {&quot;intensity-sigma&quot;, RealReference}, {&quot;spatial-sigma&quot;, RealReference},
      {&quot;channel&quot;, MagickChannelOptions} } },
    { &quot;SortPixels&quot;, { { (const char *) NULL, NullReference } } },
    { &quot;Integral&quot;, { { (const char *) NULL, NullReference } } },
  };

static SplayTreeInfo
  *magick_registry = (SplayTreeInfo *) NULL;

/*
  Forward declarations.
*/
static Image
  *SetupList(pTHX_ SV *,struct PackageInfo **,SV ***,ExceptionInfo *);

static ssize_t
  strEQcase(const char *,const char *);

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C l o n e P a c k a g e I n f o                                           %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ClonePackageInfo makes a duplicate of the given info, or if info is NULL,
%  a new one.
%
%  The format of the ClonePackageInfo routine is:
%
%      struct PackageInfo *ClonePackageInfo(struct PackageInfo *info,
%        exception)
%
%  A description of each parameter follows:
%
%    o info: a structure of type info.
%
%    o exception: Return any errors or warnings in this structure.
%
*/
static struct PackageInfo *ClonePackageInfo(struct PackageInfo *info,
  ExceptionInfo *exception)
{
  struct PackageInfo
    *clone_info;

  clone_info=(struct PackageInfo *) AcquireQuantumMemory(1,sizeof(*clone_info));
  if (clone_info == (struct PackageInfo *) NULL)
    {
      ThrowPerlException(exception,ResourceLimitError,
        &quot;UnableToClonePackageInfo&quot;,PackageName);
      return((struct PackageInfo *) NULL);
    }
  if (info == (struct PackageInfo *) NULL)
    {
      clone_info-&gt;image_info=CloneImageInfo((ImageInfo *) NULL);
      return(clone_info);
    }
  *clone_info=(*info);
  clone_info-&gt;image_info=CloneImageInfo(info-&gt;image_info);
  return(clone_info);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   c o n s t a n t                                                           %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  constant() returns a double value for the specified name.
%
%  The format of the constant routine is:
%
%      double constant(char *name,ssize_t sans)
%
%  A description of each parameter follows:
%
%    o value: Method constant returns a double value for the specified name.
%
%    o name: The name of the constant.
%
%    o sans: This integer value is not used.
%
*/
static double constant(char *name,ssize_t sans)
{
  (void) sans;
  errno=0;
  switch (*name)
  {
    case &#039;B&#039;:
    {
      if (strEQ(name,&quot;BlobError&quot;))
        return(BlobError);
      if (strEQ(name,&quot;BlobWarning&quot;))
        return(BlobWarning);
      break;
    }
    case &#039;C&#039;:
    {
      if (strEQ(name,&quot;CacheError&quot;))
        return(CacheError);
      if (strEQ(name,&quot;CacheWarning&quot;))
        return(CacheWarning);
      if (strEQ(name,&quot;CoderError&quot;))
        return(CoderError);
      if (strEQ(name,&quot;CoderWarning&quot;))
        return(CoderWarning);
      if (strEQ(name,&quot;ConfigureError&quot;))
        return(ConfigureError);
      if (strEQ(name,&quot;ConfigureWarning&quot;))
        return(ConfigureWarning);
      if (strEQ(name,&quot;CorruptImageError&quot;))
        return(CorruptImageError);
      if (strEQ(name,&quot;CorruptImageWarning&quot;))
        return(CorruptImageWarning);
      break;
    }
    case &#039;D&#039;:
    {
      if (strEQ(name,&quot;DelegateError&quot;))
        return(DelegateError);
      if (strEQ(name,&quot;DelegateWarning&quot;))
        return(DelegateWarning);
      if (strEQ(name,&quot;DrawError&quot;))
        return(DrawError);
      if (strEQ(name,&quot;DrawWarning&quot;))
        return(DrawWarning);
      break;
    }
    case &#039;E&#039;:
    {
      if (strEQ(name,&quot;ErrorException&quot;))
        return(ErrorException);
      if (strEQ(name,&quot;ExceptionError&quot;))
        return(CoderError);
      if (strEQ(name,&quot;ExceptionWarning&quot;))
        return(CoderWarning);
      break;
    }
    case &#039;F&#039;:
    {
      if (strEQ(name,&quot;FatalErrorException&quot;))
        return(FatalErrorException);
      if (strEQ(name,&quot;FileOpenError&quot;))
        return(FileOpenError);
      if (strEQ(name,&quot;FileOpenWarning&quot;))
        return(FileOpenWarning);
      break;
    }
    case &#039;I&#039;:
    {
      if (strEQ(name,&quot;ImageError&quot;))
        return(ImageError);
      if (strEQ(name,&quot;ImageWarning&quot;))
        return(ImageWarning);
      break;
    }
    case &#039;M&#039;:
    {
      if (strEQ(name,&quot;MaxRGB&quot;))
        return(QuantumRange);
      if (strEQ(name,&quot;MissingDelegateError&quot;))
        return(MissingDelegateError);
      if (strEQ(name,&quot;MissingDelegateWarning&quot;))
        return(MissingDelegateWarning);
      if (strEQ(name,&quot;ModuleError&quot;))
        return(ModuleError);
      if (strEQ(name,&quot;ModuleWarning&quot;))
        return(ModuleWarning);
      break;
    }
    case &#039;O&#039;:
    {
      if (strEQ(name,&quot;Opaque&quot;))
        return(OpaqueAlpha);
      if (strEQ(name,&quot;OptionError&quot;))
        return(OptionError);
      if (strEQ(name,&quot;OptionWarning&quot;))
        return(OptionWarning);
      break;
    }
    case &#039;Q&#039;:
    {
      if (strEQ(name,&quot;MAGICKCORE_QUANTUM_DEPTH&quot;))
        return(MAGICKCORE_QUANTUM_DEPTH);
      if (strEQ(name,&quot;QuantumDepth&quot;))
        return(MAGICKCORE_QUANTUM_DEPTH);
      if (strEQ(name,&quot;QuantumRange&quot;))
        return(QuantumRange);
      break;
    }
    case &#039;R&#039;:
    {
      if (strEQ(name,&quot;ResourceLimitError&quot;))
        return(ResourceLimitError);
      if (strEQ(name,&quot;ResourceLimitWarning&quot;))
        return(ResourceLimitWarning);
      if (strEQ(name,&quot;RegistryError&quot;))
        return(RegistryError);
      if (strEQ(name,&quot;RegistryWarning&quot;))
        return(RegistryWarning);
      break;
    }
    case &#039;S&#039;:
    {
      if (strEQ(name,&quot;StreamError&quot;))
        return(StreamError);
      if (strEQ(name,&quot;StreamWarning&quot;))
        return(StreamWarning);
      if (strEQ(name,&quot;Success&quot;))
        return(0);
      break;
    }
    case &#039;T&#039;:
    {
      if (strEQ(name,&quot;Transparent&quot;))
        return(TransparentAlpha);
      if (strEQ(name,&quot;TypeError&quot;))
        return(TypeError);
      if (strEQ(name,&quot;TypeWarning&quot;))
        return(TypeWarning);
      break;
    }
    case &#039;W&#039;:
    {
      if (strEQ(name,&quot;WarningException&quot;))
        return(WarningException);
      break;
    }
    case &#039;X&#039;:
    {
      if (strEQ(name,&quot;XServerError&quot;))
        return(XServerError);
      if (strEQ(name,&quot;XServerWarning&quot;))
        return(XServerWarning);
      break;
    }
  }
  errno=EINVAL;
  return(0);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   D e s t r o y P a c k a g e I n f o                                       %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  Method DestroyPackageInfo frees a previously created info structure.
%
%  The format of the DestroyPackageInfo routine is:
%
%      DestroyPackageInfo(struct PackageInfo *info)
%
%  A description of each parameter follows:
%
%    o info: a structure of type info.
%
*/
static void DestroyPackageInfo(struct PackageInfo *info)
{
  info-&gt;image_info=DestroyImageInfo(info-&gt;image_info);
  info=(struct PackageInfo *) RelinquishMagickMemory(info);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   G e t L i s t                                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  Method GetList is recursively called by SetupList to traverse the
%  Image__Magick reference.  If building an reference_vector (see SetupList),
%  *current is the current position in *reference_vector and *last is the final
%  entry in *reference_vector.
%
%  The format of the GetList routine is:
%
%      GetList(info)
%
%  A description of each parameter follows:
%
%    o info: a structure of type info.
%
*/
static Image *GetList(pTHX_ SV *reference,SV ***reference_vector,
  ssize_t *current,ssize_t *last,ExceptionInfo *exception)
{
  Image
    *image;

  if (reference == (SV *) NULL)
    return(NULL);
  switch (SvTYPE(reference))
  {
    case SVt_PVAV:
    {
      AV
        *av;

      Image
        *head,
        *previous,
        **seen = (Image **) NULL;

      ssize_t
        count = 0,
        i,
        n;

      /*
        Array of images.
      */
      previous=(Image *) NULL;
      head=(Image *) NULL;
      av=(AV *) reference;
      n=av_len(av);
      for (i=0; i &lt;= n; i++)
      {
        SV
          **rv;

        rv=av_fetch(av,i,0);
        if (rv &amp;&amp; *rv &amp;&amp; sv_isobject(*rv))
          {
            image=GetList(aTHX_ SvRV(*rv),reference_vector,current,last,
              exception);
            if (image == (Image *) NULL)
              continue;
            {
              MagickBooleanType duplicate = MagickFalse;
              ssize_t j = 0;
              for (j=0; j &lt; count; j++)
              {
                if (seen[j] == image)
                  {
                    duplicate=MagickTrue;
                    break;
                  }
              }
              if (duplicate != MagickFalse)
                {
                  /*
                    Clone if already seen (adjacent or non-adjacent).
                  */
                  Image *clone = CloneImage(image,0,0,MagickTrue,exception);
                  if (clone == (Image *) NULL)
                    {
                      if (seen != (Image **) NULL)
                        free(seen);
                      return(NULL);
                    }
                  image=clone;
                }
              seen=(Image **) realloc(seen,(count+1)*sizeof(Image *));
              if (seen == (Image **) NULL)
                return((Image *) NULL);
              seen[count++]=image;
            }
            image-&gt;previous=previous;
            *(previous ? &amp;previous-&gt;next : &amp;head)=image;
            for (previous=image; previous-&gt;next; previous=previous-&gt;next) ;
          }
      }
      if (seen != (Image **) NULL)
        free(seen);
      return(head);
    }
    case SVt_PVMG:
    {
      /*
        Blessed scalar, one image.
      */
      image=INT2PTR(Image *,SvIV(reference));
      if (image == (Image *) NULL)
        return(NULL);
      image-&gt;previous=(Image *) NULL;
      image-&gt;next=(Image *) NULL;
      if (reference_vector)
        {
          if (*current == *last)
            {
              *last+=256;
              if (*reference_vector == (SV **) NULL)
                *reference_vector=(SV **) AcquireQuantumMemory((size_t) *last,
                  sizeof(*reference_vector));
              else
                *reference_vector=(SV **) ResizeQuantumMemory(*reference_vector,
                  (size_t) *last,sizeof(*reference_vector));
            }
          if (*reference_vector == (SV **) NULL)
            {
              ThrowPerlException(exception,ResourceLimitError,
                &quot;MemoryAllocationFailed&quot;,PackageName);
              return((Image *) NULL);
            }
          (*reference_vector)[*current]=reference;
          (*reference_vector)[++(*current)]=NULL;
        }
      return(image);
    }
    default:
      break;
  }
  (void) fprintf(stderr,&quot;GetList: UnrecognizedType %.17g\n&quot;,
    (double) SvTYPE(reference));
  return((Image *) NULL);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   G e t P a c k a g e I n f o                                               %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  Method GetPackageInfo looks up or creates an info structure for the given
%  Image__Magick reference.  If it does create a new one, the information in
%  package_info is used to initialize it.
%
%  The format of the GetPackageInfo routine is:
%
%      struct PackageInfo *GetPackageInfo(void *reference,
%        struct PackageInfo *package_info,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o info: a structure of type info.
%
%    o exception: Return any errors or warnings in this structure.
%
*/
static struct PackageInfo *GetPackageInfo(pTHX_ void *reference,
  struct PackageInfo *package_info,ExceptionInfo *exception)
{
  char
    message[MagickPathExtent];

  struct PackageInfo
    *clone_info;

  SV
    *sv;

  (void) FormatLocaleString(message,MagickPathExtent,&quot;%s::package%s%p&quot;,
    PackageName,XS_VERSION,reference);
  sv=perl_get_sv(message,(TRUE | 0x02));
  if (sv == (SV *) NULL)
    {
      ThrowPerlException(exception,ResourceLimitError,&quot;UnableToGetPackageInfo&quot;,
        message);
      return(package_info);
    }
  if (SvREFCNT(sv) == 0)
    (void) SvREFCNT_inc(sv);
  if (SvIOKp(sv) &amp;&amp; (clone_info=INT2PTR(struct PackageInfo *,SvIV(sv))))
    return(clone_info);
  clone_info=ClonePackageInfo(package_info,exception);
  sv_setiv(sv,PTR2IV(clone_info));
  return(clone_info);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   S e t A t t r i b u t e                                                   %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  SetAttribute() sets the attribute to the value in sval.  This can change
%  either or both of image or info.
%
%  The format of the SetAttribute routine is:
%
%      SetAttribute(struct PackageInfo *info,Image *image,char *attribute,
%        SV *sval,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o list: a list of strings.
%
%    o string: a character string.
%
*/

static double SiPrefixToDoubleInterval(const char *string,const double interval)
{
  char
    *q;

  double
    value;

  value=InterpretSiPrefixValue(string,&amp;q);
  if (*q == &#039;%&#039;)
    value*=interval/100.0;
  return(value);
}

static inline double StringToDouble(const char *string,char **sentinel)
{
  return(InterpretLocaleValue(string,sentinel));
}

static double StringToDoubleInterval(const char *string,const double interval)
{
  char
    *q;

  double
    value;

  value=InterpretLocaleValue(string,&amp;q);
  if (*q == &#039;%&#039;)
    value*=interval/100.0;
  return(value);
}

static inline ssize_t StringToLong(const char *value)
{
  return(strtol(value,(char **) NULL,10));
}

static void SetAttribute(pTHX_ struct PackageInfo *info,Image *image,
  const char *attribute,SV *sval,ExceptionInfo *exception)
{
  GeometryInfo
    geometry_info;

  long
    x,
    y;

  PixelInfo
    pixel;

  MagickStatusType
    flags;

  PixelInfo
    *color,
    target_color;

  ssize_t
    sp;

  switch (*attribute)
  {
    case &#039;A&#039;:
    case &#039;a&#039;:
    {
      if (LocaleCompare(attribute,&quot;adjoin&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;adjoin=sp != 0 ? MagickTrue : MagickFalse;
          break;
        }
      if (LocaleCompare(attribute,&quot;alpha&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickAlphaChannelOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          for ( ; image; image=image-&gt;next)
            (void) SetImageAlphaChannel(image,(AlphaChannelOption) sp,
              exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;antialias&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;antialias=sp != 0 ? MagickTrue : MagickFalse;
          break;
        }
      if (LocaleCompare(attribute,&quot;area-limit&quot;) == 0)
        {
          MagickSizeType
            limit;

          limit=MagickResourceInfinity;
          if (LocaleCompare(SvPV(sval,na),&quot;unlimited&quot;) != 0)
            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
              100.0);
          (void) SetMagickResourceLimit(AreaResource,limit);
          break;
        }
      if (LocaleCompare(attribute,&quot;attenuate&quot;) == 0)
        {
          if (info)
            (void) SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;authenticate&quot;) == 0)
        {
          if (info)
            SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;B&#039;:
    case &#039;b&#039;:
    {
      if (LocaleCompare(attribute,&quot;background&quot;) == 0)
        {
          (void) QueryColorCompliance(SvPV(sval,na),AllCompliance,&amp;target_color,
            exception);
          if (info)
            info-&gt;image_info-&gt;background_color=target_color;
          for ( ; image; image=image-&gt;next)
            image-&gt;background_color=target_color;
          break;
        }
      if (LocaleCompare(attribute,&quot;blue-primary&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
          {
            flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
            image-&gt;chromaticity.blue_primary.x=geometry_info.rho;
            image-&gt;chromaticity.blue_primary.y=geometry_info.sigma;
            if ((flags &amp; SigmaValue) == 0)
              image-&gt;chromaticity.blue_primary.y=
                image-&gt;chromaticity.blue_primary.x;
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;bordercolor&quot;) == 0)
        {
          (void) QueryColorCompliance(SvPV(sval,na),AllCompliance,&amp;target_color,
            exception);
          if (info)
            info-&gt;image_info-&gt;border_color=target_color;
          for ( ; image; image=image-&gt;next)
            image-&gt;border_color=target_color;
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;C&#039;:
    case &#039;c&#039;:
    {
      if (LocaleCompare(attribute,&quot;cache-threshold&quot;) == 0)
        {
          (void) SetMagickResourceLimit(MemoryResource,(MagickSizeType)
            SiPrefixToDoubleInterval(SvPV(sval,na),100.0));
          (void) SetMagickResourceLimit(MapResource,(MagickSizeType)
            (2.0*SiPrefixToDoubleInterval(SvPV(sval,na),100.0)));
          break;
        }
      if (LocaleCompare(attribute,&quot;clip-mask&quot;) == 0)
        {
          Image
            *clip_mask;

          clip_mask=(Image *) NULL;
          if (SvPOK(sval))
            clip_mask=SetupList(aTHX_ SvRV(sval),&amp;info,(SV ***) NULL,exception);
          for ( ; image; image=image-&gt;next)
            SetImageMask(image,ReadPixelMask,clip_mask,exception);
          break;
        }
      if (LocaleNCompare(attribute,&quot;colormap&quot;,8) == 0)
        {
          for ( ; image; image=image-&gt;next)
          {
            int
              items;

            ssize_t
              i;

            if (image-&gt;storage_class == DirectClass)
              continue;
            i=0;
            items=sscanf(attribute,&quot;%*[^[][%ld&quot;,&amp;i);
            (void) items;
            if (i &gt; (ssize_t) image-&gt;colors)
              i%=(ssize_t) image-&gt;colors;
            if ((strchr(SvPV(sval,na),&#039;,&#039;) == 0) ||
                (strchr(SvPV(sval,na),&#039;)&#039;) != 0))
              QueryColorCompliance(SvPV(sval,na),AllCompliance,
                image-&gt;colormap+i,exception);
            else
              {
                color=image-&gt;colormap+i;
                pixel.red=color-&gt;red;
                pixel.green=color-&gt;green;
                pixel.blue=color-&gt;blue;
                flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
                pixel.red=geometry_info.rho;
                pixel.green=geometry_info.sigma;
                pixel.blue=geometry_info.xi;
                color-&gt;red=ClampToQuantum(pixel.red);
                color-&gt;green=ClampToQuantum(pixel.green);
                color-&gt;blue=ClampToQuantum(pixel.blue);
              }
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;colorspace&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickColorspaceOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedColorspace&quot;,
                SvPV(sval,na));
              break;
            }
          for ( ; image; image=image-&gt;next)
            (void) SetImageColorspace(image,(ColorspaceType) sp,exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;comment&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
            (void) SetImageProperty(image,&quot;Comment&quot;,InterpretImageProperties(
              info ? info-&gt;image_info : (ImageInfo *) NULL,image,
              SvPV(sval,na),exception),exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;compression&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickCompressOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedImageCompression&quot;,SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;compression=(CompressionType) sp;
          for ( ; image; image=image-&gt;next)
            image-&gt;compression=(CompressionType) sp;
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;D&#039;:
    case &#039;d&#039;:
    {
      if (LocaleCompare(attribute,&quot;debug&quot;) == 0)
        {
          SetLogEventMask(SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;delay&quot;) == 0)
        {
          flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
          for ( ; image; image=image-&gt;next)
          {
            image-&gt;delay=(size_t) floor(geometry_info.rho+0.5);
            if ((flags &amp; SigmaValue) != 0)
              image-&gt;ticks_per_second=(ssize_t)
                floor(geometry_info.sigma+0.5);
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;disk-limit&quot;) == 0)
        {
          MagickSizeType
            limit;

          limit=MagickResourceInfinity;
          if (LocaleCompare(SvPV(sval,na),&quot;unlimited&quot;) != 0)
            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
              100.0);
          (void) SetMagickResourceLimit(DiskResource,limit);
          break;
        }
      if (LocaleCompare(attribute,&quot;density&quot;) == 0)
        {
          if (IsGeometry(SvPV(sval,na)) == MagickFalse)
            {
              ThrowPerlException(exception,OptionError,&quot;MissingGeometry&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;density,SvPV(sval,na));
          for ( ; image; image=image-&gt;next)
          {
            flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
            image-&gt;resolution.x=geometry_info.rho;
            image-&gt;resolution.y=geometry_info.sigma;
            if ((flags &amp; SigmaValue) == 0)
              image-&gt;resolution.y=image-&gt;resolution.x;
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;depth&quot;) == 0)
        {
          if (info)
            info-&gt;image_info-&gt;depth=(size_t) SvIV(sval);
          for ( ; image; image=image-&gt;next)
            (void) SetImageDepth(image,(size_t) SvIV(sval),exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;dispose&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickDisposeOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedDisposeMethod&quot;,SvPV(sval,na));
              break;
            }
          for ( ; image; image=image-&gt;next)
            image-&gt;dispose=(DisposeType) sp;
          break;
        }
      if (LocaleCompare(attribute,&quot;dither&quot;) == 0)
        {
          if (info)
            {
              sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,
                MagickFalse,SvPV(sval,na)) : SvIV(sval);
              if (sp &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(sval,na));
                  break;
                }
              info-&gt;image_info-&gt;dither=sp != 0 ? MagickTrue : MagickFalse;
            }
          break;
        }
      if (LocaleCompare(attribute,&quot;display&quot;) == 0)
        {
          display:
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;server_name,SvPV(sval,na));
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;E&#039;:
    case &#039;e&#039;:
    {
      if (LocaleCompare(attribute,&quot;endian&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickEndianOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedEndianType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;endian=(EndianType) sp;
          for ( ; image; image=image-&gt;next)
            image-&gt;endian=(EndianType) sp;
          break;
        }
      if (LocaleCompare(attribute,&quot;extract&quot;) == 0)
        {
          /*
            Set image extract geometry.
          */
          (void) CloneString(&amp;info-&gt;image_info-&gt;extract,SvPV(sval,na));
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;F&#039;:
    case &#039;f&#039;:
    {
      if (LocaleCompare(attribute,&quot;filename&quot;) == 0)
        {
          if (info)
            (void) CopyMagickString(info-&gt;image_info-&gt;filename,SvPV(sval,na),
              MagickPathExtent);
          for ( ; image; image=image-&gt;next)
            (void) CopyMagickString(image-&gt;filename,SvPV(sval,na),
              MagickPathExtent);
          break;
        }
      if (LocaleCompare(attribute,&quot;file&quot;) == 0)
        {
          FILE
            *file;

          PerlIO
            *io_info;

          if (info == (struct PackageInfo *) NULL)
            break;
          io_info=IoIFP(sv_2io(sval));
          if (io_info == (PerlIO *) NULL)
            {
              ThrowPerlException(exception,BlobError,&quot;UnableToOpenFile&quot;,
                PackageName);
              break;
            }
          file=PerlIO_findFILE(io_info);
          if (file == (FILE *) NULL)
            {
              ThrowPerlException(exception,BlobError,&quot;UnableToOpenFile&quot;,
                PackageName);
              break;
            }
          SetImageInfoFile(info-&gt;image_info,file);
          break;
        }
      if (LocaleCompare(attribute,&quot;fill&quot;) == 0)
        {
          if (info)
            (void) SetImageOption(info-&gt;image_info,&quot;fill&quot;,SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;font&quot;) == 0)
        {
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;font,SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;foreground&quot;) == 0)
        break;
      if (LocaleCompare(attribute,&quot;fuzz&quot;) == 0)
        {
          if (info)
            info-&gt;image_info-&gt;fuzz=StringToDoubleInterval(SvPV(sval,na),(double)
              QuantumRange+1.0);
          for ( ; image; image=image-&gt;next)
            image-&gt;fuzz=StringToDoubleInterval(SvPV(sval,na),(double)
              QuantumRange+1.0);
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;G&#039;:
    case &#039;g&#039;:
    {
      if (LocaleCompare(attribute,&quot;gamma&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
            image-&gt;gamma=SvNV(sval);
          break;
        }
      if (LocaleCompare(attribute,&quot;gravity&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickGravityOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedGravityType&quot;,SvPV(sval,na));
              break;
            }
          if (info)
            SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
          for ( ; image; image=image-&gt;next)
            image-&gt;gravity=(GravityType) sp;
          break;
        }
      if (LocaleCompare(attribute,&quot;green-primary&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
          {
            flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
            image-&gt;chromaticity.green_primary.x=geometry_info.rho;
            image-&gt;chromaticity.green_primary.y=geometry_info.sigma;
            if ((flags &amp; SigmaValue) == 0)
              image-&gt;chromaticity.green_primary.y=
                image-&gt;chromaticity.green_primary.x;
          }
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;I&#039;:
    case &#039;i&#039;:
    {
      if (LocaleNCompare(attribute,&quot;index&quot;,5) == 0)
        {
          CacheView
            *image_view;

          int
            items;

          long
            index;

          Quantum
            *q;

          for ( ; image; image=image-&gt;next)
          {
            if (image-&gt;storage_class != PseudoClass)
              continue;
            x=0;
            y=0;
            items=sscanf(attribute,&quot;%*[^[][%ld%*[,/]%ld&quot;,&amp;x,&amp;y);
            (void) items;
            image_view=AcquireAuthenticCacheView(image,exception);
            q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
            if (q != (Quantum *) NULL)
              {
                items=sscanf(SvPV(sval,na),&quot;%ld&quot;,&amp;index);
                if ((index &gt;= 0) &amp;&amp; (index &lt; (ssize_t) image-&gt;colors))
                  SetPixelIndex(image,index,q);
                (void) SyncCacheViewAuthenticPixels(image_view,exception);
              }
            image_view=DestroyCacheView(image_view);
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;iterations&quot;) == 0)
        {
  iterations:
          for ( ; image; image=image-&gt;next)
            image-&gt;iterations=(size_t) SvIV(sval);
          break;
        }
      if (LocaleCompare(attribute,&quot;interlace&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickInterlaceOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedInterlaceType&quot;,SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;interlace=(InterlaceType) sp;
          for ( ; image; image=image-&gt;next)
            image-&gt;interlace=(InterlaceType) sp;
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;L&#039;:
    case &#039;l&#039;:
    {
      if (LocaleCompare(attribute,&quot;label&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
            (void) SetImageProperty(image,&quot;label&quot;,InterpretImageProperties(
              info ? info-&gt;image_info : (ImageInfo *) NULL,image,
              SvPV(sval,na),exception),exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;loop&quot;) == 0)
        goto iterations;
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;M&#039;:
    case &#039;m&#039;:
    {
      if (LocaleCompare(attribute,&quot;magick&quot;) == 0)
        {
          if (info)
            (void) FormatLocaleString(info-&gt;image_info-&gt;filename,
              MagickPathExtent,&quot;%s:&quot;,SvPV(sval,na));
          for ( ; image; image=image-&gt;next)
            (void) CopyMagickString(image-&gt;magick,SvPV(sval,na),
              MagickPathExtent);
          break;
        }
      if (LocaleCompare(attribute,&quot;map-limit&quot;) == 0)
        {
          MagickSizeType
            limit;

          limit=MagickResourceInfinity;
          if (LocaleCompare(SvPV(sval,na),&quot;unlimited&quot;) != 0)
            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
              100.0);
          (void) SetMagickResourceLimit(MapResource,limit);
          break;
        }
      if (LocaleCompare(attribute,&quot;mask&quot;) == 0)
        {
          Image
            *mask;

          mask=(Image *) NULL;
          if (SvPOK(sval))
            mask=SetupList(aTHX_ SvRV(sval),&amp;info,(SV ***) NULL,exception);
          for ( ; image; image=image-&gt;next)
            SetImageMask(image,ReadPixelMask,mask,exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;mattecolor&quot;) == 0)
        {
          (void) QueryColorCompliance(SvPV(sval,na),AllCompliance,&amp;target_color,
            exception);
          if (info)
            info-&gt;image_info-&gt;alpha_color=target_color;
          for ( ; image; image=image-&gt;next)
            image-&gt;alpha_color=target_color;
          break;
        }
      if (LocaleCompare(attribute,&quot;matte&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          for ( ; image; image=image-&gt;next)
            image-&gt;alpha_trait=sp != 0 ? BlendPixelTrait : UndefinedPixelTrait;
          break;
        }
      if (LocaleCompare(attribute,&quot;memory-limit&quot;) == 0)
        {
          MagickSizeType
            limit;

          limit=MagickResourceInfinity;
          if (LocaleCompare(SvPV(sval,na),&quot;unlimited&quot;) != 0)
            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
              100.0);
          (void) SetMagickResourceLimit(MemoryResource,limit);
          break;
        }
      if (LocaleCompare(attribute,&quot;monochrome&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;monochrome=sp != 0 ? MagickTrue : MagickFalse;
          for ( ; image; image=image-&gt;next)
            (void) SetImageType(image,BilevelType,exception);
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;O&#039;:
    case &#039;o&#039;:
    {
      if (LocaleCompare(attribute,&quot;option&quot;) == 0)
        {
          if (info)
            DefineImageOption(info-&gt;image_info,SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;orientation&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickOrientationOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedOrientationType&quot;,SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;orientation=(OrientationType) sp;
          for ( ; image; image=image-&gt;next)
            image-&gt;orientation=(OrientationType) sp;
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;P&#039;:
    case &#039;p&#039;:
    {
      if (LocaleCompare(attribute,&quot;page&quot;) == 0)
        {
          char
            *geometry;

          geometry=GetPageGeometry(SvPV(sval,na));
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;page,geometry);
          for ( ; image; image=image-&gt;next)
            (void) ParsePageGeometry(image,geometry,&amp;image-&gt;page,exception);
          geometry=(char *) RelinquishMagickMemory(geometry);
          break;
        }
      if (LocaleNCompare(attribute,&quot;pixel&quot;,5) == 0)
        {
          CacheView
            *image_view;

          int
            items;

          PixelInfo
            pixel;

          Quantum
            *q;

          for ( ; image; image=image-&gt;next)
          {
            if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
              break;
            x=0;
            y=0;
            items=sscanf(attribute,&quot;%*[^[][%ld%*[,/]%ld&quot;,&amp;x,&amp;y);
            (void) items;
            image_view=AcquireVirtualCacheView(image,exception);
            q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
            if (q != (Quantum *) NULL)
              {
                if ((strchr(SvPV(sval,na),&#039;,&#039;) == 0) ||
                    (strchr(SvPV(sval,na),&#039;)&#039;) != 0))
                  QueryColorCompliance(SvPV(sval,na),AllCompliance,
                    &amp;pixel,exception);
                else
                  {
                    GetPixelInfo(image,&amp;pixel);
                    flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
                    pixel.red=geometry_info.rho;
                    if ((flags &amp; SigmaValue) != 0)
                      pixel.green=geometry_info.sigma;
                    if ((flags &amp; XiValue) != 0)
                      pixel.blue=geometry_info.xi;
                    if ((flags &amp; PsiValue) != 0)
                      pixel.alpha=geometry_info.psi;
                    if ((flags &amp; ChiValue) != 0)
                      pixel.black=geometry_info.chi;
                  }
                SetPixelRed(image,ClampToQuantum(pixel.red),q);
                SetPixelGreen(image,ClampToQuantum(pixel.green),q);
                SetPixelBlue(image,ClampToQuantum(pixel.blue),q);
                if (image-&gt;colorspace == CMYKColorspace)
                  SetPixelBlack(image,ClampToQuantum(pixel.black),q);
                SetPixelAlpha(image,ClampToQuantum(pixel.alpha),q);
                (void) SyncCacheViewAuthenticPixels(image_view,exception);
              }
            image_view=DestroyCacheView(image_view);
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;pointsize&quot;) == 0)
        {
          if (info)
            {
              (void) ParseGeometry(SvPV(sval,na),&amp;geometry_info);
              info-&gt;image_info-&gt;pointsize=geometry_info.rho;
            }
          break;
        }
      if (LocaleCompare(attribute,&quot;precision&quot;) == 0)
        {
          (void) SetMagickPrecision(SvIV(sval));
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;Q&#039;:
    case &#039;q&#039;:
    {
      if (LocaleCompare(attribute,&quot;quality&quot;) == 0)
        {
          if (info)
            info-&gt;image_info-&gt;quality=(size_t) SvIV(sval);
          for ( ; image; image=image-&gt;next)
            image-&gt;quality=(size_t) SvIV(sval);
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;R&#039;:
    case &#039;r&#039;:
    {
      if (LocaleCompare(attribute,&quot;read-mask&quot;) == 0)
        {
          Image
            *mask;

          mask=(Image *) NULL;
          if (SvPOK(sval))
            mask=SetupList(aTHX_ SvRV(sval),&amp;info,(SV ***) NULL,exception);
          for ( ; image; image=image-&gt;next)
            SetImageMask(image,ReadPixelMask,mask,exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;red-primary&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
          {
            flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
            image-&gt;chromaticity.red_primary.x=geometry_info.rho;
            image-&gt;chromaticity.red_primary.y=geometry_info.sigma;
            if ((flags &amp; SigmaValue) == 0)
              image-&gt;chromaticity.red_primary.y=
                image-&gt;chromaticity.red_primary.x;
          }
          break;
        }
      if (LocaleNCompare(attribute,&quot;registry:&quot;,9) == 0)
        {
          (void) SetImageRegistry(StringRegistryType,attribute+9,SvPV(sval,na),
            exception);
          break;
        }
      if (LocaleCompare(attribute,&quot;render&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickIntentOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedIntentType&quot;,
                SvPV(sval,na));
              break;
            }
         for ( ; image; image=image-&gt;next)
           image-&gt;rendering_intent=(RenderingIntent) sp;
         break;
       }
      if (LocaleCompare(attribute,&quot;repage&quot;) == 0)
        {
          RectangleInfo
            geometry;

          for ( ; image; image=image-&gt;next)
          {
            flags=ParseAbsoluteGeometry(SvPV(sval,na),&amp;geometry);
            if ((flags &amp; WidthValue) != 0)
              {
                if ((flags &amp; HeightValue) == 0)
                  geometry.height=geometry.width;
                image-&gt;page.width=geometry.width;
                image-&gt;page.height=geometry.height;
              }
            if ((flags &amp; AspectValue) != 0)
              {
                if ((flags &amp; XValue) != 0)
                  image-&gt;page.x+=geometry.x;
                if ((flags &amp; YValue) != 0)
                  image-&gt;page.y+=geometry.y;
              }
            else
              {
                if ((flags &amp; XValue) != 0)
                  {
                    image-&gt;page.x=geometry.x;
                    if (((flags &amp; WidthValue) != 0) &amp;&amp; (geometry.x &gt; 0))
                      image-&gt;page.width=(size_t) ((ssize_t) image-&gt;columns+
                        geometry.x);
                  }
                if ((flags &amp; YValue) != 0)
                  {
                    image-&gt;page.y=geometry.y;
                    if (((flags &amp; HeightValue) != 0) &amp;&amp; (geometry.y &gt; 0))
                      image-&gt;page.height=(size_t) ((ssize_t) image-&gt;rows+
                        geometry.y);
                  }
              }
          }
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;S&#039;:
    case &#039;s&#039;:
    {
      if (LocaleCompare(attribute,&quot;sampling-factor&quot;) == 0)
        {
          if (IsGeometry(SvPV(sval,na)) == MagickFalse)
            {
              ThrowPerlException(exception,OptionError,&quot;MissingGeometry&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;sampling_factor,
              SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;scene&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
            image-&gt;scene=(size_t) SvIV(sval);
          break;
        }
      if (LocaleCompare(attribute,&quot;server&quot;) == 0)
        goto display;
      if (LocaleCompare(attribute,&quot;size&quot;) == 0)
        {
          if (info)
            {
              if (IsGeometry(SvPV(sval,na)) == MagickFalse)
                {
                  ThrowPerlException(exception,OptionError,&quot;MissingGeometry&quot;,
                    SvPV(sval,na));
                  break;
                }
              (void) CloneString(&amp;info-&gt;image_info-&gt;size,SvPV(sval,na));
            }
          break;
        }
      if (LocaleCompare(attribute,&quot;stroke&quot;) == 0)
        {
          if (info)
            (void) SetImageOption(info-&gt;image_info,&quot;stroke&quot;,SvPV(sval,na));
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;T&#039;:
    case &#039;t&#039;:
    {
      if (LocaleCompare(attribute,&quot;texture&quot;) == 0)
        {
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;texture,SvPV(sval,na));
          break;
        }
      if (LocaleCompare(attribute,&quot;thread-limit&quot;) == 0)
        {
          MagickSizeType
            limit;

          limit=MagickResourceInfinity;
          if (LocaleCompare(SvPV(sval,na),&quot;unlimited&quot;) != 0)
            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
              100.0);
          (void) SetMagickResourceLimit(ThreadResource,limit);
          break;
        }
      if (LocaleCompare(attribute,&quot;tile-offset&quot;) == 0)
        {
          char
            *geometry;

          geometry=GetPageGeometry(SvPV(sval,na));
          if (info)
            (void) CloneString(&amp;info-&gt;image_info-&gt;page,geometry);
          for ( ; image; image=image-&gt;next)
            (void) ParsePageGeometry(image,geometry,&amp;image-&gt;tile_offset,
              exception);
          geometry=(char *) RelinquishMagickMemory(geometry);
          break;
        }
      if (LocaleCompare(attribute,&quot;time-limit&quot;) == 0)
        {
          MagickSizeType
            limit;

          limit=MagickResourceInfinity;
          if (LocaleCompare(SvPV(sval,na),&quot;unlimited&quot;) != 0)
            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
              100.0);
          (void) SetMagickResourceLimit(TimeResource,limit);
          break;
        }
      if (LocaleCompare(attribute,&quot;transparent-color&quot;) == 0)
        {
          (void) QueryColorCompliance(SvPV(sval,na),AllCompliance,&amp;target_color,
            exception);
          if (info)
            info-&gt;image_info-&gt;transparent_color=target_color;
          for ( ; image; image=image-&gt;next)
            image-&gt;transparent_color=target_color;
          break;
        }
      if (LocaleCompare(attribute,&quot;type&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickTypeOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;type=(ImageType) sp;
          for ( ; image; image=image-&gt;next)
            SetImageType(image,(ImageType) sp,exception);
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;U&#039;:
    case &#039;u&#039;:
    {
      if (LocaleCompare(attribute,&quot;units&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickResolutionOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedUnitsType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;units=(ResolutionType) sp;
          for ( ; image; image=image-&gt;next)
          {
            ResolutionType
              units;

            units=(ResolutionType) sp;
            if (image-&gt;units != units)
              switch (image-&gt;units)
              {
                case UndefinedResolution:
                case PixelsPerInchResolution:
                {
                  if (units == PixelsPerCentimeterResolution)
                    {
                      image-&gt;resolution.x*=2.54;
                      image-&gt;resolution.y*=2.54;
                    }
                  break;
                }
                case PixelsPerCentimeterResolution:
                {
                  if (units == PixelsPerInchResolution)
                    {
                      image-&gt;resolution.x/=2.54;
                      image-&gt;resolution.y/=2.54;
                    }
                  break;
                }
              }
            image-&gt;units=units;
          }
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;V&#039;:
    case &#039;v&#039;:
    {
      if (LocaleCompare(attribute,&quot;verbose&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
            SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                SvPV(sval,na));
              break;
            }
          if (info)
            info-&gt;image_info-&gt;verbose=sp != 0 ? MagickTrue : MagickFalse;
          break;
        }
      if (LocaleCompare(attribute,&quot;virtual-pixel&quot;) == 0)
        {
          sp=SvPOK(sval) ? ParseCommandOption(MagickVirtualPixelOptions,
            MagickFalse,SvPV(sval,na)) : SvIV(sval);
          if (sp &lt; 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedVirtualPixelMethod&quot;,SvPV(sval,na));
              break;
            }
          for ( ; image; image=image-&gt;next)
            SetImageVirtualPixelMethod(image,(VirtualPixelMethod) sp,exception);
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    case &#039;W&#039;:
    case &#039;w&#039;:
    {
      if (LocaleCompare(attribute,&quot;white-point&quot;) == 0)
        {
          for ( ; image; image=image-&gt;next)
          {
            flags=ParseGeometry(SvPV(sval,na),&amp;geometry_info);
            image-&gt;chromaticity.white_point.x=geometry_info.rho;
            image-&gt;chromaticity.white_point.y=geometry_info.sigma;
            if ((flags &amp; SigmaValue) == 0)
              image-&gt;chromaticity.white_point.y=
                image-&gt;chromaticity.white_point.x;
          }
          break;
        }
      if (LocaleCompare(attribute,&quot;write-mask&quot;) == 0)
        {
          Image
            *mask;

          mask=(Image *) NULL;
          if (SvPOK(sval))
            mask=SetupList(aTHX_ SvRV(sval),&amp;info,(SV ***) NULL,exception);
          for ( ; image; image=image-&gt;next)
            SetImageMask(image,WritePixelMask,mask,exception);
          break;
        }
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
    default:
    {
      if (info)
        SetImageOption(info-&gt;image_info,attribute,SvPV(sval,na));
      for ( ; image; image=image-&gt;next)
      {
        (void) SetImageProperty(image,attribute,SvPV(sval,na),exception);
        (void) SetImageArtifact(image,attribute,SvPV(sval,na));
      }
      break;
    }
  }
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   S e t u p L i s t                                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  Method SetupList returns the list of all the images linked by their
%  image-&gt;next and image-&gt;previous link lists for use with ImageMagick.  If
%  info is non-NULL, an info structure is returned in *info.  If
%  reference_vector is non-NULL,an array of SV* are returned in
%  *reference_vector.  Reference_vector is used when the images are going to be
%  replaced with new Image*&#039;s.
%
%  The format of the SetupList routine is:
%
%      Image *SetupList(SV *reference,struct PackageInfo **info,
%        SV ***reference_vector,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o list: a list of strings.
%
%    o string: a character string.
%
%    o exception: Return any errors or warnings in this structure.
%
*/
static Image *SetupList(pTHX_ SV *reference,struct PackageInfo **info,
  SV ***reference_vector,ExceptionInfo *exception)
{
  Image
    *image;

  ssize_t
    current,
    last;

  if (reference_vector)
    *reference_vector=NULL;
  if (info)
    *info=NULL;
  current=0;
  last=0;
  image=GetList(aTHX_ reference,reference_vector,&amp;current,&amp;last,exception);
  if (info &amp;&amp; (SvTYPE(reference) == SVt_PVAV))
    *info=GetPackageInfo(aTHX_ (void *) reference,(struct PackageInfo *) NULL,
      exception);
  return(image);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   s t r E Q c a s e                                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  strEQcase() compares two strings and returns 0 if they are the
%  same or if the second string runs out first.  The comparison is case
%  insensitive.
%
%  The format of the strEQcase routine is:
%
%      ssize_t strEQcase(const char *p,const char *q)
%
%  A description of each parameter follows:
%
%    o p: a character string.
%
%    o q: a character string.
%
%
*/
static ssize_t strEQcase(const char *p,const char *q)
{
  char
    c;

  ssize_t
    i;

  for (i=0 ; (c=(*q)) != 0; i++)
  {
    if ((isUPPER((unsigned char) c) ? toLOWER(c) : c) !=
        (isUPPER((unsigned char) *p) ? toLOWER(*p) : *p))
      return(0);
    p++;
    q++;
  }
  return(((*q == 0) &amp;&amp; (*p == 0)) ? i : 0);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   I m a g e : : M a g i c k                                                 %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
MODULE = Image::Magick PACKAGE = Image::Magick

PROTOTYPES: ENABLE

BOOT:
  MagickCoreGenesis(&quot;PerlMagick&quot;,MagickFalse);
  SetWarningHandler(NULL);
  SetErrorHandler(NULL);
  magick_registry=NewSplayTree((int (*)(const void *,const void *))
    NULL,(void *(*)(void *)) NULL,(void *(*)(void *)) NULL);

void
UNLOAD()
  PPCODE:
  {
    if (magick_registry != (SplayTreeInfo *) NULL)
      magick_registry=DestroySplayTree(magick_registry);
    MagickCoreTerminus();
  }

double
constant(name,argument)
  char *name
  ssize_t argument

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   A n i m a t e                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Animate(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    AnimateImage  = 1
    animate       = 2
    animateimage  = 3
  PPCODE:
  {
    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      i;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    package_info=(struct PackageInfo *) NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    package_info=ClonePackageInfo(info,exception);
    if (items == 2)
      SetAttribute(aTHX_ package_info,NULL,&quot;server&quot;,ST(1),exception);
    else
      if (items &gt; 2)
        for (i=2; i &lt; items; i+=2)
          SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),
            exception);
    (void) AnimateImages(package_info-&gt;image_info,image,exception);
    (void) CatchImageException(image);

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   A p p e n d                                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Append(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    AppendImage  = 1
    append       = 2
    appendimage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      i,
      stack;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    attribute=NULL;
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    /*
      Get options.
    */
    stack=MagickTrue;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;S&#039;:
        case &#039;s&#039;:
        {
          if (LocaleCompare(attribute,&quot;stack&quot;) == 0)
            {
              stack=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (stack &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  return;
                }
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    image=AppendImages(image,stack != 0 ? MagickTrue : MagickFalse,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   A v e r a g e                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Average(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    AverageImage   = 1
    average        = 2
    averageimage   = 3
  PPCODE:
  {
    AV
      *av;

    char
      *p;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    image=EvaluateImages(image,MeanEvaluateOperator,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    /*
      Create blessed Perl array for the returned image.
    */
    av=newAV();
    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    AddImageToRegistry(sv,image);
    rv=newRV(sv);
    av_push(av,sv_bless(rv,hv));
    SvREFCNT_dec(sv);
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    (void) FormatLocaleString(info-&gt;image_info-&gt;filename,MagickPathExtent,
      &quot;average-%.*s&quot;,(int) (MagickPathExtent-9),
      ((p=strrchr(image-&gt;filename,&#039;/&#039;)) ? p+1 : image-&gt;filename));
    (void) CopyMagickString(image-&gt;filename,info-&gt;image_info-&gt;filename,
      MagickPathExtent);
    SetImageInfo(info-&gt;image_info,0,exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   B l o b T o I m a g e                                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
BlobToImage(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    BlobToImage  = 1
    blobtoimage  = 2
    blobto       = 3
  PPCODE:
  {
    AV
      *av;

    char
      **keep,
      **list,
      **p;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      ac,
      i,
      n,
      number_images;

    STRLEN
      *length;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    number_images=0;
    ac=(items &lt; 2) ? 1 : items-1;
    length=(STRLEN *) NULL;
    list=(char **) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*list));
    if (list == (char **) NULL)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    length=(STRLEN *) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*length));
    if (length == (STRLEN *) NULL)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    if (SvTYPE(reference) != SVt_PVAV)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    n=1;
    if (items &lt;= 1)
      {
        ThrowPerlException(exception,OptionError,&quot;NoBlobDefined&quot;,PackageName);
        goto PerlException;
      }
    for (n=0, i=0; i &lt; ac; i++)
    {
      list[n]=(char *) (SvPV(ST(i+1),length[n]));
      if ((items &gt;= 3) &amp;&amp; strEQcase((char *) SvPV(ST(i+1),na),&quot;blob&quot;))
        {
          list[n]=(char *) (SvPV(ST(i+2),length[n]));
          continue;
        }
      n++;
    }
    list[n]=(char *) NULL;
    keep=list;
    for (i=number_images=0; i &lt; n; i++)
    {
      image=BlobToImage(info-&gt;image_info,list[i],length[i],exception);
      if (image == (Image *) NULL)
        break;
      for ( ; image; image=image-&gt;next)
      {
        AddImageToRegistry(sv,image);
        rv=newRV(sv);
        av_push(av,sv_bless(rv,hv));
        SvREFCNT_dec(sv);
        number_images++;
      }
    }
    /*
      Free resources.
    */
    for (i=0; i &lt; n; i++)
      if (list[i] != (char *) NULL)
        for (p=keep; list[i] != *p++; )
          if (*p == (char *) NULL)
            {
              list[i]=(char *) RelinquishMagickMemory(list[i]);
              break;
            }

  PerlException:
    if (list)
      list=(char **) RelinquishMagickMemory(list);
    if (length)
      length=(STRLEN *) RelinquishMagickMemory(length);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) number_images);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C h a n n e l F x                                                         #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
ChannelFx(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    ChannelFxImage  = 1
    channelfx       = 2
    channelfximage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute,
      expression[MagickPathExtent];

    ChannelType
      channel,
      channel_mask;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    attribute=NULL;
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    /*
      Get options.
    */
    channel=DefaultChannels;
    (void) CopyMagickString(expression,&quot;u&quot;,MagickPathExtent);
    if (items == 2)
      (void) CopyMagickString(expression,(char *) SvPV(ST(1),na),MagickPathExtent);
    else
      for (i=2; i &lt; items; i+=2)
      {
        attribute=(char *) SvPV(ST(i-1),na);
        switch (*attribute)
        {
          case &#039;C&#039;:
          case &#039;c&#039;:
          {
            if (LocaleCompare(attribute,&quot;channel&quot;) == 0)
              {
                ssize_t
                  option;

                option=ParseChannelOption(SvPV(ST(i),na));
                if (option &lt; 0)
                  {
                    ThrowPerlException(exception,OptionError,
                      &quot;UnrecognizedType&quot;,SvPV(ST(i),na));
                    return;
                  }
                channel=(ChannelType) option;
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          case &#039;E&#039;:
          case &#039;e&#039;:
          {
            if (LocaleCompare(attribute,&quot;expression&quot;) == 0)
              {
                (void) CopyMagickString(expression,SvPV(ST(i),na),
                  MagickPathExtent);
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          default:
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
        }
      }
    channel_mask=SetImageChannelMask(image,channel);
    image=ChannelFxImage(image,expression,exception);
    if (image != (Image *) NULL)
      (void) SetImageChannelMask(image,channel_mask);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C l o n e                                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Clone(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    CopyImage   = 1
    copy        = 2
    copyimage   = 3
    CloneImage  = 4
    clone       = 5
    cloneimage  = 6
    Clone       = 7
  PPCODE:
  {
    AV
      *av;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *clone,
      *image;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    /*
      Create blessed Perl array for the returned image.
    */
    av=newAV();
    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    for ( ; image; image=image-&gt;next)
    {
      clone=CloneImage(image,0,0,MagickTrue,exception);
      if (clone == (Image *) NULL)
        break;
      AddImageToRegistry(sv,clone);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C L O N E                                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
CLONE(ref,...)
  SV *ref;
  CODE:
  {
    PERL_UNUSED_VAR(ref);
    if (magick_registry != (SplayTreeInfo *) NULL)
      {
        Image
          *p;

        ResetSplayTreeIterator(magick_registry);
        p=(Image *) GetNextKeyInSplayTree(magick_registry);
        while (p != (Image *) NULL)
        {
          ReferenceImage(p);
          p=(Image *) GetNextKeyInSplayTree(magick_registry);
        }
      }
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C o a l e s c e                                                           #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Coalesce(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    CoalesceImage   = 1
    coalesce        = 2
    coalesceimage   = 3
  PPCODE:
  {
    AV
      *av;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    image=CoalesceImages(image,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C o m p a r e                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Compare(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    CompareImages = 1
    compare      = 2
    compareimage = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    double
      distortion;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *difference_image,
      *image,
      *reconstruct_image;

    MetricType
      metric;

    ssize_t
      i,
      option;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    av=NULL;
    attribute=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    /*
      Get attribute.
    */
    reconstruct_image=image;
    metric=RootMeanSquaredErrorMetric;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;channel&quot;) == 0)
            {
              ssize_t
                option;

              option=ParseChannelOption(SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;UnrecognizedType&quot;,SvPV(ST(i),na));
                  return;
                }
              (void) SetPixelChannelMask(image,(ChannelType) option);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;F&#039;:
        case &#039;f&#039;:
        {
          if (LocaleCompare(attribute,&quot;fuzz&quot;) == 0)
            {
              image-&gt;fuzz=StringToDoubleInterval(SvPV(ST(i),na),100.0);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;I&#039;:
        case &#039;i&#039;:
        {
          if (LocaleCompare(attribute,&quot;image&quot;) == 0)
            {
              reconstruct_image=SetupList(aTHX_ SvRV(ST(i)),
                (struct PackageInfo **) NULL,(SV ***) NULL,exception);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;M&#039;:
        case &#039;m&#039;:
        {
          if (LocaleCompare(attribute,&quot;metric&quot;) == 0)
            {
              option=ParseCommandOption(MagickMetricOptions,MagickFalse,
                SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              metric=(MetricType) option;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    difference_image=CompareImages(image,reconstruct_image,metric,&amp;distortion,
      exception);
    if (difference_image != (Image *) NULL)
      {
        difference_image-&gt;error.mean_error_per_pixel=distortion;
        AddImageToRegistry(sv,difference_image);
        rv=newRV(sv);
        av_push(av,sv_bless(rv,hv));
        SvREFCNT_dec(sv);
      }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C o m p l e x I m a g e s                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
ComplexImages(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    ComplexImages   = 1
    compleximages   = 2
  PPCODE:
  {
    AV
      *av;

    char
      *attribute,
      *p;

    ComplexOperator
      op;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    op=UndefinedComplexOperator;
    if (items == 2)
      {
        ssize_t
          in;

        in=ParseCommandOption(MagickComplexOptions,MagickFalse,(char *)
          SvPV(ST(1),na));
        if (in &lt; 0)
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
              SvPV(ST(1),na));
            return;
          }
        op=(ComplexOperator) in;
      }
    else
      for (i=2; i &lt; items; i+=2)
      {
        attribute=(char *) SvPV(ST(i-1),na);
        switch (*attribute)
        {
          case &#039;O&#039;:
          case &#039;o&#039;:
          {
            if (LocaleCompare(attribute,&quot;operator&quot;) == 0)
              {
                ssize_t
                  in;

                in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
                  MagickComplexOptions,MagickFalse,SvPV(ST(i),na));
                if (in &lt; 0)
                  {
                    ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                      SvPV(ST(i),na));
                    return;
                  }
                op=(ComplexOperator) in;
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          default:
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
        }
      }
    image=ComplexImages(image,op,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    /*
      Create blessed Perl array for the returned image.
    */
    av=newAV();
    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    AddImageToRegistry(sv,image);
    rv=newRV(sv);
    av_push(av,sv_bless(rv,hv));
    SvREFCNT_dec(sv);
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    (void) FormatLocaleString(info-&gt;image_info-&gt;filename,MagickPathExtent,
      &quot;complex-%.*s&quot;,(int) (MagickPathExtent-9),
      ((p=strrchr(image-&gt;filename,&#039;/&#039;)) ? p+1 : image-&gt;filename));
    (void) CopyMagickString(image-&gt;filename,info-&gt;image_info-&gt;filename,
      MagickPathExtent);
    SetImageInfo(info-&gt;image_info,0,exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   C o m p a r e L a y e r s                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
CompareLayers(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    CompareImagesLayers   = 1
    comparelayers        = 2
    compareimagelayers   = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    LayerMethod
      method;

    ssize_t
      i,
      option;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    method=CompareAnyLayer;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;M&#039;:
        case &#039;m&#039;:
        {
          if (LocaleCompare(attribute,&quot;method&quot;) == 0)
            {
              option=ParseCommandOption(MagickLayerOptions,MagickFalse,
                SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
               method=(LayerMethod) option;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    image=CompareImagesLayers(image,method,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   D e s t r o y                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
DESTROY(ref)
  Image::Magick ref=NO_INIT
  PPCODE:
  {
    SV
      *reference;

    PERL_UNUSED_VAR(ref);
    if (sv_isobject(ST(0)) == 0)
      croak(&quot;ReferenceIsNotMyType&quot;);
    reference=SvRV(ST(0));
    switch (SvTYPE(reference))
    {
      case SVt_PVAV:
      {
        char
          message[MagickPathExtent];

        const SV
          *key;

        HV
          *hv;

        GV
          **gvp;

        struct PackageInfo
          *info;

        SV
          *sv;

        /*
          Array (AV *) reference
        */
        (void) FormatLocaleString(message,MagickPathExtent,&quot;package%s%p&quot;,
          XS_VERSION,(void *) reference);
        hv=gv_stashpv(PackageName, FALSE);
        if (!hv)
          break;
        gvp=(GV **) hv_fetch(hv,message,(long) strlen(message),FALSE);
        if (!gvp)
          break;
        sv=GvSV(*gvp);
        if (sv &amp;&amp; (SvREFCNT(sv) == 1) &amp;&amp; SvIOK(sv))
          {
            info=INT2PTR(struct PackageInfo *,SvIV(sv));
            DestroyPackageInfo(info);
          }
        key=hv_delete(hv,message,(long) strlen(message),G_DISCARD);
        (void) key;
        break;
      }
      case SVt_PVMG:
      {
        Image
          *image;

        /*
          Blessed scalar = (Image *) SvIV(reference)
        */
        image=INT2PTR(Image *,SvIV(reference));
        if (image != (Image *) NULL)
          DeleteImageFromRegistry(reference,image);
        break;
      }
      default:
        break;
    }
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   D i s p l a y                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Display(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    DisplayImage  = 1
    display       = 2
    displayimage  = 3
  PPCODE:
  {
    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      i;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    package_info=(struct PackageInfo *) NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    package_info=ClonePackageInfo(info,exception);
    if (items == 2)
      SetAttribute(aTHX_ package_info,NULL,&quot;server&quot;,ST(1),exception);
    else
      if (items &gt; 2)
        for (i=2; i &lt; items; i+=2)
          SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),
            exception);
    (void) DisplayImages(package_info-&gt;image_info,image,exception);
    (void) CatchImageException(image);

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   E v a l u a t e I m a g e s                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
EvaluateImages(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    EvaluateImages   = 1
    evaluateimages   = 2
  PPCODE:
  {
    AV
      *av;

    char
      *attribute,
      *p;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    MagickEvaluateOperator
      op;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    op=MeanEvaluateOperator;
    if (items == 2)
      {
        ssize_t
          in;

        in=ParseCommandOption(MagickEvaluateOptions,MagickFalse,(char *)
          SvPV(ST(1),na));
        if (in &lt; 0)
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
              SvPV(ST(1),na));
            return;
          }
        op=(MagickEvaluateOperator) in;
      }
    else
      for (i=2; i &lt; items; i+=2)
      {
        attribute=(char *) SvPV(ST(i-1),na);
        switch (*attribute)
        {
          case &#039;O&#039;:
          case &#039;o&#039;:
          {
            if (LocaleCompare(attribute,&quot;operator&quot;) == 0)
              {
                ssize_t
                  in;

                in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
                  MagickEvaluateOptions,MagickFalse,SvPV(ST(i),na));
                if (in &lt; 0)
                  {
                    ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                      SvPV(ST(i),na));
                    return;
                  }
                op=(MagickEvaluateOperator) in;
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          default:
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
        }
      }
    image=EvaluateImages(image,op,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    /*
      Create blessed Perl array for the returned image.
    */
    av=newAV();
    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    AddImageToRegistry(sv,image);
    rv=newRV(sv);
    av_push(av,sv_bless(rv,hv));
    SvREFCNT_dec(sv);
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    (void) FormatLocaleString(info-&gt;image_info-&gt;filename,MagickPathExtent,
      &quot;evaluate-%.*s&quot;,(int) (MagickPathExtent-9),
      ((p=strrchr(image-&gt;filename,&#039;/&#039;)) ? p+1 : image-&gt;filename));
    (void) CopyMagickString(image-&gt;filename,info-&gt;image_info-&gt;filename,
      MagickPathExtent);
    SetImageInfo(info-&gt;image_info,0,exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   F e a t u r e s                                                           #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Features(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    FeaturesImage = 1
    features      = 2
    featuresimage = 3
  PPCODE:
  {
#define ChannelFeatures(channel,direction) \
{ \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].angular_second_moment[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].contrast[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].contrast[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].variance_sum_of_squares[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].inverse_difference_moment[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].sum_average[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].sum_variance[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].sum_entropy[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].entropy[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].difference_variance[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].difference_entropy[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].measure_of_correlation_1[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].measure_of_correlation_2[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_features[channel].maximum_correlation_coefficient[direction]); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
}

    AV
      *av;

    char
      *attribute,
      message[MagickPathExtent];

    ChannelFeatures
      *channel_features;

    double
      distance;

    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      i,
      count;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    av=newAV();
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    distance=1.0;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;D&#039;:
        case &#039;d&#039;:
        {
          if (LocaleCompare(attribute,&quot;distance&quot;) == 0)
            {
              distance=StringToLong((char *) SvPV(ST(1),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    count=0;
    for ( ; image; image=image-&gt;next)
    {
      ssize_t
        j;

      channel_features=GetImageFeatures(image,distance,exception);
      if (channel_features == (ChannelFeatures *) NULL)
        continue;
      count++;
      for (j=0; j &lt; 4; j++)
      {
        for (i=0; i &lt; (ssize_t) GetPixelChannels(image); i++)
        {
          PixelChannel channel=GetPixelChannelChannel(image,i);
          PixelTrait traits=GetPixelChannelTraits(image,channel);
          if (traits == UndefinedPixelTrait)
            continue;
          EXTEND(sp,14*(i+1)*count);
          ChannelFeatures(channel,j);
        }
      }
      channel_features=(ChannelFeatures *)
        RelinquishMagickMemory(channel_features);
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   F l a t t e n                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Flatten(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    FlattenImage   = 1
    flatten        = 2
    flattenimage   = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute,
      *p;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    PixelInfo
      background_color;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    background_color=image-&gt;background_color;
    if (items == 2)
      (void) QueryColorCompliance((char *) SvPV(ST(1),na),AllCompliance,
        &amp;background_color,exception);
    else
      for (i=2; i &lt; items; i+=2)
      {
        attribute=(char *) SvPV(ST(i-1),na);
        switch (*attribute)
        {
          case &#039;B&#039;:
          case &#039;b&#039;:
          {
            if (LocaleCompare(attribute,&quot;background&quot;) == 0)
              {
                (void) QueryColorCompliance((char *) SvPV(ST(1),na),
                  AllCompliance,&amp;background_color,exception);
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          default:
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
        }
      }
    image-&gt;background_color=background_color;
    image=MergeImageLayers(image,FlattenLayer,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    /*
      Create blessed Perl array for the returned image.
    */
    av=newAV();
    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    AddImageToRegistry(sv,image);
    rv=newRV(sv);
    av_push(av,sv_bless(rv,hv));
    SvREFCNT_dec(sv);
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    (void) FormatLocaleString(info-&gt;image_info-&gt;filename,MagickPathExtent,
      &quot;flatten-%.*s&quot;,(int) (MagickPathExtent-9),
      ((p=strrchr(image-&gt;filename,&#039;/&#039;)) ? p+1 : image-&gt;filename));
    (void) CopyMagickString(image-&gt;filename,info-&gt;image_info-&gt;filename,
      MagickPathExtent);
    SetImageInfo(info-&gt;image_info,0,exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);  /* return messages in string context */
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   F x                                                                       #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Fx(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    FxImage  = 1
    fx       = 2
    fximage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute,
      expression[MagickPathExtent];

    ChannelType
      channel,
      channel_mask;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    attribute=NULL;
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    /*
      Get options.
    */
    channel=DefaultChannels;
    (void) CopyMagickString(expression,&quot;u&quot;,MagickPathExtent);
    if (items == 2)
      (void) CopyMagickString(expression,(char *) SvPV(ST(1),na),MagickPathExtent);
    else
      for (i=2; i &lt; items; i+=2)
      {
        attribute=(char *) SvPV(ST(i-1),na);
        switch (*attribute)
        {
          case &#039;C&#039;:
          case &#039;c&#039;:
          {
            if (LocaleCompare(attribute,&quot;channel&quot;) == 0)
              {
                ssize_t
                  option;

                option=ParseChannelOption(SvPV(ST(i),na));
                if (option &lt; 0)
                  {
                    ThrowPerlException(exception,OptionError,
                      &quot;UnrecognizedType&quot;,SvPV(ST(i),na));
                    return;
                  }
                channel=(ChannelType) option;
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          case &#039;E&#039;:
          case &#039;e&#039;:
          {
            if (LocaleCompare(attribute,&quot;expression&quot;) == 0)
              {
                (void) CopyMagickString(expression,SvPV(ST(i),na),
                  MagickPathExtent);
                break;
              }
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
          default:
          {
            ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
              attribute);
            break;
          }
        }
      }
    channel_mask=SetImageChannelMask(image,channel);
    image=FxImage(image,expression,exception);
    if (image != (Image *) NULL)
      (void) SetImageChannelMask(image,channel_mask);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t                                                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Get(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    GetAttributes = 1
    GetAttribute  = 2
    get           = 3
    getattributes = 4
    getattribute  = 5
  PPCODE:
  {
    char
      *attribute,
      color[MagickPathExtent];

    const char
      *value;

    ExceptionInfo
      *exception;

    Image
      *image;

    long
      j;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *s;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        XSRETURN_EMPTY;
      }
    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL &amp;&amp; !info)
      XSRETURN_EMPTY;
    EXTEND(sp,items);
    for (i=1; i &lt; items; i++)
    {
      attribute=(char *) SvPV(ST(i),na);
      s=NULL;
      switch (*attribute)
      {
        case &#039;A&#039;:
        case &#039;a&#039;:
        {
          if (LocaleCompare(attribute,&quot;adjoin&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;adjoin);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;antialias&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;antialias);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;area&quot;) == 0)
            {
              s=newSViv((MagickOffsetType) GetMagickResource(AreaResource));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;attenuate&quot;) == 0)
            {
              const char
                *value;

              value=GetImageProperty(image,attribute,exception);
              if (value != (const char *) NULL)
                s=newSVpv(value,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;authenticate&quot;) == 0)
            {
              if (info)
                {
                  const char
                    *option;

                  option=GetImageOption(info-&gt;image_info,attribute);
                  if (option != (const char *) NULL)
                    s=newSVpv(option,0);
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;B&#039;:
        case &#039;b&#039;:
        {
          if (LocaleCompare(attribute,&quot;background&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,
                &quot;%.17g,%.17g,%.17g,%.17g&quot;,(double) image-&gt;background_color.red,
                (double) image-&gt;background_color.green,
                (double) image-&gt;background_color.blue,
                (double) image-&gt;background_color.alpha);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;base-columns&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;magick_columns);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;base-filename&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVpv(image-&gt;magick_filename,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;base-height&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;magick_rows);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;base-rows&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;magick_rows);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;base-width&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;magick_columns);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;blue-primary&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,&quot;%.17g,%.17g&quot;,
                image-&gt;chromaticity.blue_primary.x,
                image-&gt;chromaticity.blue_primary.y);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;bordercolor&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,
                &quot;%.17g,%.17g,%.17g,%.17g&quot;,(double) image-&gt;border_color.red,
                (double) image-&gt;border_color.green,
                (double) image-&gt;border_color.blue,
                (double) image-&gt;border_color.alpha);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;bounding-box&quot;) == 0)
            {
              char
                geometry[MagickPathExtent];

              RectangleInfo
                page;

              if (image == (Image *) NULL)
                break;
              page=GetImageBoundingBox(image,exception);
              (void) FormatLocaleString(geometry,MagickPathExtent,
                &quot;%.17gx%.17g%+.20g%+.20g&quot;,(double) page.width,(double)
                page.height,(double) page.x,(double) page.y);
              s=newSVpv(geometry,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;class&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              s=newSViv(image-&gt;storage_class);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickClassOptions,
                image-&gt;storage_class));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;clip-mask&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  Image
                    *mask_image;

                  SV
                    *sv;

                  sv=NULL;
                  if (image-&gt;read_mask == MagickFalse)
                    ClipImage(image,exception);
                  mask_image=GetImageMask(image,ReadPixelMask,exception);
                  if (mask_image != (Image *) NULL)
                    {
                      AddImageToRegistry(sv,mask_image);
                      s=sv_bless(newRV(sv),SvSTASH(reference));
                    }
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;clip-path&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  Image
                    *mask_image;

                  SV
                    *sv;

                  sv=NULL;
                  if (image-&gt;read_mask != MagickFalse)
                    ClipImage(image,exception);
                  mask_image=GetImageMask(image,ReadPixelMask,exception);
                  if (mask_image != (Image *) NULL)
                    {
                      AddImageToRegistry(sv,mask_image);
                      s=sv_bless(newRV(sv),SvSTASH(reference));
                    }
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;compression&quot;) == 0)
            {
              j=info ? info-&gt;image_info-&gt;compression : image ?
                image-&gt;compression : UndefinedCompression;
              if (info)
                if (info-&gt;image_info-&gt;compression == UndefinedCompression)
                  j=image-&gt;compression;
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickCompressOptions,
                j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;colorspace&quot;) == 0)
            {
              j=image ? image-&gt;colorspace : RGBColorspace;
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickColorspaceOptions,
                j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;colors&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) GetNumberColors(image,(FILE *) NULL,
                  exception));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleNCompare(attribute,&quot;colormap&quot;,8) == 0)
            {
              int
                items;

              if (image == (Image *) NULL || !image-&gt;colormap)
                break;
              j=0;
              items=sscanf(attribute,&quot;%*[^[][%ld&quot;,&amp;j);
              (void) items;
              if (j &gt; (ssize_t) image-&gt;colors)
                j%=(ssize_t) image-&gt;colors;
              (void) FormatLocaleString(color,MagickPathExtent,
                &quot;%.17g,%.17g,%.17g,%.17g&quot;,(double) image-&gt;colormap[j].red,
                (double) image-&gt;colormap[j].green,
                (double) image-&gt;colormap[j].blue,
                (double) image-&gt;colormap[j].alpha);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;columns&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;columns);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;comment&quot;) == 0)
            {
              const char
                *value;

              value=GetImageProperty(image,attribute,exception);
              if (value != (const char *) NULL)
                s=newSVpv(value,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;copyright&quot;) == 0)
            {
              s=newSVpv(GetMagickCopyright(),0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;D&#039;:
        case &#039;d&#039;:
        {
          if (LocaleCompare(attribute,&quot;density&quot;) == 0)
            {
              char
                geometry[MagickPathExtent];

              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(geometry,MagickPathExtent,&quot;%.17gx%.17g&quot;,
                image-&gt;resolution.x,image-&gt;resolution.y);
              s=newSVpv(geometry,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;delay&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;delay);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;depth&quot;) == 0)
            {
              s=newSViv(MAGICKCORE_QUANTUM_DEPTH);
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) GetImageDepth(image,exception));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;directory&quot;) == 0)
            {
              if (image &amp;&amp; image-&gt;directory)
                s=newSVpv(image-&gt;directory,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;dispose&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;

              s=newSViv(image-&gt;dispose);
              (void) sv_setpv(s,
                CommandOptionToMnemonic(MagickDisposeOptions,image-&gt;dispose));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;disk&quot;) == 0)
            {
              s=newSViv((MagickOffsetType) GetMagickResource(DiskResource));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;dither&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;dither);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;display&quot;) == 0)  /* same as server */
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;server_name)
                s=newSVpv(info-&gt;image_info-&gt;server_name,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;E&#039;:
        case &#039;e&#039;:
        {
          if (LocaleCompare(attribute,&quot;elapsed-time&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(GetElapsedTime(&amp;image-&gt;timer));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;endian&quot;) == 0)
            {
              j=info ? info-&gt;image_info-&gt;endian : image ? image-&gt;endian :
                UndefinedEndian;
              if (info)
                if (info-&gt;image_info-&gt;endian == UndefinedEndian)
                  j=image-&gt;endian;
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickEndianOptions,j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;error&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;error.mean_error_per_pixel);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;F&#039;:
        case &#039;f&#039;:
        {
          if (LocaleCompare(attribute,&quot;filesize&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) GetBlobSize(image));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;filename&quot;) == 0)
            {
              if (info &amp;&amp; *info-&gt;image_info-&gt;filename)
                s=newSVpv(info-&gt;image_info-&gt;filename,0);
              if (image != (Image *) NULL)
                s=newSVpv(image-&gt;filename,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;filter&quot;) == 0)
            {
              s=image ? newSViv(image-&gt;filter) : newSViv(0);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickFilterOptions,
                image-&gt;filter));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;font&quot;) == 0)
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;font)
                s=newSVpv(info-&gt;image_info-&gt;font,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;foreground&quot;) == 0)
            continue;
          if (LocaleCompare(attribute,&quot;format&quot;) == 0)
            {
              const MagickInfo
                *magick_info;

              magick_info=(const MagickInfo *) NULL;
              if (info &amp;&amp; (*info-&gt;image_info-&gt;magick != &#039;\0&#039;))
                magick_info=GetMagickInfo(info-&gt;image_info-&gt;magick,exception);
              if (image != (Image *) NULL)
                magick_info=GetMagickInfo(image-&gt;magick,exception);
              if ((magick_info != (const MagickInfo *) NULL) &amp;&amp;
                  (*magick_info-&gt;description != &#039;\0&#039;))
                s=newSVpv((char *) magick_info-&gt;description,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;fuzz&quot;) == 0)
            {
              if (info)
                s=newSVnv(info-&gt;image_info-&gt;fuzz);
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;fuzz);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;G&#039;:
        case &#039;g&#039;:
        {
          if (LocaleCompare(attribute,&quot;gamma&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;gamma);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              if (image &amp;&amp; image-&gt;geometry)
                s=newSVpv(image-&gt;geometry,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;gravity&quot;) == 0)
            {
              s=image ? newSViv(image-&gt;gravity) : newSViv(0);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickGravityOptions,
                image-&gt;gravity));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;green-primary&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,&quot;%.17g,%.17g&quot;,
                image-&gt;chromaticity.green_primary.x,
                image-&gt;chromaticity.green_primary.y);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;H&#039;:
        case &#039;h&#039;:
        {
          if (LocaleCompare(attribute,&quot;height&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;rows);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;I&#039;:
        case &#039;i&#039;:
        {
          if (LocaleCompare(attribute,&quot;icc&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  const StringInfo
                    *profile;

                  profile=GetImageProfile(image,&quot;icc&quot;);
                  if (profile != (StringInfo *) NULL)
                    s=newSVpv((const char *) GetStringInfoDatum(profile),
                      GetStringInfoLength(profile));
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;icm&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  const StringInfo
                    *profile;

                  profile=GetImageProfile(image,&quot;icm&quot;);
                  if (profile != (const StringInfo *) NULL)
                    s=newSVpv((const char *) GetStringInfoDatum(profile),
                      GetStringInfoLength(profile));
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;id&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  char
                    key[MagickPathExtent];

                  MagickBooleanType
                    status;

                  static ssize_t
                    id = 0;

                  (void) FormatLocaleString(key,MagickPathExtent,&quot;%.17g\n&quot;,(double)
                    id);
                  status=SetImageRegistry(ImageRegistryType,key,image,
                    exception);
                  (void) status;
                  s=newSViv(id++);
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleNCompare(attribute,&quot;index&quot;,5) == 0)
            {
              CacheView
                *image_view;

              char
                name[MagickPathExtent];

              const Quantum
                *p;

              int
                items;

              long
                x,
                y;

              if (image == (Image *) NULL)
                break;
              if (image-&gt;storage_class != PseudoClass)
                break;
              x=0;
              y=0;
              items=sscanf(attribute,&quot;%*[^[][%ld%*[,/]%ld&quot;,&amp;x,&amp;y);
              (void) items;
              image_view=AcquireVirtualCacheView(image,exception);
              p=GetCacheViewVirtualPixels(image_view,x,y,1,1,exception);
              if (p != (const Quantum *) NULL)
                {
                  (void) FormatLocaleString(name,MagickPathExtent,QuantumFormat,
                    GetPixelIndex(image,p));
                  s=newSVpv(name,0);
                  PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
                }
              image_view=DestroyCacheView(image_view);
              continue;
            }
          if (LocaleCompare(attribute,&quot;iptc&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  const StringInfo
                    *profile;

                  profile=GetImageProfile(image,&quot;iptc&quot;);
                  if (profile != (const StringInfo *) NULL)
                    s=newSVpv((const char *) GetStringInfoDatum(profile),
                      GetStringInfoLength(profile));
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;iterations&quot;) == 0)  /* same as loop */
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;iterations);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;interlace&quot;) == 0)
            {
              j=info ? info-&gt;image_info-&gt;interlace : image ? image-&gt;interlace :
                UndefinedInterlace;
              if (info)
                if (info-&gt;image_info-&gt;interlace == UndefinedInterlace)
                  j=image-&gt;interlace;
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickInterlaceOptions,
                j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;L&#039;:
        case &#039;l&#039;:
        {
          if (LocaleCompare(attribute,&quot;label&quot;) == 0)
            {
              const char
                *value;

              if (image == (Image *) NULL)
                break;
              value=GetImageProperty(image,&quot;Label&quot;,exception);
              if (value != (const char *) NULL)
                s=newSVpv(value,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;loop&quot;) == 0)  /* same as iterations */
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;iterations);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;M&#039;:
        case &#039;m&#039;:
        {
          if (LocaleCompare(attribute,&quot;magick&quot;) == 0)
            {
              if (info &amp;&amp; *info-&gt;image_info-&gt;magick)
                s=newSVpv(info-&gt;image_info-&gt;magick,0);
              if (image != (Image *) NULL)
                s=newSVpv(image-&gt;magick,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;map&quot;) == 0)
            {
              s=newSViv((MagickOffsetType) GetMagickResource(MapResource));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;maximum-error&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;error.normalized_maximum_error);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;memory&quot;) == 0)
            {
              s=newSViv((MagickOffsetType) GetMagickResource(MemoryResource));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;mean-error&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;error.normalized_mean_error);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;mime&quot;) == 0)
            {
              if (info &amp;&amp; *info-&gt;image_info-&gt;magick)
                s=newSVpv(MagickToMime(info-&gt;image_info-&gt;magick),0);
              if (image != (Image *) NULL)
                s=newSVpv(MagickToMime(image-&gt;magick),0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;mattecolor&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,
                &quot;%.17g,%.17g,%.17g,%.17g&quot;,(double) image-&gt;alpha_color.red,
                (double) image-&gt;alpha_color.green,
                (double) image-&gt;alpha_color.blue,
                (double) image-&gt;alpha_color.alpha);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;matte&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;alpha_trait != UndefinedPixelTrait ?
                  1 : 0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;mime&quot;) == 0)
            {
              const char
                *magick;

              magick=NULL;
              if (info &amp;&amp; *info-&gt;image_info-&gt;magick)
                magick=info-&gt;image_info-&gt;magick;
              if (image != (Image *) NULL)
                magick=image-&gt;magick;
              if (magick)
                {
                  char
                    *mime;

                  mime=MagickToMime(magick);
                  s=newSVpv(mime,0);
                  mime=(char *) RelinquishMagickMemory(mime);
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;monochrome&quot;) == 0)
            {
              if (image == (Image *) NULL)
                continue;
              j=info ? info-&gt;image_info-&gt;monochrome :
                SetImageMonochrome(image,exception);
              s=newSViv(j);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;montage&quot;) == 0)
            {
              if (image &amp;&amp; image-&gt;montage)
                s=newSVpv(image-&gt;montage,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;O&#039;:
        case &#039;o&#039;:
        {
          if (LocaleCompare(attribute,&quot;orientation&quot;) == 0)
            {
              j=info ? info-&gt;image_info-&gt;orientation : image ?
                image-&gt;orientation : UndefinedOrientation;
              if (info)
                if (info-&gt;image_info-&gt;orientation == UndefinedOrientation)
                  j=image-&gt;orientation;
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickOrientationOptions,
                j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;P&#039;:
        case &#039;p&#039;:
        {
          if (LocaleCompare(attribute,&quot;page&quot;) == 0)
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;page)
                s=newSVpv(info-&gt;image_info-&gt;page,0);
              if (image != (Image *) NULL)
                {
                  char
                    geometry[MagickPathExtent];

                  (void) FormatLocaleString(geometry,MagickPathExtent,
                    &quot;%.17gx%.17g%+.20g%+.20g&quot;,(double) image-&gt;page.width,
                    (double) image-&gt;page.height,(double) image-&gt;page.x,(double)
                    image-&gt;page.y);
                  s=newSVpv(geometry,0);
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;page.x&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;page.x);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;page.y&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;page.y);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleNCompare(attribute,&quot;pixel&quot;,5) == 0)
            {
              char
                tuple[MagickPathExtent];

              const Quantum
                *p;

              int
                items;

              long
                x,
                y;

              if (image == (Image *) NULL)
                break;
              x=0;
              y=0;
              items=sscanf(attribute,&quot;%*[^[][%ld%*[,/]%ld&quot;,&amp;x,&amp;y);
              (void) items;
              p=GetVirtualPixels(image,x,y,1,1,exception);
              if (image-&gt;colorspace != CMYKColorspace)
                (void) FormatLocaleString(tuple,MagickPathExtent,QuantumFormat &quot;,&quot;
                  QuantumFormat &quot;,&quot; QuantumFormat &quot;,&quot; QuantumFormat,
                  GetPixelRed(image,p),GetPixelGreen(image,p),
                  GetPixelBlue(image,p),GetPixelAlpha(image,p));
              else
                (void) FormatLocaleString(tuple,MagickPathExtent,QuantumFormat &quot;,&quot;
                  QuantumFormat &quot;,&quot; QuantumFormat &quot;,&quot; QuantumFormat &quot;,&quot;
                  QuantumFormat,GetPixelRed(image,p),GetPixelGreen(image,p),
                  GetPixelBlue(image,p),GetPixelBlack(image,p),
                  GetPixelAlpha(image,p));
              s=newSVpv(tuple,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;pointsize&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;pointsize);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;precision&quot;) == 0)
            {
              s=newSViv((ssize_t) GetMagickPrecision());
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;Q&#039;:
        case &#039;q&#039;:
        {
          if (LocaleCompare(attribute,&quot;quality&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;quality);
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;quality);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;quantum&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) MAGICKCORE_QUANTUM_DEPTH);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;R&#039;:
        case &#039;r&#039;:
        {
          if (LocaleCompare(attribute,&quot;rendering-intent&quot;) == 0)
            {
              s=newSViv(image-&gt;rendering_intent);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickIntentOptions,
                image-&gt;rendering_intent));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;red-primary&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,&quot;%.17g,%.17g&quot;,
                image-&gt;chromaticity.red_primary.x,
                image-&gt;chromaticity.red_primary.y);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleNCompare(attribute,&quot;registry:&quot;,9) == 0)
            {
              const char
                *value;

              value=(const char *) GetImageRegistry(StringRegistryType,
                attribute+9,exception);
              if (value != (const char *) NULL)
                s=newSVpv(value,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;rows&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;rows);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;S&#039;:
        case &#039;s&#039;:
        {
          if (LocaleCompare(attribute,&quot;sampling-factor&quot;) == 0)
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;sampling_factor)
                s=newSVpv(info-&gt;image_info-&gt;sampling_factor,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;server&quot;) == 0)  /* same as display */
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;server_name)
                s=newSVpv(info-&gt;image_info-&gt;server_name,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;size&quot;) == 0)
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;size)
                s=newSVpv(info-&gt;image_info-&gt;size,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;scene&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;scene);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;scenes&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;number_scenes);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;signature&quot;) == 0)
            {
              const char
                *value;

              if (image == (Image *) NULL)
                break;
              (void) SignatureImage(image,exception);
              value=GetImageProperty(image,&quot;Signature&quot;,exception);
              if (value != (const char *) NULL)
                s=newSVpv(value,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;T&#039;:
        case &#039;t&#039;:
        {
          if (LocaleCompare(attribute,&quot;taint&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) IsTaintImage(image));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;texture&quot;) == 0)
            {
              if (info &amp;&amp; info-&gt;image_info-&gt;texture)
                s=newSVpv(info-&gt;image_info-&gt;texture,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;total-ink-density&quot;) == 0)
            {
              s=newSViv(MAGICKCORE_QUANTUM_DEPTH);
              if (image != (Image *) NULL)
                s=newSVnv(GetImageTotalInkDensity(image,exception));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;transparent-color&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,
                &quot;%.17g,%.17g,%.17g,%.17g&quot;,(double) image-&gt;transparent_color.red,
                (double) image-&gt;transparent_color.green,
                (double) image-&gt;transparent_color.blue,
                (double) image-&gt;transparent_color.alpha);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;type&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              j=(ssize_t) GetImageType(image);
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(MagickTypeOptions,j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;U&#039;:
        case &#039;u&#039;:
        {
          if (LocaleCompare(attribute,&quot;units&quot;) == 0)
            {
              j=info ? info-&gt;image_info-&gt;units : image ? image-&gt;units :
                UndefinedResolution;
              if (info)
                if (info-&gt;image_info-&gt;units == UndefinedResolution)
                  j=image-&gt;units;
              if (j == UndefinedResolution)
                s=newSVpv(&quot;undefined units&quot;,0);
              else
                if (j == PixelsPerInchResolution)
                  s=newSVpv(&quot;pixels / inch&quot;,0);
                else
                  s=newSVpv(&quot;pixels / centimeter&quot;,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;user-time&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(GetUserTime(&amp;image-&gt;timer));
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;V&#039;:
        case &#039;v&#039;:
        {
          if (LocaleCompare(attribute,&quot;verbose&quot;) == 0)
            {
              if (info)
                s=newSViv((ssize_t) info-&gt;image_info-&gt;verbose);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;version&quot;) == 0)
            {
              s=newSVpv(GetMagickVersion((size_t *) NULL),0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;virtual-pixel&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              j=(ssize_t) GetImageVirtualPixelMethod(image);
              s=newSViv(j);
              (void) sv_setpv(s,CommandOptionToMnemonic(
                MagickVirtualPixelOptions,j));
              SvIOK_on(s);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;W&#039;:
        case &#039;w&#039;:
        {
          if (LocaleCompare(attribute,&quot;white-point&quot;) == 0)
            {
              if (image == (Image *) NULL)
                break;
              (void) FormatLocaleString(color,MagickPathExtent,&quot;%.17g,%.17g&quot;,
                image-&gt;chromaticity.white_point.x,
                image-&gt;chromaticity.white_point.y);
              s=newSVpv(color,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;width&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSViv((ssize_t) image-&gt;columns);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
             attribute);
          break;
        }
        case &#039;X&#039;:
        case &#039;x&#039;:
        {
          if (LocaleCompare(attribute,&quot;xmp&quot;) == 0)
            {
              if (image != (Image *) NULL)
                {
                  const StringInfo
                    *profile;

                  profile=GetImageProfile(image,&quot;xmp&quot;);
                  if (profile != (StringInfo *) NULL)
                    s=newSVpv((const char *) GetStringInfoDatum(profile),
                      GetStringInfoLength(profile));
                }
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          if (LocaleCompare(attribute,&quot;x-resolution&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;resolution.x);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;Y&#039;:
        case &#039;y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y-resolution&quot;) == 0)
            {
              if (image != (Image *) NULL)
                s=newSVnv(image-&gt;resolution.y);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
          break;
      }
      if (image == (Image *) NULL)
        ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
          attribute)
      else
        {
          value=GetImageProperty(image,attribute,exception);
          if (value != (const char *) NULL)
            {
              s=newSVpv(value,0);
              PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
            }
          else
            if (*attribute != &#039;%&#039;)
              ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
                attribute)
            else
              {
                 char
                   *meta;

                 meta=InterpretImageProperties(info ? info-&gt;image_info :
                   (ImageInfo *) NULL,image,attribute,exception);
                 s=newSVpv(meta,0);
                 PUSHs(s ? sv_2mortal(s) : &amp;sv_undef);
                 meta=(char *) RelinquishMagickMemory(meta);
              }
        }
    }
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t A u t h e n t i c P i x e l s                                       #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void *
GetAuthenticPixels(ref,...)
  Image::Magick ref = NO_INIT
  ALIAS:
    getauthenticpixels = 1
    GetImagePixels = 2
    getimagepixels = 3
  CODE:
  {
    char
      *attribute;

    ExceptionInfo
      *exception;

    Image
      *image;

    RectangleInfo
      region;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    void
      *blob = NULL;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));

    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }

    region.x=0;
    region.y=0;
    region.width=image-&gt;columns;
    region.height=1;
    if (items == 1)
      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&amp;region);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&amp;region);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;H&#039;:
        case &#039;h&#039;:
        {
          if (LocaleCompare(attribute,&quot;height&quot;) == 0)
            {
              region.height=(size_t) SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
        case &#039;X&#039;:
        case &#039;x&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              region.x=SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
        case &#039;Y&#039;:
        case &#039;y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              region.y=SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
        case &#039;W&#039;:
        case &#039;w&#039;:
        {
          if (LocaleCompare(attribute,&quot;width&quot;) == 0)
            {
              region.width=(size_t) SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
      }
    }
    blob=(void *) GetAuthenticPixels(image,region.x,region.y,region.width,
      region.height,exception);
    if (blob != (void *) NULL)
      goto PerlEnd;

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */

  PerlEnd:
    RETVAL = blob;
  }
  OUTPUT:
    RETVAL

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t V i r t u a l P i x e l s                                           #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void *
GetVirtualPixels(ref,...)
  Image::Magick ref = NO_INIT
  ALIAS:
    getvirtualpixels = 1
    AcquireImagePixels = 2
    acquireimagepixels = 3
  CODE:
  {
    char
      *attribute;

    const void
      *blob = NULL;

    ExceptionInfo
      *exception;

    Image
      *image;

    RectangleInfo
      region;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));

    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }

    region.x=0;
    region.y=0;
    region.width=image-&gt;columns;
    region.height=1;
    if (items == 1)
      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&amp;region);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&amp;region);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;H&#039;:
        case &#039;h&#039;:
        {
          if (LocaleCompare(attribute,&quot;height&quot;) == 0)
            {
              region.height=(size_t) SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
        case &#039;X&#039;:
        case &#039;x&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              region.x=SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
        case &#039;Y&#039;:
        case &#039;y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              region.y=SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
        case &#039;W&#039;:
        case &#039;w&#039;:
        {
          if (LocaleCompare(attribute,&quot;width&quot;) == 0)
            {
              region.width=(size_t) SvIV(ST(i));
              continue;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          break;
        }
      }
    }
    blob=(const void *) GetVirtualPixels(image,region.x,region.y,region.width,
      region.height,exception);
    if (blob != (void *) NULL)
      goto PerlEnd;

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */

  PerlEnd:
    RETVAL = (void *) blob;
  }
  OUTPUT:
    RETVAL

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t A u t h e n t i c M e t a c o n t e n t                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void *
GetAuthenticMetacontent(ref,...)
  Image::Magick ref = NO_INIT
  ALIAS:
    getauthenticmetacontent = 1
    GetMetacontent = 2
    getmetacontent = 3
  CODE:
  {
    ExceptionInfo
      *exception;

    Image
      *image;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    void
      *blob = NULL;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));

    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }

    blob=(void *) GetAuthenticMetacontent(image);
    if (blob != (void *) NULL)
      goto PerlEnd;

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */

  PerlEnd:
    RETVAL = blob;
  }
  OUTPUT:
    RETVAL

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t V i r t u a l M e t a c o n t e n t                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void *
GetVirtualMetacontent(ref,...)
  Image::Magick ref = NO_INIT
  ALIAS:
    getvirtualmetacontent = 1
  CODE:
  {
    ExceptionInfo
      *exception;

    Image
      *image;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    void
      *blob = NULL;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));

    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }

    blob=(void *) GetVirtualMetacontent(image);
    if (blob != (void *) NULL)
      goto PerlEnd;

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */

  PerlEnd:
    RETVAL = blob;
  }
  OUTPUT:
    RETVAL

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   H i s t o g r a m                                                         #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Histogram(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    HistogramImage = 1
    histogram      = 2
    histogramimage = 3
  PPCODE:
  {
    AV
      *av;

    char
      message[MagickPathExtent];

    PixelInfo
      *histogram;

    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      i,
      count;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    size_t
      number_colors;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    av=newAV();
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    count=0;
    for ( ; image; image=image-&gt;next)
    {
      histogram=GetImageHistogram(image,&amp;number_colors,exception);
      if (histogram == (PixelInfo *) NULL)
        continue;
      count+=(ssize_t) number_colors;
      EXTEND(sp,6*count);
      for (i=0; i &lt; (ssize_t) number_colors; i++)
      {
        (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,
          histogram[i].red);
        PUSHs(sv_2mortal(newSVpv(message,0)));
        (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,
          histogram[i].green);
        PUSHs(sv_2mortal(newSVpv(message,0)));
        (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,
          histogram[i].blue);
        PUSHs(sv_2mortal(newSVpv(message,0)));
        if (image-&gt;colorspace == CMYKColorspace)
          {
            (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,
              histogram[i].black);
            PUSHs(sv_2mortal(newSVpv(message,0)));
          }
        (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,
          histogram[i].alpha);
        PUSHs(sv_2mortal(newSVpv(message,0)));
        (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,(double)
          histogram[i].count);
        PUSHs(sv_2mortal(newSVpv(message,0)));
      }
      histogram=(PixelInfo *) RelinquishMagickMemory(histogram);
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t P i x e l                                                           #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
GetPixel(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    getpixel = 1
    getPixel = 2
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    const Quantum
      *p;

    ExceptionInfo
      *exception;

    Image
      *image;

    MagickBooleanType
      normalize;

    RectangleInfo
      region;

    ssize_t
      i,
      option;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    normalize=MagickTrue;
    region.x=0;
    region.y=0;
    region.width=image-&gt;columns;
    region.height=1;
    if (items == 1)
      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&amp;region);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;channel&quot;) == 0)
            {
              ssize_t
                option;

              option=ParseChannelOption(SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  return;
                }
              (void) SetPixelChannelMask(image,(ChannelType) option);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&amp;region);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;N&#039;:
        case &#039;n&#039;:
        {
          if (LocaleCompare(attribute,&quot;normalize&quot;) == 0)
            {
              option=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
             normalize=option != 0 ? MagickTrue : MagickFalse;
             break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;x&#039;:
        case &#039;X&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              region.x=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;y&#039;:
        case &#039;Y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              region.y=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    p=GetVirtualPixels(image,region.x,region.y,1,1,exception);
    if (p == (const Quantum *) NULL)
      PUSHs(&amp;sv_undef);
    else
      {
        double
          scale;

        scale=1.0;
        if (normalize != MagickFalse)
          scale=1.0/QuantumRange;
        if ((GetPixelRedTraits(image) &amp; UpdatePixelTrait) != 0)
          PUSHs(sv_2mortal(newSVnv(scale*GetPixelRed(image,p))));
        if ((GetPixelGreenTraits(image) &amp; UpdatePixelTrait) != 0)
          PUSHs(sv_2mortal(newSVnv(scale*GetPixelGreen(image,p))));
        if ((GetPixelBlueTraits(image) &amp; UpdatePixelTrait) != 0)
          PUSHs(sv_2mortal(newSVnv(scale*GetPixelBlue(image,p))));
        if (((GetPixelBlackTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
            (image-&gt;colorspace == CMYKColorspace))
          PUSHs(sv_2mortal(newSVnv(scale*GetPixelBlack(image,p))));
        if ((GetPixelAlphaTraits(image) &amp; UpdatePixelTrait) != 0)
          PUSHs(sv_2mortal(newSVnv(scale*GetPixelAlpha(image,p))));
      }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   G e t P i x e l s                                                         #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
GetPixels(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    getpixels = 1
    getPixels = 2
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    const char
      *map;

    ExceptionInfo
      *exception;

    Image
      *image;

    MagickBooleanType
      normalize,
      status;

    RectangleInfo
      region;

    ssize_t
      i,
      option;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    map=&quot;RGB&quot;;
    if (image-&gt;alpha_trait != UndefinedPixelTrait)
      map=&quot;RGBA&quot;;
    if (image-&gt;colorspace == CMYKColorspace)
      {
        map=&quot;CMYK&quot;;
        if (image-&gt;alpha_trait != UndefinedPixelTrait)
          map=&quot;CMYKA&quot;;
      }
    normalize=MagickFalse;
    region.x=0;
    region.y=0;
    region.width=image-&gt;columns;
    region.height=1;
    if (items == 1)
      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&amp;region);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&amp;region);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;H&#039;:
        case &#039;h&#039;:
        {
          if (LocaleCompare(attribute,&quot;height&quot;) == 0)
            {
              region.height=(size_t) SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;M&#039;:
        case &#039;m&#039;:
        {
          if (LocaleCompare(attribute,&quot;map&quot;) == 0)
            {
              map=SvPV(ST(i),na);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;N&#039;:
        case &#039;n&#039;:
        {
          if (LocaleCompare(attribute,&quot;normalize&quot;) == 0)
            {
              option=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
             normalize=option != 0 ? MagickTrue : MagickFalse;
             break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;W&#039;:
        case &#039;w&#039;:
        {
          if (LocaleCompare(attribute,&quot;width&quot;) == 0)
            {
              region.width=(size_t) SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;x&#039;:
        case &#039;X&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              region.x=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;y&#039;:
        case &#039;Y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              region.y=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    if (normalize != MagickFalse)
      {
        float
          *pixels;

        MemoryInfo
          *pixels_info;

        pixels_info=AcquireVirtualMemory(strlen(map)*region.width,
          region.height*sizeof(*pixels));
        if (pixels_info == (MemoryInfo *) NULL)
          {
            ThrowPerlException(exception,ResourceLimitError,
              &quot;MemoryAllocationFailed&quot;,PackageName);
            goto PerlException;
          }
        pixels=(float *) GetVirtualMemoryBlob(pixels_info);
        status=ExportImagePixels(image,region.x,region.y,region.width,
          region.height,map,FloatPixel,pixels,exception);
        if (status == MagickFalse)
          PUSHs(&amp;sv_undef);
        else
          {
            EXTEND(sp,(ssize_t) (strlen(map)*region.width*region.height));
            for (i=0; i &lt; (ssize_t) (strlen(map)*region.width*region.height); i++)
              PUSHs(sv_2mortal(newSVnv(pixels[i])));
          }
        pixels_info=RelinquishVirtualMemory(pixels_info);
      }
    else
      {
        MemoryInfo
          *pixels_info;

        Quantum
          *pixels;

        pixels_info=AcquireVirtualMemory(strlen(map)*region.width,
          region.height*sizeof(*pixels));
        if (pixels_info == (MemoryInfo *) NULL)
          {
            ThrowPerlException(exception,ResourceLimitError,
              &quot;MemoryAllocationFailed&quot;,PackageName);
            goto PerlException;
          }
        pixels=(Quantum *) GetVirtualMemoryBlob(pixels_info);
        status=ExportImagePixels(image,region.x,region.y,region.width,
          region.height,map,QuantumPixel,pixels,exception);
        if (status == MagickFalse)
          PUSHs(&amp;sv_undef);
        else
          {
            EXTEND(sp,(ssize_t) (strlen(map)*region.width*region.height));
            for (i=0; i &lt; (ssize_t) (strlen(map)*region.width*region.height); i++)
              PUSHs(sv_2mortal(newSViv(pixels[i])));
          }
        pixels_info=RelinquishVirtualMemory(pixels_info);
      }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   I m a g e T o B l o b                                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
ImageToBlob(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    ImageToBlob  = 1
    imagetoblob  = 2
    toblob       = 3
    blob         = 4
  PPCODE:
  {
    char
      filename[MagickPathExtent];

    ExceptionInfo
      *exception;

    Image
      *image,
      *next;

    ssize_t
      i;

    struct PackageInfo
      *info,
      *package_info;

    size_t
      length;

    ssize_t
      scene;

    SV
      *perl_exception,
      *reference;

    void
      *blob;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    package_info=(struct PackageInfo *) NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    package_info=ClonePackageInfo(info,exception);
    for (i=2; i &lt; items; i+=2)
      SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),exception);
    (void) CopyMagickString(filename,package_info-&gt;image_info-&gt;filename,
      MagickPathExtent);
    scene=0;
    for (next=image; next; next=next-&gt;next)
    {
      (void) CopyMagickString(next-&gt;filename,filename,MagickPathExtent);
      next-&gt;scene=(size_t) scene++;
    }
    SetImageInfo(package_info-&gt;image_info,(unsigned int)
      GetImageListLength(image),exception);
    EXTEND(sp,(ssize_t) GetImageListLength(image));
    for ( ; image; image=image-&gt;next)
    {
      length=0;
      blob=ImagesToBlob(package_info-&gt;image_info,image,&amp;length,exception);
      if (blob != (char *) NULL)
        {
          PUSHs(sv_2mortal(newSVpv((const char *) blob,length)));
          blob=(unsigned char *) RelinquishMagickMemory(blob);
        }
      if (package_info-&gt;image_info-&gt;adjoin)
        break;
    }

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   L a y e r s                                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Layers(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    Layers                = 1
    layers           = 2
    OptimizeImageLayers   = 3
    optimizelayers        = 4
    optimizeimagelayers   = 5
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    CompositeOperator
      compose;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image,
      *layers;

    LayerMethod
      method;

    ssize_t
      i,
      option,
      sp;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    compose=image-&gt;compose;
    method=OptimizeLayer;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;compose&quot;) == 0)
            {
              sp=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
                MagickComposeOptions,MagickFalse,SvPV(ST(i),na));
              if (sp &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              compose=(CompositeOperator) sp;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;M&#039;:
        case &#039;m&#039;:
        {
          if (LocaleCompare(attribute,&quot;method&quot;) == 0)
            {
              option=ParseCommandOption(MagickLayerOptions,MagickFalse,
                SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              method=(LayerMethod) option;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    layers=(Image *) NULL;
    switch (method)
    {
      case CompareAnyLayer:
      case CompareClearLayer:
      case CompareOverlayLayer:
      default:
      {
        layers=CompareImagesLayers(image,method,exception);
        break;
      }
      case MergeLayer:
      case FlattenLayer:
      case MosaicLayer:
      {
        layers=MergeImageLayers(image,method,exception);
        break;
      }
      case DisposeLayer:
      {
        layers=DisposeImages(image,exception);
        break;
      }
      case OptimizeImageLayer:
      {
        layers=OptimizeImageLayers(image,exception);
        break;
      }
      case OptimizePlusLayer:
      {
        layers=OptimizePlusImageLayers(image,exception);
        break;
      }
      case OptimizeTransLayer:
      {
        OptimizeImageTransparency(image,exception);
        break;
      }
      case RemoveDupsLayer:
      {
        RemoveDuplicateLayers(&amp;image,exception);
        break;
      }
      case RemoveZeroLayer:
      {
        RemoveZeroDelayLayers(&amp;image,exception);
        break;
      }
      case OptimizeLayer:
      {
        QuantizeInfo
          *quantize_info;

        /*
          General Purpose, GIF Animation Optimizer.
        */
        layers=CoalesceImages(image,exception);
        if (layers == (Image *) NULL)
          break;
        image=layers;
        layers=OptimizeImageLayers(image,exception);
        if (layers == (Image *) NULL)
          break;
        image=DestroyImageList(image);
        image=layers;
        layers=(Image *) NULL;
        OptimizeImageTransparency(image,exception);
        quantize_info=AcquireQuantizeInfo(info-&gt;image_info);
        (void) RemapImages(quantize_info,image,(Image *) NULL,exception);
        quantize_info=DestroyQuantizeInfo(quantize_info);
        break;
      }
      case CompositeLayer:
      {
        Image
          *source;

        RectangleInfo
          geometry;

        /*
          Split image sequence at the first &#039;NULL:&#039; image.
        */
        source=CloneImageList(image,exception);
        while (source != (Image *) NULL)
        {
          source=GetNextImageInList(source);
          if ((source != (Image *) NULL) &amp;&amp;
              (LocaleCompare(source-&gt;magick,&quot;NULL&quot;) == 0))
            break;
        }
        if (source != (Image *) NULL)
          {
            if ((GetPreviousImageInList(source) == (Image *) NULL) ||
                (GetNextImageInList(source) == (Image *) NULL))
              source=(Image *) NULL;
            else
              {
                /*
                  Separate the two lists, junk the null: image.
                */
                source=SplitImageList(source-&gt;previous);
                DeleteImageFromList(&amp;source);
              }
          }
        if (source == (Image *) NULL)
          {
            (void) ThrowMagickException(exception,GetMagickModule(),
              OptionError,&quot;MissingNullSeparator&quot;,&quot;layers Composite&quot;);
            break;
          }
        /*
          Adjust offset with gravity and virtual canvas.
        */
        SetGeometry(image,&amp;geometry);
        (void) ParseAbsoluteGeometry(image-&gt;geometry,&amp;geometry);
        geometry.width=source-&gt;page.width != 0 ? source-&gt;page.width :
          source-&gt;columns;
        geometry.height=source-&gt;page.height != 0 ? source-&gt;page.height :
          source-&gt;rows;
        GravityAdjustGeometry(image-&gt;page.width != 0 ? image-&gt;page.width :
          image-&gt;columns,image-&gt;page.height != 0 ? image-&gt;page.height :
          image-&gt;rows,image-&gt;gravity,&amp;geometry);
        CompositeLayers(image,compose,source,geometry.x,geometry.y,exception);
        source=DestroyImageList(source);
        break;
      }
    }
    if (layers != (Image *) NULL)
      image=layers;
    else
      image=CloneImage(image,0,0,MagickTrue,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   M a g i c k T o M i m e                                                   #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
SV *
MagickToMime(ref,name)
  Image::Magick ref=NO_INIT
  char *name
  ALIAS:
    magicktomime = 1
  CODE:
  {
    char
      *mime;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    mime=MagickToMime(name);
    RETVAL=newSVpv(mime,0);
    mime=(char *) RelinquishMagickMemory(mime);
  }
  OUTPUT:
    RETVAL

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   M o g r i f y                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Mogrify(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    Comment            =   1
    CommentImage       =   2
    Label              =   3
    LabelImage         =   4
    AddNoise           =   5
    AddNoiseImage      =   6
    Colorize           =   7
    ColorizeImage      =   8
    Border             =   9
    BorderImage        =  10
    Blur               =  11
    BlurImage          =  12
    Chop               =  13
    ChopImage          =  14
    Crop               =  15
    CropImage          =  16
    Despeckle          =  17
    DespeckleImage     =  18
    Edge               =  19
    EdgeImage          =  20
    Emboss             =  21
    EmbossImage        =  22
    Enhance            =  23
    EnhanceImage       =  24
    Flip               =  25
    FlipImage          =  26
    Flop               =  27
    FlopImage          =  28
    Frame              =  29
    FrameImage         =  30
    Implode            =  31
    ImplodeImage       =  32
    Magnify            =  33
    MagnifyImage       =  34
    MedianFilter       =  35
    MedianConvolveImage  =  36
    Minify             =  37
    MinifyImage        =  38
    OilPaint           =  39
    OilPaintImage      =  40
    ReduceNoise        =  41
    ReduceNoiseImage   =  42
    Roll               =  43
    RollImage          =  44
    Rotate             =  45
    RotateImage        =  46
    Sample             =  47
    SampleImage        =  48
    Scale              =  49
    ScaleImage         =  50
    Shade              =  51
    ShadeImage         =  52
    Sharpen            =  53
    SharpenImage       =  54
    Shear              =  55
    ShearImage         =  56
    Spread             =  57
    SpreadImage        =  58
    Swirl              =  59
    SwirlImage         =  60
    Resize             =  61
    ResizeImage        =  62
    Zoom               =  63
    ZoomImage          =  64
    Annotate           =  65
    AnnotateImage      =  66
    ColorFloodfill     =  67
    ColorFloodfillImage=  68
    Composite          =  69
    CompositeImage     =  70
    Contrast           =  71
    ContrastImage      =  72
    CycleColormap      =  73
    CycleColormapImage =  74
    Draw               =  75
    DrawImage          =  76
    Equalize           =  77
    EqualizeImage      =  78
    Gamma              =  79
    GammaImage         =  80
    Map                =  81
    MapImage           =  82
    MatteFloodfill     =  83
    MatteFloodfillImage=  84
    Modulate           =  85
    ModulateImage      =  86
    Negate             =  87
    NegateImage        =  88
    Normalize          =  89
    NormalizeImage     =  90
    NumberColors       =  91
    NumberColorsImage  =  92
    Opaque             =  93
    OpaqueImage        =  94
    Quantize           =  95
    QuantizeImage      =  96
    Raise              =  97
    RaiseImage         =  98
    Segment            =  99
    SegmentImage       = 100
    Signature          = 101
    SignatureImage     = 102
    Solarize           = 103
    SolarizeImage      = 104
    Sync               = 105
    SyncImage          = 106
    Texture            = 107
    TextureImage       = 108
    Evaluate           = 109
    EvaluateImage      = 110
    Transparent        = 111
    TransparentImage   = 112
    Threshold          = 113
    ThresholdImage     = 114
    Charcoal           = 115
    CharcoalImage      = 116
    Trim               = 117
    TrimImage          = 118
    Wave               = 119
    WaveImage          = 120
    Separate           = 121
    SeparateImage      = 122
    Stereo             = 125
    StereoImage        = 126
    Stegano            = 127
    SteganoImage       = 128
    Deconstruct        = 129
    DeconstructImage   = 130
    GaussianBlur       = 131
    GaussianBlurImage  = 132
    Convolve           = 133
    ConvolveImage      = 134
    Profile            = 135
    ProfileImage       = 136
    UnsharpMask        = 137
    UnsharpMaskImage   = 138
    MotionBlur         = 139
    MotionBlurImage    = 140
    OrderedDither      = 141
    OrderedDitherImage = 142
    Shave              = 143
    ShaveImage         = 144
    Level              = 145
    LevelImage         = 146
    Clip               = 147
    ClipImage          = 148
    AffineTransform    = 149
    AffineTransformImage = 150
    Difference         = 151
    DifferenceImage    = 152
    AdaptiveThreshold  = 153
    AdaptiveThresholdImage = 154
    Resample           = 155
    ResampleImage      = 156
    Describe           = 157
    DescribeImage      = 158
    BlackThreshold     = 159
    BlackThresholdImage= 160
    WhiteThreshold     = 161
    WhiteThresholdImage= 162
    RotationalBlur     = 163
    RotationalBlurImage= 164
    Thumbnail          = 165
    ThumbnailImage     = 166
    Strip              = 167
    StripImage         = 168
    Tint               = 169
    TintImage          = 170
    Channel            = 171
    ChannelImage       = 172
    Splice             = 173
    SpliceImage        = 174
    Posterize          = 175
    PosterizeImage     = 176
    Shadow             = 177
    ShadowImage        = 178
    Identify           = 179
    IdentifyImage      = 180
    SepiaTone          = 181
    SepiaToneImage     = 182
    SigmoidalContrast  = 183
    SigmoidalContrastImage = 184
    Extent             = 185
    ExtentImage        = 186
    Vignette           = 187
    VignetteImage      = 188
    ContrastStretch    = 189
    ContrastStretchImage = 190
    Sans0              = 191
    Sans0Image         = 192
    Sans1              = 193
    Sans1Image         = 194
    AdaptiveSharpen    = 195
    AdaptiveSharpenImage = 196
    Transpose          = 197
    TransposeImage     = 198
    Transverse         = 199
    TransverseImage    = 200
    AutoOrient         = 201
    AutoOrientImage    = 202
    AdaptiveBlur       = 203
    AdaptiveBlurImage  = 204
    Sketch             = 205
    SketchImage        = 206
    UniqueColors       = 207
    UniqueColorsImage  = 208
    AdaptiveResize     = 209
    AdaptiveResizeImage= 210
    ClipMask           = 211
    ClipMaskImage      = 212
    LinearStretch      = 213
    LinearStretchImage = 214
    ColorMatrix        = 215
    ColorMatrixImage   = 216
    Mask               = 217
    MaskImage          = 218
    Polaroid           = 219
    PolaroidImage      = 220
    FloodfillPaint     = 221
    FloodfillPaintImage= 222
    Distort            = 223
    DistortImage       = 224
    Clut               = 225
    ClutImage          = 226
    LiquidRescale      = 227
    LiquidRescaleImage = 228
    Encipher           = 229
    EncipherImage      = 230
    Decipher           = 231
    DecipherImage      = 232
    Deskew             = 233
    DeskewImage        = 234
    Remap              = 235
    RemapImage         = 236
    SparseColor        = 237
    SparseColorImage   = 238
    Function           = 239
    FunctionImage      = 240
    SelectiveBlur      = 241
    SelectiveBlurImage = 242
    HaldClut           = 243
    HaldClutImage      = 244
    BlueShift          = 245
    BlueShiftImage     = 246
    ForwardFourierTransform  = 247
    ForwardFourierTransformImage = 248
    InverseFourierTransform = 249
    InverseFourierTransformImage = 250
    ColorDecisionList  = 251
    ColorDecisionListImage = 252
    AutoGamma          = 253
    AutoGammaImage     = 254
    AutoLevel          = 255
    AutoLevelImage     = 256
    LevelColors        = 257
    LevelImageColors   = 258
    Clamp              = 259
    ClampImage         = 260
    BrightnessContrast = 261
    BrightnessContrastImage = 262
    Morphology         = 263
    MorphologyImage    = 264
    Mode               = 265
    ModeImage          = 266
    Statistic          = 267
    StatisticImage     = 268
    Perceptible        = 269
    PerceptibleImage   = 270
    Poly               = 271
    PolyImage          = 272
    Grayscale          = 273
    GrayscaleImage     = 274
    CannyEdge          = 275
    CannyEdgeImage     = 276
    HoughLine          = 277
    HoughLineImage     = 278
    MeanShift          = 279
    MeanShiftImage     = 280
    Kuwahara           = 281
    KuwaharaImage      = 282
    ConnectedComponents = 283
    ConnectedComponentsImage = 284
    CopyPixels         = 285
    CopyImagePixels    = 286
    Color              = 287
    ColorImage         = 288
    WaveletDenoise     = 289
    WaveletDenoiseImage= 290
    Colorspace         = 291
    ColorspaceImage    = 292
    AutoThreshold      = 293
    AutoThresholdImage = 294
    RangeThreshold     = 295
    RangeThresholdImage= 296
    CLAHE              = 297
    CLAHEImage         = 298
    Kmeans             = 299
    KMeansImage        = 300
    ColorThreshold     = 301
    ColorThresholdImage= 302
    WhiteBalance       = 303
    WhiteBalanceImage  = 304
    BilateralBlur      = 305
    BilateralBlurImage = 306
    SortPixels         = 307
    SortPixelsImage    = 308
    Integral           = 309
    IntegralImage      = 310
    MogrifyRegion      = 666
  PPCODE:
  {
    AffineMatrix
      affine,
      current;

    char
      attribute_flag[MaxArguments],
      message[MagickPathExtent];

    ChannelType
      channel,
      channel_mask;

    CompositeOperator
      compose;

    const char
      *attribute,
      *value;

    double
      angle;

    ExceptionInfo
      *exception;

    GeometryInfo
      geometry_info;

    Image
      *image,
      *next;

    MagickStatusType
      flags;

    PixelInfo
      fill_color;

    RectangleInfo
      geometry,
      region_info;

    ssize_t
      base,
      i,
      j,
      number_images;

    struct Methods
      *rp;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      **pv,
      *reference,
      **reference_vector;

    struct ArgumentList
      argument_list[MaxArguments];

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference_vector=NULL;
    number_images=0;
    base=2;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    region_info.width=0;
    region_info.height=0;
    region_info.x=0;
    region_info.y=0;
    image=SetupList(aTHX_ reference,&amp;info,&amp;reference_vector,exception);
    if (ix &amp;&amp; (ix != 666))
      {
        /*
          Called as Method(...)
        */
        ix=(ix+1)/2;
        rp=(&amp;Methods[ix-1]);
        attribute=rp-&gt;name;
      }
    else
      {
        /*
          Called as Mogrify(&quot;Method&quot;,...)
        */
        attribute=(char *) SvPV(ST(1),na);
        if (ix)
          {
            flags=ParseGravityGeometry(image,attribute,&amp;region_info,exception);
            attribute=(char *) SvPV(ST(2),na);
            base++;
          }
        for (rp=Methods; ; rp++)
        {
          if (rp &gt;= EndOf(Methods))
            {
              ThrowPerlException(exception,OptionError,
                &quot;UnrecognizedPerlMagickMethod&quot;,attribute);
              goto PerlException;
            }
          if (strEQcase(attribute,rp-&gt;name))
            break;
        }
        ix=rp-Methods+1;
        base++;
      }
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,attribute);
        goto PerlException;
      }
    Zero(&amp;argument_list,NumberOf(argument_list),struct ArgumentList);
    Zero(&amp;attribute_flag,NumberOf(attribute_flag),char);
    for (i=base; (i &lt; items) || ((i == items) &amp;&amp; (base == items)); i+=2)
    {
      Arguments
        *pp,
        *qq;

      ssize_t
        ssize_test;

      struct ArgumentList
        *al;

      SV
        *sv;

      sv=NULL;
      ssize_test=0;
      pp=(Arguments *) NULL;
      qq=rp-&gt;arguments;
      if (i == items)
        {
          pp=rp-&gt;arguments,
          sv=ST(i-1);
        }
      else
        for (sv=ST(i), attribute=(char *) SvPV(ST(i-1),na); ; qq++)
        {
          if ((qq &gt;= EndOf(rp-&gt;arguments)) || (qq-&gt;method == NULL))
            break;
          if (strEQcase(attribute,qq-&gt;method) &gt; ssize_test)
            {
              pp=qq;
              ssize_test=strEQcase(attribute,qq-&gt;method);
            }
        }
      if (pp == (Arguments *) NULL)
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedOption&quot;,
            attribute);
          goto continue_outer_loop;
        }
      al=(&amp;argument_list[pp-rp-&gt;arguments]);
      switch (pp-&gt;type)
      {
        case ArrayReference:
        {
          if (SvTYPE(sv) != SVt_RV)
            {
              (void) FormatLocaleString(message,MagickPathExtent,
                &quot;invalid %.60s value&quot;,pp-&gt;method);
              ThrowPerlException(exception,OptionError,message,SvPV(sv,na));
              goto continue_outer_loop;
            }
          al-&gt;array_reference=SvRV(sv);
          break;
        }
        case RealReference:
        {
          al-&gt;real_reference=SvNV(sv);
          break;
        }
        case FileReference:
        {
          al-&gt;file_reference=(FILE *) PerlIO_findFILE(IoIFP(sv_2io(sv)));
          break;
        }
        case ImageReference:
        {
          if (!sv_isobject(sv) ||
              !(al-&gt;image_reference=SetupList(aTHX_ SvRV(sv),
                (struct PackageInfo **) NULL,(SV ***) NULL,exception)))
            {
              ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
                PackageName);
              goto PerlException;
            }
          break;
        }
        case IntegerReference:
        {
          al-&gt;integer_reference=SvIV(sv);
          break;
        }
        case StringReference:
        {
          al-&gt;string_reference=(char *) SvPV(sv,al-&gt;length);
          if (sv_isobject(sv))
            al-&gt;image_reference=SetupList(aTHX_ SvRV(sv),
              (struct PackageInfo **) NULL,(SV ***) NULL,exception);
          break;
        }
        default:
        {
          /*
            Is a string; look up name.
          */
          if ((al-&gt;length &gt; 1) &amp;&amp; (*(char *) SvPV(sv,al-&gt;length) == &#039;@&#039;))
            {
              al-&gt;string_reference=(char *) SvPV(sv,al-&gt;length);
              al-&gt;integer_reference=(-1);
              break;
            }
          al-&gt;integer_reference=ParseCommandOption((CommandOption) pp-&gt;type,
            MagickFalse,SvPV(sv,na));
          if (pp-&gt;type == MagickChannelOptions)
            al-&gt;integer_reference=ParseChannelOption(SvPV(sv,na));
          if ((al-&gt;integer_reference &lt; 0) &amp;&amp; ((al-&gt;integer_reference=SvIV(sv)) &lt;= 0))
            {
              (void) FormatLocaleString(message,MagickPathExtent,
                &quot;invalid %.60s value&quot;,pp-&gt;method);
              ThrowPerlException(exception,OptionError,message,SvPV(sv,na));
              goto continue_outer_loop;
            }
          break;
        }
      }
      attribute_flag[pp-rp-&gt;arguments]++;
      continue_outer_loop: ;
    }
    (void) ResetMagickMemory((char *) &amp;fill_color,0,sizeof(fill_color));
    pv=reference_vector;
    SetGeometryInfo(&amp;geometry_info);
    channel=DefaultChannels;
    for (next=image; next; next=next-&gt;next)
    {
      image=next;
      SetGeometry(image,&amp;geometry);
      if ((region_info.width*region_info.height) != 0)
        (void) SetImageRegionMask(image,WritePixelMask,&amp;region_info,exception);
      switch (ix)
      {
        default:
        {
          (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,(double) ix);
          ThrowPerlException(exception,OptionError,
            &quot;UnrecognizedPerlMagickMethod&quot;,message);
          goto PerlException;
        }
        case 1:  /* Comment */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=(char *) NULL;
          (void) SetImageProperty(image,&quot;comment&quot;,InterpretImageProperties(
            info ? info-&gt;image_info : (ImageInfo *) NULL,image,
            argument_list[0].string_reference,exception),exception);
          break;
        }
        case 2:  /* Label */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=(char *) NULL;
          (void) SetImageProperty(image,&quot;label&quot;,InterpretImageProperties(
            info ? info-&gt;image_info : (ImageInfo *) NULL,image,
            argument_list[0].string_reference,exception),exception);
          break;
        }
        case 3:  /* AddNoise */
        {
          double
            attenuate;

          if (attribute_flag[0] == 0)
            argument_list[0].integer_reference=UniformNoise;
          attenuate=1.0;
          if (attribute_flag[1] != 0)
            attenuate=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            channel=(ChannelType) argument_list[2].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=AddNoiseImage(image,(NoiseType)
            argument_list[0].integer_reference,attenuate,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 4:  /* Colorize */
        {
          PixelInfo
            target;

          (void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,
            0,0,&amp;target,exception);
          if (attribute_flag[0] != 0)
            (void) QueryColorCompliance(argument_list[0].string_reference,
              AllCompliance,&amp;target,exception);
          if (attribute_flag[1] == 0)
            argument_list[1].string_reference=&quot;100%&quot;;
          image=ColorizeImage(image,argument_list[1].string_reference,&amp;target,
            exception);
          break;
        }
        case 5:  /* Border */
        {
          CompositeOperator
            compose;

          geometry.width=0;
          geometry.height=0;
          if (attribute_flag[0] != 0)
            flags=ParsePageGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            QueryColorCompliance(argument_list[3].string_reference,
              AllCompliance,&amp;image-&gt;border_color,exception);
          if (attribute_flag[4] != 0)
            QueryColorCompliance(argument_list[4].string_reference,
              AllCompliance,&amp;image-&gt;border_color,exception);
          if (attribute_flag[5] != 0)
            QueryColorCompliance(argument_list[5].string_reference,
              AllCompliance,&amp;image-&gt;border_color,exception);
          compose=image-&gt;compose;
          if (attribute_flag[6] != 0)
            compose=(CompositeOperator) argument_list[6].integer_reference;
          image=BorderImage(image,&amp;geometry,compose,exception);
          break;
        }
        case 6:  /* Blur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=BlurImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 7:  /* Chop */
        {
          if (attribute_flag[5] != 0)
            image-&gt;gravity=(GravityType) argument_list[5].integer_reference;
          if (attribute_flag[0] != 0)
            flags=ParseGravityGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry.x=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry.y=argument_list[4].integer_reference;
          image=ChopImage(image,&amp;geometry,exception);
          break;
        }
        case 8:  /* Crop */
        {
          if (attribute_flag[6] != 0)
            image-&gt;gravity=(GravityType) argument_list[6].integer_reference;
          if (attribute_flag[0] != 0)
            flags=ParseGravityGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry.x=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry.y=argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[5].string_reference,(double) QuantumRange+1.0);
          image=CropImage(image,&amp;geometry,exception);
          break;
        }
        case 9:  /* Despeckle */
        {
          image=DespeckleImage(image,exception);
          break;
        }
        case 10:  /* Edge */
        {
          if (attribute_flag[0] != 0)
            geometry_info.rho=argument_list[0].real_reference;
          image=EdgeImage(image,geometry_info.rho,exception);
          break;
        }
        case 11:  /* Emboss */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          image=EmbossImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          break;
        }
        case 12:  /* Enhance */
        {
          image=EnhanceImage(image,exception);
          break;
        }
        case 13:  /* Flip */
        {
          image=FlipImage(image,exception);
          break;
        }
        case 14:  /* Flop */
        {
          image=FlopImage(image,exception);
          break;
        }
        case 15:  /* Frame */
        {
          CompositeOperator
            compose;

          FrameInfo
            frame_info;

          if (attribute_flag[0] != 0)
            {
              flags=ParsePageGeometry(image,argument_list[0].string_reference,
                &amp;geometry,exception);
              frame_info.width=geometry.width;
              frame_info.height=geometry.height;
              frame_info.outer_bevel=geometry.x;
              frame_info.inner_bevel=geometry.y;
            }
          if (attribute_flag[1] != 0)
            frame_info.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            frame_info.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            frame_info.inner_bevel=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            frame_info.outer_bevel=argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            QueryColorCompliance(argument_list[5].string_reference,
              AllCompliance,&amp;fill_color,exception);
          if (attribute_flag[6] != 0)
            QueryColorCompliance(argument_list[6].string_reference,
              AllCompliance,&amp;fill_color,exception);
          frame_info.x=(ssize_t) frame_info.width;
          frame_info.y=(ssize_t) frame_info.height;
          frame_info.width=(size_t) ((ssize_t) image-&gt;columns+2*frame_info.x);
          frame_info.height=(size_t) ((ssize_t) image-&gt;rows+2*frame_info.y);
          if ((attribute_flag[5] != 0) || (attribute_flag[6] != 0))
            image-&gt;alpha_color=fill_color;
          compose=image-&gt;compose;
          if (attribute_flag[7] != 0)
            compose=(CompositeOperator) argument_list[7].integer_reference;
          image=FrameImage(image,&amp;frame_info,compose,exception);
          break;
        }
        case 16:  /* Implode */
        {
          PixelInterpolateMethod
            method;

          if (attribute_flag[0] == 0)
            argument_list[0].real_reference=0.5;
          method=UndefinedInterpolatePixel;
          if (attribute_flag[1] != 0)
            method=(PixelInterpolateMethod) argument_list[1].integer_reference;
          image=ImplodeImage(image,argument_list[0].real_reference,
            method,exception);
          break;
        }
        case 17:  /* Magnify */
        {
          image=MagnifyImage(image,exception);
          break;
        }
        case 18:  /* MedianFilter */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=StatisticImage(image,MedianStatistic,(size_t) geometry_info.rho,
            (size_t) geometry_info.sigma,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 19:  /* Minify */
        {
          image=MinifyImage(image,exception);
          break;
        }
        case 20:  /* OilPaint */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].real_reference=0.0;
          if (attribute_flag[1] == 0)
            argument_list[1].real_reference=1.0;
          image=OilPaintImage(image,argument_list[0].real_reference,
            argument_list[1].real_reference,exception);
          break;
        }
        case 21:  /* ReduceNoise */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=StatisticImage(image,NonpeakStatistic,(size_t)
            geometry_info.rho,(size_t) geometry_info.sigma,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 22:  /* Roll */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParsePageGeometry(image,argument_list[0].string_reference,
                &amp;geometry,exception);
              if ((flags &amp; PercentValue) != 0)
                {
                  geometry.x*=(double) image-&gt;columns/100.0;
                  geometry.y*=(double) image-&gt;rows/100.0;
                }
            }
          if (attribute_flag[1] != 0)
            geometry.x=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.y=argument_list[2].integer_reference;
          image=RollImage(image,geometry.x,geometry.y,exception);
          break;
        }
        case 23:  /* Rotate */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].real_reference=90.0;
          if (attribute_flag[1] != 0)
            {
              QueryColorCompliance(argument_list[1].string_reference,
                AllCompliance,&amp;image-&gt;background_color,exception);
              if ((image-&gt;background_color.alpha_trait != UndefinedPixelTrait) &amp;&amp;
                  (image-&gt;alpha_trait == UndefinedPixelTrait))
                (void) SetImageAlpha(image,OpaqueAlpha,exception);
            }
          image=RotateImage(image,argument_list[0].real_reference,exception);
          break;
        }
        case 24:  /* Sample */
        {
          if (attribute_flag[0] != 0)
            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          image=SampleImage(image,geometry.width,geometry.height,exception);
          break;
        }
        case 25:  /* Scale */
        {
          if (attribute_flag[0] != 0)
            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          image=ScaleImage(image,geometry.width,geometry.height,exception);
          break;
        }
        case 26:  /* Shade */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=0.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          image=ShadeImage(image,
            argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse,
            geometry_info.rho,geometry_info.sigma,exception);
          break;
        }
        case 27:  /* Sharpen */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=SharpenImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 28:  /* Shear */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            QueryColorCompliance(argument_list[3].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          if (attribute_flag[4] != 0)
            QueryColorCompliance(argument_list[4].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          image=ShearImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          break;
        }
        case 29:  /* Spread */
        {
          PixelInterpolateMethod
            method;

          if (attribute_flag[0] == 0)
            argument_list[0].real_reference=1.0;
          method=UndefinedInterpolatePixel;
          if (attribute_flag[1] != 0)
            method=(PixelInterpolateMethod) argument_list[1].integer_reference;
          image=SpreadImage(image,method,argument_list[0].real_reference,
            exception);
          break;
        }
        case 30:  /* Swirl */
        {
          PixelInterpolateMethod
            method;

          if (attribute_flag[0] == 0)
            argument_list[0].real_reference=50.0;
          method=UndefinedInterpolatePixel;
          if (attribute_flag[1] != 0)
            method=(PixelInterpolateMethod) argument_list[1].integer_reference;
          image=SwirlImage(image,argument_list[0].real_reference,
            method,exception);
          break;
        }
        case 31:  /* Resize */
        case 32:  /* Zoom */
        {
          if (attribute_flag[0] != 0)
            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] == 0)
            argument_list[3].integer_reference=(ssize_t) UndefinedFilter;
          if (attribute_flag[4] != 0)
            SetImageArtifact(image,&quot;filter:support&quot;,
              argument_list[4].string_reference);
          image=ResizeImage(image,geometry.width,geometry.height,
            (FilterType) argument_list[3].integer_reference,
            exception);
          break;
        }
        case 33:  /* Annotate */
        {
          DrawInfo
            *draw_info;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info : (ImageInfo *) NULL,
            (DrawInfo *) NULL);
          if (attribute_flag[0] != 0)
            {
              char
                *text;

              text=InterpretImageProperties(info ? info-&gt;image_info :
                (ImageInfo *) NULL,image,argument_list[0].string_reference,
                exception);
              (void) CloneString(&amp;draw_info-&gt;text,text);
              text=DestroyString(text);
            }
          if (attribute_flag[1] != 0)
            (void) CloneString(&amp;draw_info-&gt;font,
              argument_list[1].string_reference);
          if (attribute_flag[2] != 0)
            draw_info-&gt;pointsize=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            (void) CloneString(&amp;draw_info-&gt;density,
              argument_list[3].string_reference);
          if (attribute_flag[4] != 0)
            (void) QueryColorCompliance(argument_list[4].string_reference,
              AllCompliance,&amp;draw_info-&gt;undercolor,exception);
          if (attribute_flag[5] != 0)
            {
              (void) QueryColorCompliance(argument_list[5].string_reference,
                AllCompliance,&amp;draw_info-&gt;stroke,exception);
              if (argument_list[5].image_reference != (Image *) NULL)
                draw_info-&gt;stroke_pattern=CloneImage(
                  argument_list[5].image_reference,0,0,MagickTrue,exception);
            }
          if (attribute_flag[6] != 0)
            {
              (void) QueryColorCompliance(argument_list[6].string_reference,
                AllCompliance,&amp;draw_info-&gt;fill,exception);
              if (argument_list[6].image_reference != (Image *) NULL)
                draw_info-&gt;fill_pattern=CloneImage(
                  argument_list[6].image_reference,0,0,MagickTrue,exception);
            }
          if (attribute_flag[7] != 0)
            {
              (void) CloneString(&amp;draw_info-&gt;geometry,
                argument_list[7].string_reference);
              flags=ParsePageGeometry(image,argument_list[7].string_reference,
                &amp;geometry,exception);
              if (((flags &amp; SigmaValue) == 0) &amp;&amp; ((flags &amp; XiValue) != 0))
                geometry_info.sigma=geometry_info.xi;
            }
          if (attribute_flag[8] != 0)
            (void) QueryColorCompliance(argument_list[8].string_reference,
              AllCompliance,&amp;draw_info-&gt;fill,exception);
          if (attribute_flag[11] != 0)
            draw_info-&gt;gravity=(GravityType)
              argument_list[11].integer_reference;
          if (attribute_flag[25] != 0)
            {
              AV
                *av;

              av=(AV *) argument_list[25].array_reference;
              if ((av_len(av) != 3) &amp;&amp; (av_len(av) != 5))
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;affine matrix must have 4 or 6 elements&quot;,PackageName);
                  goto PerlException;
                }
              draw_info-&gt;affine.sx=(double) SvNV(*(av_fetch(av,0,0)));
              draw_info-&gt;affine.rx=(double) SvNV(*(av_fetch(av,1,0)));
              draw_info-&gt;affine.ry=(double) SvNV(*(av_fetch(av,2,0)));
              draw_info-&gt;affine.sy=(double) SvNV(*(av_fetch(av,3,0)));
              if (fabs(draw_info-&gt;affine.sx*draw_info-&gt;affine.sy-
                  draw_info-&gt;affine.rx*draw_info-&gt;affine.ry) &lt; MagickEpsilon)
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;affine matrix is singular&quot;,PackageName);
                   goto PerlException;
                }
              if (av_len(av) == 5)
                {
                  draw_info-&gt;affine.tx=(double) SvNV(*(av_fetch(av,4,0)));
                  draw_info-&gt;affine.ty=(double) SvNV(*(av_fetch(av,5,0)));
                }
            }
          for (j=12; j &lt; 17; j++)
          {
            if (attribute_flag[j] == 0)
              continue;
            value=argument_list[j].string_reference;
            angle=argument_list[j].real_reference;
            current=draw_info-&gt;affine;
            GetAffineMatrix(&amp;affine);
            switch (j)
            {
              case 12:
              {
                /*
                  Translate.
                */
                flags=ParseGeometry(value,&amp;geometry_info);
                affine.tx=geometry_info.xi;
                affine.ty=geometry_info.psi;
                if ((flags &amp; PsiValue) == 0)
                  affine.ty=affine.tx;
                break;
              }
              case 13:
              {
                /*
                  Scale.
                */
                flags=ParseGeometry(value,&amp;geometry_info);
                affine.sx=geometry_info.rho;
                affine.sy=geometry_info.sigma;
                if ((flags &amp; SigmaValue) == 0)
                  affine.sy=affine.sx;
                break;
              }
              case 14:
              {
                /*
                  Rotate.
                */
                if (angle == 0.0)
                  break;
                affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));
                affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));
                affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));
                affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
              case 15:
              {
                /*
                  SkewX.
                */
                affine.ry=tan(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
              case 16:
              {
                /*
                  SkewY.
                */
                affine.rx=tan(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
            }
            draw_info-&gt;affine.sx=current.sx*affine.sx+current.ry*affine.rx;
            draw_info-&gt;affine.rx=current.rx*affine.sx+current.sy*affine.rx;
            draw_info-&gt;affine.ry=current.sx*affine.ry+current.ry*affine.sy;
            draw_info-&gt;affine.sy=current.rx*affine.ry+current.sy*affine.sy;
            draw_info-&gt;affine.tx=current.sx*affine.tx+current.ry*affine.ty+
              current.tx;
            draw_info-&gt;affine.ty=current.rx*affine.tx+current.sy*affine.ty+
              current.ty;
          }
          if (attribute_flag[9] == 0)
            argument_list[9].real_reference=0.0;
          if (attribute_flag[10] == 0)
            argument_list[10].real_reference=0.0;
          if ((attribute_flag[9] != 0) || (attribute_flag[10] != 0))
            {
              char
                geometry[MagickPathExtent];

              (void) FormatLocaleString(geometry,MagickPathExtent,&quot;%+f%+f&quot;,
                (double) argument_list[9].real_reference+draw_info-&gt;affine.tx,
                (double) argument_list[10].real_reference+draw_info-&gt;affine.ty);
              (void) CloneString(&amp;draw_info-&gt;geometry,geometry);
            }
          if (attribute_flag[17] != 0)
            draw_info-&gt;stroke_width=(size_t) argument_list[17].real_reference;
          if (attribute_flag[18] != 0)
            {
              draw_info-&gt;text_antialias=argument_list[18].integer_reference != 0 ?
                MagickTrue : MagickFalse;
              draw_info-&gt;stroke_antialias=draw_info-&gt;text_antialias;
            }
          if (attribute_flag[19] != 0)
            (void) CloneString(&amp;draw_info-&gt;family,
              argument_list[19].string_reference);
          if (attribute_flag[20] != 0)
            draw_info-&gt;style=(StyleType) argument_list[20].integer_reference;
          if (attribute_flag[21] != 0)
            draw_info-&gt;stretch=(StretchType) argument_list[21].integer_reference;
          if (attribute_flag[22] != 0)
            draw_info-&gt;weight=(size_t) argument_list[22].integer_reference;
          if (attribute_flag[23] != 0)
            draw_info-&gt;align=(AlignType) argument_list[23].integer_reference;
          if (attribute_flag[24] != 0)
            (void) CloneString(&amp;draw_info-&gt;encoding,
              argument_list[24].string_reference);
          if (attribute_flag[25] != 0)
            draw_info-&gt;fill_pattern=CloneImage(
              argument_list[25].image_reference,0,0,MagickTrue,exception);
          if (attribute_flag[26] != 0)
            draw_info-&gt;fill_pattern=CloneImage(
              argument_list[26].image_reference,0,0,MagickTrue,exception);
          if (attribute_flag[27] != 0)
            draw_info-&gt;stroke_pattern=CloneImage(
              argument_list[27].image_reference,0,0,MagickTrue,exception);
          if (attribute_flag[29] != 0)
            draw_info-&gt;kerning=argument_list[29].real_reference;
          if (attribute_flag[30] != 0)
            draw_info-&gt;interline_spacing=argument_list[30].real_reference;
          if (attribute_flag[31] != 0)
            draw_info-&gt;interword_spacing=argument_list[31].real_reference;
          if (attribute_flag[32] != 0)
            draw_info-&gt;direction=(DirectionType)
              argument_list[32].integer_reference;
          if (attribute_flag[33] != 0)
            draw_info-&gt;decorate=(DecorationType)
              argument_list[33].integer_reference;
          if (attribute_flag[34] != 0)
            draw_info-&gt;word_break=(WordBreakType)
              argument_list[34].integer_reference;
          (void) AnnotateImage(image,draw_info,exception);
          draw_info=DestroyDrawInfo(draw_info);
          break;
        }
        case 34:  /* ColorFloodfill */
        {
          DrawInfo
            *draw_info;

          MagickBooleanType
            invert;

          PixelInfo
            target;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info :
            (ImageInfo *) NULL,(DrawInfo *) NULL);
          if (attribute_flag[0] != 0)
            flags=ParsePageGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.x=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.y=argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            (void) QueryColorCompliance(argument_list[3].string_reference,
              AllCompliance,&amp;draw_info-&gt;fill,exception);
          (void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,
            geometry.x,geometry.y,&amp;target,exception);
          invert=MagickFalse;
          if (attribute_flag[4] != 0)
            {
              QueryColorCompliance(argument_list[4].string_reference,
                AllCompliance,&amp;target,exception);
              invert=MagickTrue;
            }
          if (attribute_flag[5] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[5].string_reference,(double) QuantumRange+1.0);
          if (attribute_flag[6] != 0)
            invert=(MagickBooleanType) argument_list[6].integer_reference;
          (void) FloodfillPaintImage(image,draw_info,&amp;target,geometry.x,
            geometry.y,invert,exception);
          draw_info=DestroyDrawInfo(draw_info);
          break;
        }
        case 35:  /* Composite */
        {
          char
            composite_geometry[MagickPathExtent];

          Image
            *composite_image,
            *rotate_image;

          MagickBooleanType
            clip_to_self;

          compose=OverCompositeOp;
          if (attribute_flag[0] != 0)
            composite_image=argument_list[0].image_reference;
          else
            {
              ThrowPerlException(exception,OptionError,
                &quot;CompositeImageRequired&quot;,PackageName);
              goto PerlException;
            }
          /*
            Parameter Handling used for BOTH normal and tiled composition.
          */
          if (attribute_flag[1] != 0) /* compose */
            compose=(CompositeOperator) argument_list[1].integer_reference;
          if (attribute_flag[6] != 0) /* opacity  */
            {
              if (compose != DissolveCompositeOp)
                (void) SetImageAlpha(composite_image,(Quantum)
                  StringToDoubleInterval(argument_list[6].string_reference,
                  (double) QuantumRange+1.0),exception);
              else
                {
                  CacheView
                    *composite_view;

                  double
                    opacity;

                  MagickBooleanType
                    sync;

                  Quantum
                    *q;

                  ssize_t
                    x,
                    y;

                  /*
                    Handle dissolve composite operator (patch by
                    Kevin A. McGrail).
                  */
                  (void) CloneString(&amp;image-&gt;geometry,
                    argument_list[6].string_reference);
                  opacity=(Quantum) StringToDoubleInterval(
                    argument_list[6].string_reference,(double) QuantumRange+
                    1.0);
                  if (composite_image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) SetImageAlpha(composite_image,OpaqueAlpha,exception);
                  composite_view=AcquireAuthenticCacheView(composite_image,exception);
                  for (y=0; y &lt; (ssize_t) composite_image-&gt;rows ; y++)
                  {
                    q=GetCacheViewAuthenticPixels(composite_view,0,y,
                      composite_image-&gt;columns,1,exception);
                    for (x=0; x &lt; (ssize_t) composite_image-&gt;columns; x++)
                    {
                      if (GetPixelAlpha(image,q) == OpaqueAlpha)
                        SetPixelAlpha(composite_image,ClampToQuantum(opacity),
                          q);
                      q+=GetPixelChannels(composite_image);
                    }
                    sync=SyncCacheViewAuthenticPixels(composite_view,exception);
                    if (sync == MagickFalse)
                      break;
                  }
                  composite_view=DestroyCacheView(composite_view);
                }
            }
          if (attribute_flag[9] != 0)    /* &quot;color=&gt;&quot; */
            QueryColorCompliance(argument_list[9].string_reference,
              AllCompliance,&amp;composite_image-&gt;background_color,exception);
          if (attribute_flag[12] != 0) /* &quot;interpolate=&gt;&quot; */
            image-&gt;interpolate=(PixelInterpolateMethod)
              argument_list[12].integer_reference;
          if (attribute_flag[13] != 0)   /* &quot;args=&gt;&quot; */
            (void) SetImageArtifact(image,&quot;compose:args&quot;,
              argument_list[13].string_reference);
          if (attribute_flag[14] != 0)   /* &quot;blend=&gt;&quot;  depreciated */
            (void) SetImageArtifact(image,&quot;compose:args&quot;,
              argument_list[14].string_reference);
          clip_to_self=MagickTrue;
          if (attribute_flag[15] != 0)
            clip_to_self=(MagickBooleanType)
              argument_list[15].integer_reference;
          /*
            Tiling Composition (with orthogonal rotate).
          */
          rotate_image=(Image *) NULL;
          if (attribute_flag[8] != 0)   /* &quot;rotate=&gt;&quot; */
            {
               /*
                 Rotate image.
               */
               rotate_image=RotateImage(composite_image,
                 argument_list[8].real_reference,exception);
               if (rotate_image == (Image *) NULL)
                 break;
            }
          if ((attribute_flag[7] != 0) &amp;&amp;
              (argument_list[7].integer_reference != 0)) /* tile */
            {
              ssize_t
                x,
                y;

              /*
                Tile the composite image.
              */
             for (y=0; y &lt; (ssize_t) image-&gt;rows; y+=(ssize_t) composite_image-&gt;rows)
                for (x=0; x &lt; (ssize_t) image-&gt;columns; x+=(ssize_t) composite_image-&gt;columns)
                {
                  if (attribute_flag[8] != 0) /* rotate */
                    (void) CompositeImage(image,rotate_image,compose,
                      MagickTrue,x,y,exception);
                  else
                    (void) CompositeImage(image,composite_image,compose,
                      MagickTrue,x,y,exception);
                }
              if (attribute_flag[8] != 0) /* rotate */
                rotate_image=DestroyImage(rotate_image);
              break;
            }
          /*
            Parameter Handling used ONLY for normal composition.
          */
          if (attribute_flag[5] != 0) /* gravity */
            image-&gt;gravity=(GravityType) argument_list[5].integer_reference;
          if (attribute_flag[2] != 0) /* geometry offset */
            {
              SetGeometry(image,&amp;geometry);
              (void) ParseAbsoluteGeometry(argument_list[2].string_reference,
                &amp;geometry);
              GravityAdjustGeometry(image-&gt;columns,image-&gt;rows,image-&gt;gravity,
                &amp;geometry);
            }
          if (attribute_flag[3] != 0) /* x offset */
            geometry.x=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0) /* y offset */
            geometry.y=argument_list[4].integer_reference;
          if (attribute_flag[10] != 0) /* mask */
            {
              if ((image-&gt;compose == DisplaceCompositeOp) ||
                  (image-&gt;compose == DistortCompositeOp))
                {
                  /*
                    Merge Y displacement into X displacement image.
                  */
                  composite_image=CloneImage(composite_image,0,0,MagickTrue,
                    exception);
                  (void) CompositeImage(composite_image,
                    argument_list[10].image_reference,CopyGreenCompositeOp,
                    clip_to_self,0,0,exception);
                  (void) SetImageColorspace(composite_image,sRGBColorspace,
                    exception);

                }
              else
                {
                  Image
                    *mask_image;

                  /*
                    Set a blending mask for the composition.
                  */
                  mask_image=CloneImage(argument_list[10].image_reference,0,0,
                    MagickTrue,exception);
                  (void) CompositeImage(composite_image,mask_image,
                    CopyAlphaCompositeOp,clip_to_self,0,0,exception);
                  mask_image=DestroyImage(mask_image);
                }
            }
          if (attribute_flag[11] != 0) /* channel */
            channel=(ChannelType) argument_list[11].integer_reference;
          /*
            Composite two images (normal composition).
          */
          (void) FormatLocaleString(composite_geometry,MagickPathExtent,
            &quot;%.17gx%.17g%+.20g%+.20g&quot;,(double) composite_image-&gt;columns,
            (double) composite_image-&gt;rows,(double) geometry.x,(double)
            geometry.y);
          flags=ParseGravityGeometry(image,composite_geometry,&amp;geometry,
            exception);
          channel_mask=SetImageChannelMask(image,channel);
          if (attribute_flag[8] == 0) /* no rotate */
            CompositeImage(image,composite_image,compose,clip_to_self,
              geometry.x,geometry.y,exception);
          else
            {
              /*
                Position adjust rotated image then composite.
              */
              geometry.x-=(ssize_t) (rotate_image-&gt;columns-
                composite_image-&gt;columns)/2;
              geometry.y-=(ssize_t) (rotate_image-&gt;rows-
                composite_image-&gt;rows)/2;
              CompositeImage(image,rotate_image,compose,clip_to_self,geometry.x,
                geometry.y,exception);
              rotate_image=DestroyImage(rotate_image);
            }
          if (attribute_flag[10] != 0) /* mask */
            {
              if ((image-&gt;compose == DisplaceCompositeOp) ||
                  (image-&gt;compose == DistortCompositeOp))
                composite_image=DestroyImage(composite_image);
              else
                (void) SetImageMask(image,ReadPixelMask,(Image *) NULL,
                  exception);
            }
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 36:  /* Contrast */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].integer_reference=0;
          (void) ContrastImage(image,argument_list[0].integer_reference != 0 ?
            MagickTrue : MagickFalse,exception);
          break;
        }
        case 37:  /* CycleColormap */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].integer_reference=6;
          (void) CycleColormapImage(image,argument_list[0].integer_reference,
            exception);
          break;
        }
        case 38:  /* Draw */
        {
          DrawInfo
            *draw_info;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info : (ImageInfo *) NULL,
            (DrawInfo *) NULL);
          (void) CloneString(&amp;draw_info-&gt;primitive,&quot;point&quot;);
          if (attribute_flag[0] != 0)
            {
              if (argument_list[0].integer_reference &lt; 0)
                (void) CloneString(&amp;draw_info-&gt;primitive,
                  argument_list[0].string_reference);
              else
                (void) CloneString(&amp;draw_info-&gt;primitive,CommandOptionToMnemonic(
                  MagickPrimitiveOptions,argument_list[0].integer_reference));
            }
          if (attribute_flag[1] != 0)
            {
              if (LocaleCompare(draw_info-&gt;primitive,&quot;path&quot;) == 0)
                {
                  (void) ConcatenateString(&amp;draw_info-&gt;primitive,&quot; &#039;&quot;);
                  ConcatenateString(&amp;draw_info-&gt;primitive,
                    argument_list[1].string_reference);
                  (void) ConcatenateString(&amp;draw_info-&gt;primitive,&quot;&#039;&quot;);
                }
              else
                {
                  (void) ConcatenateString(&amp;draw_info-&gt;primitive,&quot; &quot;);
                  ConcatenateString(&amp;draw_info-&gt;primitive,
                    argument_list[1].string_reference);
                }
            }
          if (attribute_flag[2] != 0)
            {
              (void) ConcatenateString(&amp;draw_info-&gt;primitive,&quot; &quot;);
              (void) ConcatenateString(&amp;draw_info-&gt;primitive,
                CommandOptionToMnemonic(MagickMethodOptions,
                argument_list[2].integer_reference));
            }
          if (attribute_flag[3] != 0)
            {
              (void) QueryColorCompliance(argument_list[3].string_reference,
                AllCompliance,&amp;draw_info-&gt;stroke,exception);
              if (argument_list[3].image_reference != (Image *) NULL)
                draw_info-&gt;stroke_pattern=CloneImage(
                  argument_list[3].image_reference,0,0,MagickTrue,exception);
            }
          if (attribute_flag[4] != 0)
            {
              (void) QueryColorCompliance(argument_list[4].string_reference,
                AllCompliance,&amp;draw_info-&gt;fill,exception);
              if (argument_list[4].image_reference != (Image *) NULL)
                draw_info-&gt;fill_pattern=CloneImage(
                  argument_list[4].image_reference,0,0,MagickTrue,exception);
            }
          if (attribute_flag[5] != 0)
            draw_info-&gt;stroke_width=(size_t) argument_list[5].real_reference;
          if (attribute_flag[6] != 0)
            (void) CloneString(&amp;draw_info-&gt;font,
              argument_list[6].string_reference);
          if (attribute_flag[7] != 0)
            (void) QueryColorCompliance(argument_list[7].string_reference,
              AllCompliance,&amp;draw_info-&gt;border_color,exception);
          if (attribute_flag[8] != 0)
            draw_info-&gt;affine.tx=argument_list[8].real_reference;
          if (attribute_flag[9] != 0)
            draw_info-&gt;affine.ty=argument_list[9].real_reference;
          if (attribute_flag[20] != 0)
            {
              AV
                *av;

              av=(AV *) argument_list[20].array_reference;
              if ((av_len(av) != 3) &amp;&amp; (av_len(av) != 5))
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;affine matrix must have 4 or 6 elements&quot;,PackageName);
                  goto PerlException;
                }
              draw_info-&gt;affine.sx=(double) SvNV(*(av_fetch(av,0,0)));
              draw_info-&gt;affine.rx=(double) SvNV(*(av_fetch(av,1,0)));
              draw_info-&gt;affine.ry=(double) SvNV(*(av_fetch(av,2,0)));
              draw_info-&gt;affine.sy=(double) SvNV(*(av_fetch(av,3,0)));
              if (fabs(draw_info-&gt;affine.sx*draw_info-&gt;affine.sy-
                  draw_info-&gt;affine.rx*draw_info-&gt;affine.ry) &lt; MagickEpsilon)
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;affine matrix is singular&quot;,PackageName);
                   goto PerlException;
                }
              if (av_len(av) == 5)
                {
                  draw_info-&gt;affine.tx=(double) SvNV(*(av_fetch(av,4,0)));
                  draw_info-&gt;affine.ty=(double) SvNV(*(av_fetch(av,5,0)));
                }
            }
          for (j=10; j &lt; 15; j++)
          {
            if (attribute_flag[j] == 0)
              continue;
            value=argument_list[j].string_reference;
            angle=argument_list[j].real_reference;
            current=draw_info-&gt;affine;
            GetAffineMatrix(&amp;affine);
            switch (j)
            {
              case 10:
              {
                /*
                  Translate.
                */
                flags=ParseGeometry(value,&amp;geometry_info);
                affine.tx=geometry_info.xi;
                affine.ty=geometry_info.psi;
                if ((flags &amp; PsiValue) == 0)
                  affine.ty=affine.tx;
                break;
              }
              case 11:
              {
                /*
                  Scale.
                */
                flags=ParseGeometry(value,&amp;geometry_info);
                affine.sx=geometry_info.rho;
                affine.sy=geometry_info.sigma;
                if ((flags &amp; SigmaValue) == 0)
                  affine.sy=affine.sx;
                break;
              }
              case 12:
              {
                /*
                  Rotate.
                */
                if (angle == 0.0)
                  break;
                affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));
                affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));
                affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));
                affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
              case 13:
              {
                /*
                  SkewX.
                */
                affine.ry=tan(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
              case 14:
              {
                /*
                  SkewY.
                */
                affine.rx=tan(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
            }
            draw_info-&gt;affine.sx=current.sx*affine.sx+current.ry*affine.rx;
            draw_info-&gt;affine.rx=current.rx*affine.sx+current.sy*affine.rx;
            draw_info-&gt;affine.ry=current.sx*affine.ry+current.ry*affine.sy;
            draw_info-&gt;affine.sy=current.rx*affine.ry+current.sy*affine.sy;
            draw_info-&gt;affine.tx=
              current.sx*affine.tx+current.ry*affine.ty+current.tx;
            draw_info-&gt;affine.ty=
              current.rx*affine.tx+current.sy*affine.ty+current.ty;
          }
          if (attribute_flag[15] != 0)
            draw_info-&gt;fill_pattern=CloneImage(
              argument_list[15].image_reference,0,0,MagickTrue,exception);
          if (attribute_flag[16] != 0)
            draw_info-&gt;pointsize=argument_list[16].real_reference;
          if (attribute_flag[17] != 0)
            {
              draw_info-&gt;stroke_antialias=argument_list[17].integer_reference != 0 ? MagickTrue : MagickFalse;
              draw_info-&gt;text_antialias=draw_info-&gt;stroke_antialias;
            }
          if (attribute_flag[18] != 0)
            (void) CloneString(&amp;draw_info-&gt;density,
              argument_list[18].string_reference);
          if (attribute_flag[19] != 0)
            draw_info-&gt;stroke_width=(size_t) argument_list[19].real_reference;
          if (attribute_flag[21] != 0)
            draw_info-&gt;dash_offset=argument_list[21].real_reference;
          if (attribute_flag[22] != 0)
            {
              AV
                *av;

              av=(AV *) argument_list[22].array_reference;
              draw_info-&gt;dash_pattern=(double *) AcquireQuantumMemory(
                (size_t) av_len(av)+2UL,sizeof(*draw_info-&gt;dash_pattern));
              if (draw_info-&gt;dash_pattern != (double *) NULL)
                {
                  for (i=0; i &lt;= av_len(av); i++)
                    draw_info-&gt;dash_pattern[i]=(double)
                      SvNV(*(av_fetch(av,i,0)));
                  draw_info-&gt;dash_pattern[i]=0.0;
                }
            }
          if (attribute_flag[23] != 0)
            image-&gt;interpolate=(PixelInterpolateMethod)
              argument_list[23].integer_reference;
          if ((attribute_flag[24] != 0) &amp;&amp;
              (draw_info-&gt;fill_pattern != (Image *) NULL))
            flags=ParsePageGeometry(draw_info-&gt;fill_pattern,
              argument_list[24].string_reference,
              &amp;draw_info-&gt;fill_pattern-&gt;tile_offset,exception);
          if (attribute_flag[25] != 0)
            {
              (void) ConcatenateString(&amp;draw_info-&gt;primitive,&quot; &#039;&quot;);
              (void) ConcatenateString(&amp;draw_info-&gt;primitive,
                argument_list[25].string_reference);
              (void) ConcatenateString(&amp;draw_info-&gt;primitive,&quot;&#039;&quot;);
            }
          if (attribute_flag[26] != 0)
            draw_info-&gt;fill_pattern=CloneImage(
              argument_list[26].image_reference,0,0,MagickTrue,exception);
          if (attribute_flag[27] != 0)
            draw_info-&gt;stroke_pattern=CloneImage(
              argument_list[27].image_reference,0,0,MagickTrue,exception);
          if (attribute_flag[28] != 0)
            (void) CloneString(&amp;draw_info-&gt;primitive,
              argument_list[28].string_reference);
          if (attribute_flag[29] != 0)
            draw_info-&gt;kerning=argument_list[29].real_reference;
          if (attribute_flag[30] != 0)
            draw_info-&gt;interline_spacing=argument_list[30].real_reference;
          if (attribute_flag[31] != 0)
            draw_info-&gt;interword_spacing=argument_list[31].real_reference;
          if (attribute_flag[32] != 0)
            draw_info-&gt;direction=(DirectionType)
              argument_list[32].integer_reference;
          if (attribute_flag[33] != 0)
            draw_info-&gt;word_break=(WordBreakType)
              argument_list[33].integer_reference;
          (void) DrawImage(image,draw_info,exception);
          draw_info=DestroyDrawInfo(draw_info);
          break;
        }
        case 39:  /* Equalize */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) EqualizeImage(image,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 40:  /* Gamma */
        {
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          if (attribute_flag[2] == 0)
            argument_list[2].real_reference=1.0;
          if (attribute_flag[3] == 0)
            argument_list[3].real_reference=1.0;
          if (attribute_flag[4] == 0)
            argument_list[4].real_reference=1.0;
          if (attribute_flag[0] == 0)
            {
              (void) FormatLocaleString(message,MagickPathExtent,
                &quot;%.17g,%.17g,%.17g&quot;,(double) argument_list[2].real_reference,
                (double) argument_list[3].real_reference,
                (double) argument_list[4].real_reference);
              argument_list[0].string_reference=message;
            }
          (void) GammaImage(image,StringToDouble(
            argument_list[0].string_reference,(char **) NULL),exception);
          break;
        }
        case 41:  /* Map */
        {
          QuantizeInfo
            *quantize_info;

          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;MapImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          quantize_info=AcquireQuantizeInfo(info-&gt;image_info);
          if (attribute_flag[1] != 0)
            quantize_info-&gt;dither_method=(DitherMethod)
              argument_list[1].integer_reference;
          (void) RemapImages(quantize_info,image,
            argument_list[0].image_reference,exception);
          quantize_info=DestroyQuantizeInfo(quantize_info);
          break;
        }
        case 42:  /* MatteFloodfill */
        {
          DrawInfo
            *draw_info;

          MagickBooleanType
            invert;

          PixelInfo
            target;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info : (ImageInfo *) NULL,
            (DrawInfo *) NULL);
          if (attribute_flag[0] != 0)
            flags=ParsePageGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.x=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.y=argument_list[2].integer_reference;
          if (image-&gt;alpha_trait == UndefinedPixelTrait)
            (void) SetImageAlpha(image,OpaqueAlpha,exception);
          (void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,
            geometry.x,geometry.y,&amp;target,exception);
          if (attribute_flag[4] != 0)
            QueryColorCompliance(argument_list[4].string_reference,
              AllCompliance,&amp;target,exception);
          if (attribute_flag[3] != 0)
            target.alpha=StringToDoubleInterval(
              argument_list[3].string_reference,(double) (double) QuantumRange+
              1.0);
          if (attribute_flag[5] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[5].string_reference,(double) QuantumRange+1.0);
          invert=MagickFalse;
          if (attribute_flag[6] != 0)
            invert=(MagickBooleanType) argument_list[6].integer_reference;
          channel_mask=SetImageChannelMask(image,AlphaChannel);
          (void) FloodfillPaintImage(image,draw_info,&amp;target,geometry.x,
            geometry.y,invert,exception);
          (void) SetImageChannelMask(image,channel_mask);
          draw_info=DestroyDrawInfo(draw_info);
          break;
        }
        case 43:  /* Modulate */
        {
          char
            modulate[MagickPathExtent];

          geometry_info.rho=100.0;
          geometry_info.sigma=100.0;
          geometry_info.xi=100.0;
          if (attribute_flag[0] != 0)
            (void)ParseGeometry(argument_list[0].string_reference,
              &amp;geometry_info);
          if (attribute_flag[1] != 0)
            geometry_info.xi=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            {
              geometry_info.sigma=argument_list[3].real_reference;
              SetImageArtifact(image,&quot;modulate:colorspace&quot;,&quot;HWB&quot;);
            }
          if (attribute_flag[4] != 0)
            {
              geometry_info.rho=argument_list[4].real_reference;
              SetImageArtifact(image,&quot;modulate:colorspace&quot;,&quot;HSB&quot;);
            }
          if (attribute_flag[5] != 0)
            {
              geometry_info.sigma=argument_list[5].real_reference;
              SetImageArtifact(image,&quot;modulate:colorspace&quot;,&quot;HSL&quot;);
            }
          if (attribute_flag[6] != 0)
            {
              geometry_info.rho=argument_list[6].real_reference;
              SetImageArtifact(image,&quot;modulate:colorspace&quot;,&quot;HWB&quot;);
            }
          (void) FormatLocaleString(modulate,MagickPathExtent,&quot;%.17g,%.17g,%.17g&quot;,
            geometry_info.rho,geometry_info.sigma,geometry_info.xi);
          (void) ModulateImage(image,modulate,exception);
          break;
        }
        case 44:  /* Negate */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].integer_reference=0;
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) NegateImage(image,argument_list[0].integer_reference != 0 ?
            MagickTrue : MagickFalse,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 45:  /* Normalize */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          NormalizeImage(image,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 46:  /* NumberColors */
          break;
        case 47:  /* Opaque */
        {
          MagickBooleanType
            invert;

          PixelInfo
            fill_color,
            target;

          (void) QueryColorCompliance(&quot;none&quot;,AllCompliance,&amp;target,
             exception);
          (void) QueryColorCompliance(&quot;none&quot;,AllCompliance,&amp;fill_color,
            exception);
          if (attribute_flag[0] != 0)
            (void) QueryColorCompliance(argument_list[0].string_reference,
              AllCompliance,&amp;target,exception);
          if (attribute_flag[1] != 0)
            (void) QueryColorCompliance(argument_list[1].string_reference,
              AllCompliance,&amp;fill_color,exception);
          if (attribute_flag[2] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[2].string_reference,(double) QuantumRange+1.0);
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          invert=MagickFalse;
          if (attribute_flag[4] != 0)
            invert=(MagickBooleanType) argument_list[4].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) OpaquePaintImage(image,&amp;target,&amp;fill_color,invert,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 48:  /* Quantize */
        {
          QuantizeInfo
            *quantize_info;

          quantize_info=AcquireQuantizeInfo(info-&gt;image_info);
          if (attribute_flag[0] != 0)
            quantize_info-&gt;number_colors=(size_t)
              argument_list[0].integer_reference;
          if (attribute_flag[1] != 0)
            quantize_info-&gt;tree_depth=(size_t)
              argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            quantize_info-&gt;colorspace=(ColorspaceType)
              argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            quantize_info-&gt;dither_method=(DitherMethod)
              argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            quantize_info-&gt;measure_error=
              argument_list[4].integer_reference != 0 ? MagickTrue : MagickFalse;
          if (attribute_flag[6] != 0)
            (void) QueryColorCompliance(argument_list[6].string_reference,
              AllCompliance,&amp;image-&gt;transparent_color,exception);
          if (attribute_flag[7] != 0)
            quantize_info-&gt;dither_method=(DitherMethod)
              argument_list[7].integer_reference;
          if (attribute_flag[5] &amp;&amp; argument_list[5].integer_reference)
            (void) QuantizeImages(quantize_info,image,exception);
          else
            if ((image-&gt;storage_class == DirectClass) ||
               (image-&gt;colors &gt; quantize_info-&gt;number_colors) ||
               (quantize_info-&gt;colorspace == GRAYColorspace))
             (void) QuantizeImage(quantize_info,image,exception);
           else
             CompressImageColormap(image,exception);
          quantize_info=DestroyQuantizeInfo(quantize_info);
          break;
        }
        case 49:  /* Raise */
        {
          if (attribute_flag[0] != 0)
            flags=ParsePageGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] == 0)
            argument_list[3].integer_reference=1;
          (void) RaiseImage(image,&amp;geometry,
            argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse,
            exception);
          break;
        }
        case 50:  /* Segment */
        {
          ColorspaceType
            colorspace;

          double
            cluster_threshold,
            smoothing_threshold;

          MagickBooleanType
            verbose;

          cluster_threshold=1.0;
          smoothing_threshold=1.5;
          colorspace=sRGBColorspace;
          verbose=MagickFalse;
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              cluster_threshold=geometry_info.rho;
              if (flags &amp; SigmaValue)
                smoothing_threshold=geometry_info.sigma;
            }
          if (attribute_flag[1] != 0)
            cluster_threshold=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            smoothing_threshold=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            colorspace=(ColorspaceType) argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            verbose=argument_list[4].integer_reference != 0 ?
              MagickTrue : MagickFalse;
          (void) SegmentImage(image,colorspace,verbose,cluster_threshold,
            smoothing_threshold,exception);
          break;
        }
        case 51:  /* Signature */
        {
          (void) SignatureImage(image,exception);
          break;
        }
        case 52:  /* Solarize */
        {
          geometry_info.rho=QuantumRange/2.0;
          if (attribute_flag[0] != 0)
            flags=ParseGeometry(argument_list[0].string_reference,
              &amp;geometry_info);
          if (attribute_flag[1] != 0)
            geometry_info.rho=StringToDoubleInterval(
              argument_list[1].string_reference,(double) QuantumRange+1.0);
          (void) SolarizeImage(image,geometry_info.rho,exception);
          break;
        }
        case 53:  /* Sync */
        {
          (void) SyncImage(image,exception);
          break;
        }
        case 54:  /* Texture */
        {
          if (attribute_flag[0] == 0)
            break;
          TextureImage(image,argument_list[0].image_reference,exception);
          break;
        }
        case 55:  /* Evaluate */
        {
          MagickEvaluateOperator
            op;

          op=SetEvaluateOperator;
          if (attribute_flag[0] == MagickFalse)
            argument_list[0].real_reference=0.0;
          if (attribute_flag[1] != MagickFalse)
            op=(MagickEvaluateOperator) argument_list[1].integer_reference;
          if (attribute_flag[2] != MagickFalse)
            channel=(ChannelType) argument_list[2].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) EvaluateImage(image,op,argument_list[0].real_reference,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 56:  /* Transparent */
        {
          double
            opacity;

          MagickBooleanType
            invert;

          PixelInfo
            target;

          (void) QueryColorCompliance(&quot;none&quot;,AllCompliance,&amp;target,
            exception);
          if (attribute_flag[0] != 0)
            (void) QueryColorCompliance(argument_list[0].string_reference,
              AllCompliance,&amp;target,exception);
          opacity=TransparentAlpha;
          if (attribute_flag[1] != 0)
            opacity=StringToDoubleInterval(argument_list[1].string_reference,
              (double) QuantumRange+1.0);
          if (attribute_flag[2] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[2].string_reference,(double) QuantumRange+1.0);
          if (attribute_flag[3] == 0)
            argument_list[3].integer_reference=0;
          invert=MagickFalse;
          if (attribute_flag[3] != 0)
            invert=(MagickBooleanType) argument_list[3].integer_reference;
          (void) TransparentPaintImage(image,&amp;target,ClampToQuantum(opacity),
            invert,exception);
          break;
        }
        case 57:  /* Threshold */
        {
          double
            threshold;

          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=&quot;50%&quot;;
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          threshold=StringToDoubleInterval(argument_list[0].string_reference,
            (double) QuantumRange+1.0);
          channel_mask=SetImageChannelMask(image,channel);
          (void) BilevelImage(image,threshold,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 58:  /* Charcoal */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          image=CharcoalImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          break;
        }
        case 59:  /* Trim */
        {
          if (attribute_flag[0] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[0].string_reference,(double) QuantumRange+1.0);
          image=TrimImage(image,exception);
          break;
        }
        case 60:  /* Wave */
        {
          PixelInterpolateMethod
            method;

          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          method=UndefinedInterpolatePixel;
          if (attribute_flag[3] != 0)
            method=(PixelInterpolateMethod) argument_list[3].integer_reference;
          image=WaveImage(image,geometry_info.rho,geometry_info.sigma,
            method,exception);
          break;
        }
        case 61:  /* Separate */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          image=SeparateImage(image,channel,exception);
          break;
        }
        case 63:  /* Stereo */
        {
          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;StereoImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          if (attribute_flag[1] != 0)
            geometry.x=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.y=argument_list[2].integer_reference;
          image=StereoAnaglyphImage(image,argument_list[0].image_reference,
            geometry.x,geometry.y,exception);
          break;
        }
        case 64:  /* Stegano */
        {
          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;SteganoImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          if (attribute_flag[1] == 0)
            argument_list[1].integer_reference=0;
          image-&gt;offset=argument_list[1].integer_reference;
          image=SteganoImage(image,argument_list[0].image_reference,exception);
          break;
        }
        case 65:  /* Deconstruct */
        {
          image=CompareImagesLayers(image,CompareAnyLayer,exception);
          break;
        }
        case 66:  /* GaussianBlur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=GaussianBlurImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 67:  /* Convolve */
        {
          KernelInfo
            *kernel;

          kernel=(KernelInfo *) NULL;
          if ((attribute_flag[0] == 0) &amp;&amp; (attribute_flag[3] == 0))
            break;
          if (attribute_flag[0] != 0)
            {
              AV
                *av;

              size_t
                order;

              kernel=AcquireKernelInfo((const char *) NULL,exception);
              if (kernel == (KernelInfo *) NULL)
                break;
              av=(AV *) argument_list[0].array_reference;
              order=(size_t) sqrt(av_len(av)+1);
              kernel-&gt;width=order;
              kernel-&gt;height=order;
              kernel-&gt;values=(MagickRealType *) AcquireAlignedMemory(order,
                order*sizeof(*kernel-&gt;values));
              if (kernel-&gt;values == (MagickRealType *) NULL)
                {
                  kernel=DestroyKernelInfo(kernel);
                  ThrowPerlException(exception,ResourceLimitFatalError,
                    &quot;MemoryAllocationFailed&quot;,PackageName);
                  goto PerlException;
                }
              for (j=0; (j &lt; (ssize_t) (order*order)) &amp;&amp; (j &lt; (av_len(av)+1)); j++)
                kernel-&gt;values[j]=(MagickRealType) SvNV(*(av_fetch(av,j,0)));
              for ( ; j &lt; (ssize_t) (order*order); j++)
                kernel-&gt;values[j]=0.0;
            }
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            SetImageArtifact(image,&quot;convolve:bias&quot;,
              argument_list[2].string_reference);
          if (attribute_flag[3] != 0)
            {
              kernel=AcquireKernelInfo(argument_list[3].string_reference,
                exception);
              if (kernel == (KernelInfo *) NULL)
                break;
            }
          channel_mask=SetImageChannelMask(image,channel);
          image=ConvolveImage(image,kernel,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          kernel=DestroyKernelInfo(kernel);
          break;
        }
        case 68:  /* Profile */
        {
          const char
            *name;

          Image
            *profile_image;

          ImageInfo
            *profile_info;

          StringInfo
            *profile;

          name=&quot;*&quot;;
          if (attribute_flag[0] != 0)
            name=argument_list[0].string_reference;
          if (attribute_flag[2] != 0)
            image-&gt;rendering_intent=(RenderingIntent)
              argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            image-&gt;black_point_compensation=
              argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse;
          if (attribute_flag[1] != 0)
            {
              if (argument_list[1].length == 0)
                {
                  /*
                    Remove a profile from the image.
                  */
                  (void) ProfileImage(image,name,(const unsigned char *) NULL,0,
                    exception);
                  break;
                }
              /*
                Associate user supplied profile with the image.
              */
              profile=AcquireStringInfo(argument_list[1].length);
              SetStringInfoDatum(profile,(const unsigned char *)
                argument_list[1].string_reference);
              (void) ProfileImage(image,name,GetStringInfoDatum(profile),
                (size_t) GetStringInfoLength(profile),exception);
              profile=DestroyStringInfo(profile);
              break;
            }
          /*
            Associate a profile with the image.
          */
          profile_info=CloneImageInfo(info ? info-&gt;image_info :
            (ImageInfo *) NULL);
          profile_image=ReadImages(profile_info,name,exception);
          if (profile_image == (Image *) NULL)
            break;
          ResetImageProfileIterator(profile_image);
          name=GetNextImageProfile(profile_image);
          while (name != (const char *) NULL)
          {
            const StringInfo
              *profile;

            profile=GetImageProfile(profile_image,name);
            if (profile != (const StringInfo *) NULL)
              (void) ProfileImage(image,name,GetStringInfoDatum(profile),
                (size_t) GetStringInfoLength(profile),exception);
            name=GetNextImageProfile(profile_image);
          }
          profile_image=DestroyImage(profile_image);
          profile_info=DestroyImageInfo(profile_info);
          break;
        }
        case 69:  /* UnsharpMask */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=1.0;
              if ((flags &amp; PsiValue) == 0)
                geometry_info.psi=0.5;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].real_reference;
          if (attribute_flag[5] != 0)
            channel=(ChannelType) argument_list[5].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=UnsharpMaskImage(image,geometry_info.rho,geometry_info.sigma,
            geometry_info.xi,geometry_info.psi,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 70:  /* MotionBlur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            channel=(ChannelType) argument_list[4].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=MotionBlurImage(image,geometry_info.rho,geometry_info.sigma,
            geometry_info.xi,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 71:  /* OrderedDither */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=&quot;o8x8&quot;;
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) OrderedDitherImage(image,argument_list[0].string_reference,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 72:  /* Shave */
        {
          if (attribute_flag[0] != 0)
            flags=ParsePageGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          image=ShaveImage(image,&amp;geometry,exception);
          break;
        }
        case 73:  /* Level */
        {
          double
            black_point,
            gamma,
            white_point;

          black_point=0.0;
          white_point=(double) image-&gt;columns*image-&gt;rows;
          gamma=1.0;
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              black_point=geometry_info.rho;
              if ((flags &amp; SigmaValue) != 0)
                white_point=geometry_info.sigma;
              if ((flags &amp; XiValue) != 0)
                gamma=geometry_info.xi;
              if ((flags &amp; PercentValue) != 0)
                {
                  black_point*=(double) (QuantumRange/100.0);
                  white_point*=(double) (QuantumRange/100.0);
                }
              if ((flags &amp; SigmaValue) == 0)
                white_point=(double) QuantumRange-black_point;
            }
          if (attribute_flag[1] != 0)
            black_point=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            white_point=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            gamma=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            channel=(ChannelType) argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            {
              argument_list[0].real_reference=argument_list[5].real_reference;
              attribute_flag[0]=attribute_flag[5];
            }
          channel_mask=SetImageChannelMask(image,channel);
          (void) LevelImage(image,black_point,white_point,gamma,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 74:  /* Clip */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=&quot;#1&quot;;
          if (attribute_flag[1] == 0)
            argument_list[1].integer_reference=MagickTrue;
          (void) ClipImagePath(image,argument_list[0].string_reference,
            argument_list[1].integer_reference != 0 ? MagickTrue : MagickFalse,
            exception);
          break;
        }
        case 75:  /* AffineTransform */
        {
          DrawInfo
            *draw_info;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info : (ImageInfo *) NULL,
            (DrawInfo *) NULL);
          if (attribute_flag[0] != 0)
            {
              AV
                *av;

              av=(AV *) argument_list[0].array_reference;
              if ((av_len(av) != 3) &amp;&amp; (av_len(av) != 5))
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;affine matrix must have 4 or 6 elements&quot;,PackageName);
                  goto PerlException;
                }
              draw_info-&gt;affine.sx=(double) SvNV(*(av_fetch(av,0,0)));
              draw_info-&gt;affine.rx=(double) SvNV(*(av_fetch(av,1,0)));
              draw_info-&gt;affine.ry=(double) SvNV(*(av_fetch(av,2,0)));
              draw_info-&gt;affine.sy=(double) SvNV(*(av_fetch(av,3,0)));
              if (fabs(draw_info-&gt;affine.sx*draw_info-&gt;affine.sy-
                  draw_info-&gt;affine.rx*draw_info-&gt;affine.ry) &lt; MagickEpsilon)
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;affine matrix is singular&quot;,PackageName);
                   goto PerlException;
                }
              if (av_len(av) == 5)
                {
                  draw_info-&gt;affine.tx=(double) SvNV(*(av_fetch(av,4,0)));
                  draw_info-&gt;affine.ty=(double) SvNV(*(av_fetch(av,5,0)));
                }
            }
          for (j=1; j &lt; 6; j++)
          {
            if (attribute_flag[j] == 0)
              continue;
            value=argument_list[j].string_reference;
            angle=argument_list[j].real_reference;
            current=draw_info-&gt;affine;
            GetAffineMatrix(&amp;affine);
            switch (j)
            {
              case 1:
              {
                /*
                  Translate.
                */
                flags=ParseGeometry(value,&amp;geometry_info);
                affine.tx=geometry_info.xi;
                affine.ty=geometry_info.psi;
                if ((flags &amp; PsiValue) == 0)
                  affine.ty=affine.tx;
                break;
              }
              case 2:
              {
                /*
                  Scale.
                */
                flags=ParseGeometry(value,&amp;geometry_info);
                affine.sx=geometry_info.rho;
                affine.sy=geometry_info.sigma;
                if ((flags &amp; SigmaValue) == 0)
                  affine.sy=affine.sx;
                break;
              }
              case 3:
              {
                /*
                  Rotate.
                */
                if (angle == 0.0)
                  break;
                affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));
                affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));
                affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));
                affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
              case 4:
              {
                /*
                  SkewX.
                */
                affine.ry=tan(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
              case 5:
              {
                /*
                  SkewY.
                */
                affine.rx=tan(DegreesToRadians(fmod(angle,360.0)));
                break;
              }
            }
            draw_info-&gt;affine.sx=current.sx*affine.sx+current.ry*affine.rx;
            draw_info-&gt;affine.rx=current.rx*affine.sx+current.sy*affine.rx;
            draw_info-&gt;affine.ry=current.sx*affine.ry+current.ry*affine.sy;
            draw_info-&gt;affine.sy=current.rx*affine.ry+current.sy*affine.sy;
            draw_info-&gt;affine.tx=
              current.sx*affine.tx+current.ry*affine.ty+current.tx;
            draw_info-&gt;affine.ty=
              current.rx*affine.tx+current.sy*affine.ty+current.ty;
          }
          if (attribute_flag[6] != 0)
            image-&gt;interpolate=(PixelInterpolateMethod)
              argument_list[6].integer_reference;
          if (attribute_flag[7] != 0)
            QueryColorCompliance(argument_list[7].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          image=AffineTransformImage(image,&amp;draw_info-&gt;affine,exception);
          draw_info=DestroyDrawInfo(draw_info);
          break;
        }
        case 76:  /* Difference */
        {
          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,
                &quot;ReferenceImageRequired&quot;,PackageName);
              goto PerlException;
            }
          if (attribute_flag[1] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[1].string_reference,(double) QuantumRange+1.0);
          (void) SetImageColorMetric(image,argument_list[0].image_reference,
            exception);
          break;
        }
        case 77:  /* AdaptiveThreshold */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; PercentValue) != 0)
                geometry_info.xi=QuantumRange*geometry_info.xi/100.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].integer_reference;;
          image=AdaptiveThresholdImage(image,(size_t) geometry_info.rho,
            (size_t) geometry_info.sigma,(double) geometry_info.xi,exception);
          break;
        }
        case 78:  /* Resample */
        {
          size_t
            height,
            width;

          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] == 0)
            argument_list[3].integer_reference=(ssize_t) UndefinedFilter;
          if (attribute_flag[4] == 0)
            SetImageArtifact(image,&quot;filter:support&quot;,
              argument_list[4].string_reference);
          width=(size_t) (geometry_info.rho*image-&gt;columns/
            (image-&gt;resolution.x == 0.0 ? 72.0 : image-&gt;resolution.x)+0.5);
          height=(size_t) (geometry_info.sigma*image-&gt;rows/
            (image-&gt;resolution.y == 0.0 ? 72.0 : image-&gt;resolution.y)+0.5);
          image=ResizeImage(image,width,height,(FilterType)
            argument_list[3].integer_reference,exception);
          if (image != (Image *) NULL)
            {
              image-&gt;resolution.x=geometry_info.rho;
              image-&gt;resolution.y=geometry_info.sigma;
            }
          break;
        }
        case 79:  /* Describe */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].file_reference=(FILE *) NULL;
          (void) IdentifyImage(image,argument_list[0].file_reference,
            MagickTrue,exception);
          break;
        }
        case 80:  /* BlackThreshold */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=&quot;50%&quot;;
          if (attribute_flag[2] != 0)
            channel=(ChannelType) argument_list[2].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) BlackThresholdImage(image,argument_list[0].string_reference,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 81:  /* WhiteThreshold */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=&quot;50%&quot;;
          if (attribute_flag[2] != 0)
            channel=(ChannelType) argument_list[2].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          WhiteThresholdImage(image,argument_list[0].string_reference,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 82:  /* RotationalBlur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            channel=(ChannelType) argument_list[2].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=RotationalBlurImage(image,geometry_info.rho,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 83:  /* Thumbnail */
        {
          if (attribute_flag[0] != 0)
            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          image=ThumbnailImage(image,geometry.width,geometry.height,exception);
          break;
        }
        case 84:  /* Strip */
        {
          (void) StripImage(image,exception);
          break;
        }
        case 85:  /* Tint */
        {
          PixelInfo
            tint;

          GetPixelInfo(image,&amp;tint);
          if (attribute_flag[0] != 0)
            (void) QueryColorCompliance(argument_list[0].string_reference,
              AllCompliance,&amp;tint,exception);
          if (attribute_flag[1] == 0)
            argument_list[1].string_reference=&quot;100&quot;;
          image=TintImage(image,argument_list[1].string_reference,&amp;tint,
            exception);
          break;
        }
        case 86:  /* Channel */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          image=SeparateImage(image,channel,exception);
          break;
        }
        case 87:  /* Splice */
        {
          if (attribute_flag[7] != 0)
            image-&gt;gravity=(GravityType) argument_list[7].integer_reference;
          if (attribute_flag[0] != 0)
            flags=ParseGravityGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry.x=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry.y=argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[5].string_reference,(double) QuantumRange+1.0);
          if (attribute_flag[6] != 0)
            (void) QueryColorCompliance(argument_list[6].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          image=SpliceImage(image,&amp;geometry,exception);
          break;
        }
        case 88:  /* Posterize */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].integer_reference=3;
          if (attribute_flag[1] == 0)
            argument_list[1].integer_reference=0;
          (void) PosterizeImage(image,(size_t)
            argument_list[0].integer_reference,
            argument_list[1].integer_reference ? RiemersmaDitherMethod :
            NoDitherMethod,exception);
          break;
        }
        case 89:  /* Shadow */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=4.0;
              if ((flags &amp; PsiValue) == 0)
                geometry_info.psi=4.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].integer_reference;
          image=ShadowImage(image,geometry_info.rho,geometry_info.sigma,
            (ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
            ceil(geometry_info.psi-0.5),exception);
          break;
        }
        case 90:  /* Identify */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].file_reference=(FILE *) NULL;
          if (attribute_flag[1] != 0)
            (void) SetImageArtifact(image,&quot;identify:features&quot;,
              argument_list[1].string_reference);
          if ((attribute_flag[2] != 0) &amp;&amp;
              (argument_list[2].integer_reference != 0))
            (void) SetImageArtifact(image,&quot;identify:moments&quot;,&quot;true&quot;);
          if ((attribute_flag[3] != 0) &amp;&amp;
              (argument_list[3].integer_reference != 0))
            (void) SetImageArtifact(image,&quot;identify:unique&quot;,&quot;true&quot;);
          (void) IdentifyImage(image,argument_list[0].file_reference,
            MagickTrue,exception);
          break;
        }
        case 91:  /* SepiaTone */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].real_reference=80.0*QuantumRange/100.0;
          image=SepiaToneImage(image,argument_list[0].real_reference,
            exception);
          break;
        }
        case 92:  /* SigmoidalContrast */
        {
          MagickBooleanType
            sharpen;

          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=QuantumRange/2.0;
              if ((flags &amp; PercentValue) != 0)
                geometry_info.sigma=QuantumRange*geometry_info.sigma/100.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          sharpen=MagickTrue;
          if (attribute_flag[4] != 0)
            sharpen=argument_list[4].integer_reference != 0 ? MagickTrue :
              MagickFalse;
          channel_mask=SetImageChannelMask(image,channel);
          (void) SigmoidalContrastImage(image,sharpen,geometry_info.rho,
            geometry_info.sigma,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 93:  /* Extent */
        {
          if (attribute_flag[7] != 0)
            image-&gt;gravity=(GravityType) argument_list[7].integer_reference;
          if (attribute_flag[0] != 0)
            {
              MagickStatusType
                flags;

              flags=ParseGravityGeometry(image,
                argument_list[0].string_reference,&amp;geometry,exception);
              (void) flags;
              if (geometry.width == 0)
                geometry.width=image-&gt;columns;
              if (geometry.height == 0)
                geometry.height=image-&gt;rows;
            }
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry.x=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry.y=argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[5].string_reference,(double) QuantumRange+1.0);
          if (attribute_flag[6] != 0)
            (void) QueryColorCompliance(argument_list[6].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          image=ExtentImage(image,&amp;geometry,exception);
          break;
        }
        case 94:  /* Vignette */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=0.1*image-&gt;columns;
              if ((flags &amp; PsiValue) == 0)
                geometry_info.psi=0.1*image-&gt;rows;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            (void) QueryColorCompliance(argument_list[5].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          image=VignetteImage(image,geometry_info.rho,geometry_info.sigma,
            (ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
            ceil(geometry_info.psi-0.5),exception);
          break;
        }
        case 95:  /* ContrastStretch */
        {
          double
            black_point,
            white_point;

          black_point=0.0;
          white_point=(double) image-&gt;columns*image-&gt;rows;
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              black_point=geometry_info.rho;
              white_point=(flags &amp; SigmaValue) != 0 ? geometry_info.sigma :
                black_point;
              if ((flags &amp; PercentValue) != 0)
                {
                  black_point*=(double) image-&gt;columns*image-&gt;rows/100.0;
                  white_point*=(double) image-&gt;columns*image-&gt;rows/100.0;
                }
              white_point=(double) image-&gt;columns*image-&gt;rows-
                white_point;
            }
          if (attribute_flag[1] != 0)
            black_point=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            white_point=argument_list[2].real_reference;
          if (attribute_flag[4] != 0)
            channel=(ChannelType) argument_list[4].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) ContrastStretchImage(image,black_point,white_point,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 96:  /* Sans0 */
        {
          break;
        }
        case 97:  /* Sans1 */
        {
          break;
        }
        case 98:  /* AdaptiveSharpen */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=0.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            channel=(ChannelType) argument_list[4].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=AdaptiveSharpenImage(image,geometry_info.rho,
            geometry_info.sigma,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 99:  /* Transpose */
        {
          image=TransposeImage(image,exception);
          break;
        }
        case 100:  /* Transverse */
        {
          image=TransverseImage(image,exception);
          break;
        }
        case 101:  /* AutoOrient */
        {
          image=AutoOrientImage(image,image-&gt;orientation,exception);
          break;
        }
        case 102:  /* AdaptiveBlur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=0.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=AdaptiveBlurImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 103:  /* Sketch */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          image=SketchImage(image,geometry_info.rho,geometry_info.sigma,
            geometry_info.xi,exception);
          break;
        }
        case 104:  /* UniqueColors */
        {
          image=UniqueImageColors(image,exception);
          break;
        }
        case 105:  /* AdaptiveResize */
        {
          if (attribute_flag[0] != 0)
            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            image-&gt;filter=(FilterType) argument_list[4].integer_reference;
          if (attribute_flag[4] != 0)
            SetImageArtifact(image,&quot;filter:support&quot;,
              argument_list[4].string_reference);
          image=AdaptiveResizeImage(image,geometry.width,geometry.height,
            exception);
          break;
        }
        case 106:  /* ClipMask */
        {
          Image
            *mask_image;

          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;MaskImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          mask_image=CloneImage(argument_list[0].image_reference,0,0,MagickTrue,
            exception);
          (void) SetImageMask(image,ReadPixelMask,mask_image,exception);
          mask_image=DestroyImage(mask_image);
          break;
        }
        case 107:  /* LinearStretch */
        {
           double
             black_point,
             white_point;

           black_point=0.0;
           white_point=(double) image-&gt;columns*image-&gt;rows;
           if (attribute_flag[0] != 0)
             {
               flags=ParseGeometry(argument_list[0].string_reference,
                 &amp;geometry_info);
               if ((flags &amp; SigmaValue) != 0)
                  white_point=geometry_info.sigma;
               if ((flags &amp; PercentValue) != 0)
                 {
                   black_point*=(double) image-&gt;columns*image-&gt;rows/100.0;
                   white_point*=(double) image-&gt;columns*image-&gt;rows/100.0;
                 }
               if ((flags &amp; SigmaValue) == 0)
                 white_point=(double) image-&gt;columns*image-&gt;rows-black_point;
             }
          if (attribute_flag[1] != 0)
            black_point=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            white_point=argument_list[2].real_reference;
          (void) LinearStretchImage(image,black_point,white_point,exception);
          break;
        }
        case 108:  /* ColorMatrix */
        {
          AV
            *av;

          double
            *color_matrix;

          KernelInfo
            *kernel_info;

          size_t
            order;

          if (attribute_flag[0] == 0)
            break;
          av=(AV *) argument_list[0].array_reference;
          order=(size_t) sqrt(av_len(av)+1);
          color_matrix=(double *) AcquireQuantumMemory(order,order*
            sizeof(*color_matrix));
          if (color_matrix == (double *) NULL)
            {
              ThrowPerlException(exception,ResourceLimitFatalError,
                &quot;MemoryAllocationFailed&quot;,PackageName);
              goto PerlException;
           }
          for (j=0; (j &lt; (ssize_t) (order*order)) &amp;&amp; (j &lt; (av_len(av)+1)); j++)
            color_matrix[j]=(double) SvNV(*(av_fetch(av,j,0)));
          for ( ; j &lt; (ssize_t) (order*order); j++)
            color_matrix[j]=0.0;
          kernel_info=AcquireKernelInfo((const char *) NULL,exception);
          if (kernel_info == (KernelInfo *) NULL)
            break;
          kernel_info-&gt;width=order;
          kernel_info-&gt;height=order;
          kernel_info-&gt;values=(MagickRealType *) AcquireAlignedMemory(order,
            order*sizeof(*kernel_info-&gt;values));
          if (kernel_info-&gt;values != (MagickRealType *) NULL)
            {
              for (i=0; i &lt; (ssize_t) (order*order); i++)
                kernel_info-&gt;values[i]=(MagickRealType) color_matrix[i];
              image=ColorMatrixImage(image,kernel_info,exception);
            }
          kernel_info=DestroyKernelInfo(kernel_info);
          color_matrix=(double *) RelinquishMagickMemory(color_matrix);
          break;
        }
        case 109:  /* Mask */
        {
          Image
            *mask_image;

          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;MaskImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          mask_image=CloneImage(argument_list[0].image_reference,0,0,
            MagickTrue,exception);
          (void) SetImageMask(image,ReadPixelMask,mask_image,exception);
          mask_image=DestroyImage(mask_image);
          break;
        }
        case 110:  /* Polaroid */
        {
          char
            *caption;

          DrawInfo
            *draw_info;

          double
            angle;

          PixelInterpolateMethod
            method;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info : (ImageInfo *) NULL,
            (DrawInfo *) NULL);
          caption=(char *) NULL;
          if (attribute_flag[0] != 0)
            caption=InterpretImageProperties(info ? info-&gt;image_info :
              (ImageInfo *) NULL,image,argument_list[0].string_reference,
              exception);
          angle=0.0;
          if (attribute_flag[1] != 0)
            angle=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            (void) CloneString(&amp;draw_info-&gt;font,
              argument_list[2].string_reference);
          if (attribute_flag[3] != 0)
            (void) QueryColorCompliance(argument_list[3].string_reference,
              AllCompliance,&amp;draw_info-&gt;stroke,exception);
          if (attribute_flag[4] != 0)
            (void) QueryColorCompliance(argument_list[4].string_reference,
              AllCompliance,&amp;draw_info-&gt;fill,exception);
          if (attribute_flag[5] != 0)
            draw_info-&gt;stroke_width=(size_t) argument_list[5].real_reference;
          if (attribute_flag[6] != 0)
            draw_info-&gt;pointsize=argument_list[6].real_reference;
          if (attribute_flag[7] != 0)
            draw_info-&gt;gravity=(GravityType) argument_list[7].integer_reference;
          if (attribute_flag[8] != 0)
            (void) QueryColorCompliance(argument_list[8].string_reference,
              AllCompliance,&amp;image-&gt;background_color,exception);
          method=UndefinedInterpolatePixel;
          if (attribute_flag[9] != 0)
            method=(PixelInterpolateMethod) argument_list[9].integer_reference;
          image=PolaroidImage(image,draw_info,caption,angle,method,exception);
          draw_info=DestroyDrawInfo(draw_info);
          if (caption != (char *) NULL)
            caption=DestroyString(caption);
          break;
        }
        case 111:  /* FloodfillPaint */
        {
          DrawInfo
            *draw_info;

          MagickBooleanType
            invert;

          PixelInfo
            target;

          draw_info=CloneDrawInfo(info ? info-&gt;image_info :
            (ImageInfo *) NULL,(DrawInfo *) NULL);
          if (attribute_flag[0] != 0)
            flags=ParsePageGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.x=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.y=argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            (void) QueryColorCompliance(argument_list[3].string_reference,
              AllCompliance,&amp;draw_info-&gt;fill,exception);
          (void) GetOneVirtualPixelInfo(image,UndefinedVirtualPixelMethod,
            geometry.x,geometry.y,&amp;target,exception);
          if (attribute_flag[4] != 0)
            QueryColorCompliance(argument_list[4].string_reference,
              AllCompliance,&amp;target,exception);
          if (attribute_flag[5] != 0)
            image-&gt;fuzz=StringToDoubleInterval(
              argument_list[5].string_reference,(double) QuantumRange+1.0);
          if (attribute_flag[6] != 0)
            channel=(ChannelType) argument_list[6].integer_reference;
          invert=MagickFalse;
          if (attribute_flag[7] != 0)
            invert=(MagickBooleanType) argument_list[7].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) FloodfillPaintImage(image,draw_info,&amp;target,geometry.x,
            geometry.y,invert,exception);
          (void) SetImageChannelMask(image,channel_mask);
          draw_info=DestroyDrawInfo(draw_info);
          break;
        }
        case 112:  /* Distort */
        {
          AV
            *av;

          double
            *coordinates;

          DistortMethod
            method;

          size_t
            number_coordinates;

          VirtualPixelMethod
            virtual_pixel;

          if (attribute_flag[0] == 0)
            break;
          method=UndefinedDistortion;
          if (attribute_flag[1] != 0)
            method=(DistortMethod) argument_list[1].integer_reference;
          av=(AV *) argument_list[0].array_reference;
          number_coordinates=(size_t) av_len(av)+1;
          coordinates=(double *) AcquireQuantumMemory(number_coordinates,
            sizeof(*coordinates));
          if (coordinates == (double *) NULL)
            {
              ThrowPerlException(exception,ResourceLimitFatalError,
                &quot;MemoryAllocationFailed&quot;,PackageName);
              goto PerlException;
            }
          for (j=0; j &lt; (ssize_t) number_coordinates; j++)
            coordinates[j]=(double) SvNV(*(av_fetch(av,j,0)));
          virtual_pixel=UndefinedVirtualPixelMethod;
          if (attribute_flag[2] != 0)
            virtual_pixel=SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
              argument_list[2].integer_reference,exception);
          image=DistortImage(image,method,number_coordinates,coordinates,
            argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse,
            exception);
          if ((attribute_flag[2] != 0) &amp;&amp; (image != (Image *) NULL))
            virtual_pixel=SetImageVirtualPixelMethod(image,virtual_pixel,
              exception);
          coordinates=(double *) RelinquishMagickMemory(coordinates);
          break;
        }
        case 113:  /* Clut */
        {
          PixelInterpolateMethod
            method;

          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;ClutImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          method=UndefinedInterpolatePixel;
          if (attribute_flag[1] != 0)
            method=(PixelInterpolateMethod) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            channel=(ChannelType) argument_list[2].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) ClutImage(image,argument_list[0].image_reference,method,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 114:  /* LiquidRescale */
        {
          if (attribute_flag[0] != 0)
            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
              &amp;geometry,exception);
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] == 0)
            argument_list[3].real_reference=1.0;
          if (attribute_flag[4] == 0)
            argument_list[4].real_reference=0.0;
          image=LiquidRescaleImage(image,geometry.width,geometry.height,
            argument_list[3].real_reference,argument_list[4].real_reference,
            exception);
          break;
        }
        case 115:  /* EncipherImage */
        {
          (void) EncipherImage(image,argument_list[0].string_reference,
            exception);
          break;
        }
        case 116:  /* DecipherImage */
        {
          (void) DecipherImage(image,argument_list[0].string_reference,
            exception);
          break;
        }
        case 117:  /* Deskew */
        {
          geometry_info.rho=QuantumRange/2.0;
          if (attribute_flag[0] != 0)
            flags=ParseGeometry(argument_list[0].string_reference,
              &amp;geometry_info);
          if (attribute_flag[1] != 0)
            geometry_info.rho=StringToDoubleInterval(
              argument_list[1].string_reference,(double) QuantumRange+1.0);
          image=DeskewImage(image,geometry_info.rho,exception);
          break;
        }
        case 118:  /* Remap */
        {
          QuantizeInfo
            *quantize_info;

          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;RemapImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          quantize_info=AcquireQuantizeInfo(info-&gt;image_info);
          if (attribute_flag[1] != 0)
            quantize_info-&gt;dither_method=(DitherMethod)
              argument_list[1].integer_reference;
          (void) RemapImages(quantize_info,image,
            argument_list[0].image_reference,exception);
          quantize_info=DestroyQuantizeInfo(quantize_info);
          break;
        }
        case 119:  /* SparseColor */
        {
          AV
            *av;

          double
            *coordinates;

          SparseColorMethod
            method;

          size_t
            number_coordinates;

          VirtualPixelMethod
            virtual_pixel;

          if (attribute_flag[0] == 0)
            break;
          method=UndefinedColorInterpolate;
          if (attribute_flag[1] != 0)
            method=(SparseColorMethod) argument_list[1].integer_reference;
          av=(AV *) argument_list[0].array_reference;
          number_coordinates=(size_t) av_len(av)+1;
          coordinates=(double *) AcquireQuantumMemory(number_coordinates,
            sizeof(*coordinates));
          if (coordinates == (double *) NULL)
            {
              ThrowPerlException(exception,ResourceLimitFatalError,
                &quot;MemoryAllocationFailed&quot;,PackageName);
              goto PerlException;
            }
          for (j=0; j &lt; (ssize_t) number_coordinates; j++)
            coordinates[j]=(double) SvNV(*(av_fetch(av,j,0)));
          virtual_pixel=UndefinedVirtualPixelMethod;
          if (attribute_flag[2] != 0)
            virtual_pixel=SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
              argument_list[2].integer_reference,exception);
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=SparseColorImage(image,method,number_coordinates,coordinates,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          if ((attribute_flag[2] != 0) &amp;&amp; (image != (Image *) NULL))
            virtual_pixel=SetImageVirtualPixelMethod(image,virtual_pixel,
              exception);
          coordinates=(double *) RelinquishMagickMemory(coordinates);
          break;
        }
        case 120:  /* Function */
        {
          AV
            *av;

          double
            *parameters;

          MagickFunction
            function;

          size_t
            number_parameters;

          VirtualPixelMethod
            virtual_pixel;

          if (attribute_flag[0] == 0)
            break;
          function=UndefinedFunction;
          if (attribute_flag[1] != 0)
            function=(MagickFunction) argument_list[1].integer_reference;
          av=(AV *) argument_list[0].array_reference;
          number_parameters=(size_t) av_len(av)+1;
          parameters=(double *) AcquireQuantumMemory(number_parameters,
            sizeof(*parameters));
          if (parameters == (double *) NULL)
            {
              ThrowPerlException(exception,ResourceLimitFatalError,
                &quot;MemoryAllocationFailed&quot;,PackageName);
              goto PerlException;
            }
          for (j=0; j &lt; (ssize_t) number_parameters; j++)
            parameters[j]=(double) SvNV(*(av_fetch(av,j,0)));
          virtual_pixel=UndefinedVirtualPixelMethod;
          if (attribute_flag[2] != 0)
            virtual_pixel=SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
              argument_list[2].integer_reference,exception);
          (void) FunctionImage(image,function,number_parameters,parameters,
            exception);
          if ((attribute_flag[2] != 0) &amp;&amp; (image != (Image *) NULL))
            virtual_pixel=SetImageVirtualPixelMethod(image,virtual_pixel,
              exception);
          parameters=(double *) RelinquishMagickMemory(parameters);
          break;
        }
        case 121:  /* SelectiveBlur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; PercentValue) != 0)
                geometry_info.xi=QuantumRange*geometry_info.xi/100.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].integer_reference;;
          if (attribute_flag[5] != 0)
            channel=(ChannelType) argument_list[5].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=SelectiveBlurImage(image,geometry_info.rho,geometry_info.sigma,
            geometry_info.xi,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 122:  /* HaldClut */
        {
          if (attribute_flag[0] == 0)
            {
              ThrowPerlException(exception,OptionError,&quot;ClutImageRequired&quot;,
                PackageName);
              goto PerlException;
            }
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) HaldClutImage(image,argument_list[0].image_reference,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 123:  /* BlueShift */
        {
          if (attribute_flag[0] != 0)
            (void) ParseGeometry(argument_list[0].string_reference,
              &amp;geometry_info);
          image=BlueShiftImage(image,geometry_info.rho,exception);
          break;
        }
        case 124:  /* ForwardFourierTransformImage */
        {
          image=ForwardFourierTransformImage(image,
            argument_list[0].integer_reference != 0 ? MagickTrue : MagickFalse,
            exception);
          break;
        }
        case 125:  /* InverseFourierTransformImage */
        {
          image=InverseFourierTransformImage(image,image-&gt;next,
            argument_list[0].integer_reference != 0 ? MagickTrue : MagickFalse,
            exception);
          break;
        }
        case 126:  /* ColorDecisionList */
        {
          if (attribute_flag[0] == 0)
            argument_list[0].string_reference=(char *) NULL;
          (void) ColorDecisionListImage(image,
            argument_list[0].string_reference,exception);
          break;
        }
        case 127:  /* AutoGamma */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) AutoGammaImage(image,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 128:  /* AutoLevel */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) AutoLevelImage(image,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 129:  /* LevelColors */
        {
          PixelInfo
            black_point,
            white_point;

          (void) QueryColorCompliance(&quot;#000000&quot;,AllCompliance,&amp;black_point,
            exception);
          (void) QueryColorCompliance(&quot;#ffffff&quot;,AllCompliance,&amp;white_point,
            exception);
          if (attribute_flag[1] != 0)
             (void) QueryColorCompliance(
               argument_list[1].string_reference,AllCompliance,&amp;black_point,
               exception);
          if (attribute_flag[2] != 0)
             (void) QueryColorCompliance(
               argument_list[2].string_reference,AllCompliance,&amp;white_point,
               exception);
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) LevelImageColors(image,&amp;black_point,&amp;white_point,
            argument_list[0].integer_reference != 0 ? MagickTrue : MagickFalse,
            exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 130:  /* Clamp */
        {
          if (attribute_flag[0] != 0)
            channel=(ChannelType) argument_list[0].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) ClampImage(image,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 131:  /* BrightnessContrast */
        {
          double
            brightness,
            contrast;

          brightness=0.0;
          contrast=0.0;
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              brightness=geometry_info.rho;
              if ((flags &amp; SigmaValue) == 0)
                contrast=geometry_info.sigma;
            }
          if (attribute_flag[1] != 0)
            brightness=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            contrast=argument_list[2].real_reference;
          if (attribute_flag[4] != 0)
            channel=(ChannelType) argument_list[4].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) BrightnessContrastImage(image,brightness,contrast,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 132:  /* Morphology */
        {
          KernelInfo
            *kernel;

          MorphologyMethod
            method;

          ssize_t
            iterations;

          if (attribute_flag[0] == 0)
            break;
          kernel=AcquireKernelInfo(argument_list[0].string_reference,exception);
          if (kernel == (KernelInfo *) NULL)
            break;
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          method=UndefinedMorphology;
          if (attribute_flag[2] != 0)
            method=(MorphologyMethod) argument_list[2].integer_reference;
          iterations=1;
          if (attribute_flag[3] != 0)
            iterations=argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=MorphologyImage(image,method,iterations,kernel,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          kernel=DestroyKernelInfo(kernel);
          break;
        }
        case 133:  /* Mode */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=StatisticImage(image,ModeStatistic,(size_t) geometry_info.rho,
            (size_t) geometry_info.sigma,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 134:  /* Statistic */
        {
          StatisticType
            statistic;

          statistic=UndefinedStatistic;
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            statistic=(StatisticType) argument_list[4].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=StatisticImage(image,statistic,(size_t) geometry_info.rho,
            (size_t) geometry_info.sigma,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 135:  /* Perceptible */
        {
          double
            epsilon;

          epsilon=MagickEpsilon;
          if (attribute_flag[0] != 0)
            epsilon=argument_list[0].real_reference;
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) PerceptibleImage(image,epsilon,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 136:  /* Poly */
        {
          AV
            *av;

          double
            *terms;

          size_t
            number_terms;

          if (attribute_flag[0] == 0)
            break;
          if (attribute_flag[1] != 0)
            channel=(ChannelType) argument_list[1].integer_reference;
          av=(AV *) argument_list[0].array_reference;
          number_terms=(size_t) av_len(av);
          terms=(double *) AcquireQuantumMemory(number_terms,sizeof(*terms));
          if (terms == (double *) NULL)
            {
              ThrowPerlException(exception,ResourceLimitFatalError,
                &quot;MemoryAllocationFailed&quot;,PackageName);
              goto PerlException;
            }
          for (j=0; j &lt; av_len(av); j++)
            terms[j]=(double) SvNV(*(av_fetch(av,j,0)));
          image=PolynomialImage(image,number_terms &gt;&gt; 1,terms,exception);
          terms=(double *) RelinquishMagickMemory(terms);
          break;
        }
        case 137:  /* Grayscale */
        {
          PixelIntensityMethod
            method;

          method=UndefinedPixelIntensityMethod;
          if (attribute_flag[0] != 0)
            method=(PixelIntensityMethod) argument_list[0].integer_reference;
          (void) GrayscaleImage(image,method,exception);
          break;
        }
        case 138:  /* Canny */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=1.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=0.10;
              if ((flags &amp; PsiValue) == 0)
                geometry_info.psi=0.30;
              if ((flags &amp; PercentValue) != 0)
                {
                  geometry_info.xi/=100.0;
                  geometry_info.psi/=100.0;
                }
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].real_reference;
          if (attribute_flag[5] != 0)
            channel=(ChannelType) argument_list[5].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=CannyEdgeImage(image,geometry_info.rho,geometry_info.sigma,
            geometry_info.xi,geometry_info.psi,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 139:  /* HoughLine */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=40;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=(double) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=(double) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=(double) argument_list[3].integer_reference;
          image=HoughLineImage(image,(size_t) geometry_info.rho,(size_t)
            geometry_info.sigma,(size_t) geometry_info.xi,exception);
          break;
        }
        case 140:  /* MeanShift */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=0.10*QuantumRange;
              if ((flags &amp; PercentValue) != 0)
                geometry_info.xi=QuantumRange*geometry_info.xi/100.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=(double) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=(double) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=(double) argument_list[3].integer_reference;
          image=MeanShiftImage(image,(size_t) geometry_info.rho,(size_t)
            geometry_info.sigma,geometry_info.xi,exception);
          break;
        }
        case 141:  /* Kuwahara */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho-0.5;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=KuwaharaImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 142:  /* ConnectedComponents */
        {
          size_t
            connectivity;

          connectivity=4;
          if (attribute_flag[0] != 0)
            connectivity=(size_t) argument_list[0].integer_reference;
          image=ConnectedComponentsImage(image,connectivity,
            (CCObjectInfo **) NULL,exception);
          break;
        }
        case 143:  /* Copy */
        {
          Image
            *source_image;

          OffsetInfo
            offset;

          RectangleInfo
            offset_geometry;

          source_image=image;
          if (attribute_flag[0] != 0)
            source_image=argument_list[0].image_reference;
          SetGeometry(source_image,&amp;geometry);
          if (attribute_flag[1] != 0)
            flags=ParseGravityGeometry(source_image,
              argument_list[1].string_reference,&amp;geometry,exception);
          if (attribute_flag[2] != 0)
            geometry.width=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry.height=(size_t) argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry.x=argument_list[4].integer_reference;
          if (attribute_flag[5] != 0)
            geometry.y=argument_list[5].integer_reference;
          if (attribute_flag[6] != 0)
            image-&gt;gravity=(GravityType) argument_list[6].integer_reference;
          SetGeometry(image,&amp;offset_geometry);
          if (attribute_flag[7] != 0)
            flags=ParseGravityGeometry(image,argument_list[7].string_reference,
              &amp;offset_geometry,exception);
          offset.x=offset_geometry.x;
          offset.y=offset_geometry.y;
          if (attribute_flag[8] != 0)
            offset.x=argument_list[8].integer_reference;
          if (attribute_flag[9] != 0)
            offset.y=argument_list[9].integer_reference;
          (void) CopyImagePixels(image,source_image,&amp;geometry,&amp;offset,
            exception);
          break;
        }
        case 144:  /* Color */
        {
          PixelInfo
            color;

          (void) QueryColorCompliance(&quot;none&quot;,AllCompliance,&amp;color,exception);
          if (attribute_flag[0] != 0)
            (void) QueryColorCompliance(argument_list[0].string_reference,
              AllCompliance,&amp;color,exception);
          (void) SetImageColor(image,&amp;color,exception);
          break;
        }
        case 145:  /* WaveletDenoise */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; PercentValue) != 0)
                {
                  geometry_info.rho=QuantumRange*geometry_info.rho/100.0;
                  geometry_info.sigma=QuantumRange*geometry_info.sigma/100.0;
                }
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=0.0;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            channel=(ChannelType) argument_list[3].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=WaveletDenoiseImage(image,geometry_info.rho,geometry_info.sigma,
            exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 146:  /* Colorspace */
        {
          ColorspaceType
            colorspace;

          colorspace=sRGBColorspace;
          if (attribute_flag[0] != 0)
            colorspace=(ColorspaceType) argument_list[0].integer_reference;
          (void) TransformImageColorspace(image,colorspace,exception);
          break;
        }
        case 147:  /* AutoThreshold */
        {
          AutoThresholdMethod
            method;

          method=UndefinedThresholdMethod;
          if (attribute_flag[0] != 0)
            method=(AutoThresholdMethod) argument_list[0].integer_reference;
          (void) AutoThresholdImage(image,method,exception);
          break;
        }
        case 148:  /* RangeThreshold */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=geometry_info.sigma;
              if ((flags &amp; PsiValue) == 0)
                geometry_info.psi=geometry_info.xi;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].real_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].real_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].real_reference;
          if (attribute_flag[5] != 0)
            channel=(ChannelType) argument_list[5].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          (void) RangeThresholdImage(image,geometry_info.rho,
            geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 149:  /* CLAHE */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              flags=ParseRegionGeometry(image,argument_list[0].string_reference,
                &amp;geometry,exception);
            }
          if (attribute_flag[1] != 0)
            geometry.width=(size_t) argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry.height=(size_t) argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry.x=argument_list[3].integer_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].real_reference;
          (void) CLAHEImage(image,geometry.width,geometry.height,(size_t)
            geometry.x,(size_t) geometry_info.psi,exception);
          break;
        }
        case 150:  /* Kmeans */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=100.0;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=0.01;
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=(ChannelType) argument_list[3].real_reference;
          (void) KmeansImage(image,geometry_info.rho,geometry_info.sigma,
            geometry_info.xi,exception);
          break;
        }
        case 151:  /* ColorThreshold */
        {
          PixelInfo
            start_color,
            stop_color;

          (void) QueryColorCompliance(&quot;black&quot;,AllCompliance,&amp;start_color,
            exception);
          (void) QueryColorCompliance(&quot;white&quot;,AllCompliance,&amp;stop_color,
            exception);
          if (attribute_flag[0] != 0)
            (void) QueryColorCompliance(argument_list[0].string_reference,
              AllCompliance,&amp;start_color,exception);
          if (attribute_flag[1] != 0)
            (void) QueryColorCompliance(argument_list[1].string_reference,
              AllCompliance,&amp;stop_color,exception);
          channel_mask=SetImageChannelMask(image,channel);
          (void) ColorThresholdImage(image,&amp;start_color,&amp;stop_color,exception);
          (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 152:  /* WhiteBalance */
        {
          (void) WhiteBalanceImage(image,exception);
          break;
        }
        case 153:  /* BilateralBlur */
        {
          if (attribute_flag[0] != 0)
            {
              flags=ParseGeometry(argument_list[0].string_reference,
                &amp;geometry_info);
              if ((flags &amp; SigmaValue) == 0)
                geometry_info.sigma=geometry_info.rho;
              if ((flags &amp; XiValue) == 0)
                geometry_info.xi=2.0*sqrt(geometry_info.rho*geometry_info.rho+
                  geometry_info.sigma*geometry_info.sigma);
              if ((flags &amp; PsiValue) == 0)
                geometry_info.psi=0.5*sqrt(geometry_info.rho*geometry_info.rho+
                  geometry_info.sigma*geometry_info.sigma);
            }
          if (attribute_flag[1] != 0)
            geometry_info.rho=argument_list[1].integer_reference;
          if (attribute_flag[2] != 0)
            geometry_info.sigma=argument_list[2].integer_reference;
          if (attribute_flag[3] != 0)
            geometry_info.xi=argument_list[3].real_reference;
          if (attribute_flag[4] != 0)
            geometry_info.psi=argument_list[4].real_reference;
          if (attribute_flag[5] != 0)
            channel=(ChannelType) argument_list[5].integer_reference;
          channel_mask=SetImageChannelMask(image,channel);
          image=BilateralBlurImage(image,(size_t) geometry_info.rho,(size_t)
            geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
          if (image != (Image *) NULL)
            (void) SetImageChannelMask(image,channel_mask);
          break;
        }
        case 154:  /* SortPixels */
        {
          (void) SortImagePixels(image,exception);
          break;
        }
        case 155:  /* Integral */
        {
          image=IntegralImage(image,exception);
          break;
        }
      }
      if (next != (Image *) NULL)
        (void) CatchImageException(next);
      if ((region_info.width*region_info.height) != 0)
        (void) SetImageRegionMask(image,WritePixelMask,
          (const RectangleInfo *) NULL,exception);
      if (image != (Image *) NULL)
        {
          number_images++;
          if (next &amp;&amp; (next != image))
            {
              image-&gt;next=next-&gt;next;
              if (image-&gt;next != (Image *) NULL)
                image-&gt;next-&gt;previous=image;
              DeleteImageFromRegistry(*pv,next);
            }
          sv_setiv(*pv,PTR2IV(image));
          next=image;
        }
      if (*pv)
        pv++;
    }

  PerlException:
    if (reference_vector)
      reference_vector=(SV **) RelinquishMagickMemory(reference_vector);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) number_images);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   M o n t a g e                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Montage(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    MontageImage  = 1
    montage       = 2
    montageimage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image,
      *next;

    PixelInfo
      transparent_color;

    MontageInfo
      *montage_info;

    ssize_t
      i,
      sp;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    attribute=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    /*
      Get options.
    */
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    montage_info=CloneMontageInfo(info-&gt;image_info,(MontageInfo *) NULL);
    (void) QueryColorCompliance(&quot;none&quot;,AllCompliance,&amp;transparent_color,
      exception);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;B&#039;:
        case &#039;b&#039;:
        {
          if (LocaleCompare(attribute,&quot;background&quot;) == 0)
            {
              (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                &amp;montage_info-&gt;background_color,exception);
              for (next=image; next; next=next-&gt;next)
                next-&gt;background_color=montage_info-&gt;background_color;
              break;
            }
          if (LocaleCompare(attribute,&quot;border&quot;) == 0)
            {
              montage_info-&gt;border_width=(size_t) SvIV(ST(i));
              break;
            }
          if (LocaleCompare(attribute,&quot;bordercolor&quot;) == 0)
            {
              (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                &amp;montage_info-&gt;border_color,exception);
              for (next=image; next; next=next-&gt;next)
                next-&gt;border_color=montage_info-&gt;border_color;
              break;
            }
          if (LocaleCompare(attribute,&quot;borderwidth&quot;) == 0)
            {
              montage_info-&gt;border_width=(size_t) SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;compose&quot;) == 0)
            {
              sp=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
                MagickComposeOptions,MagickFalse,SvPV(ST(i),na));
              if (sp &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              for (next=image; next; next=next-&gt;next)
                next-&gt;compose=(CompositeOperator) sp;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;F&#039;:
        case &#039;f&#039;:
        {
          if (LocaleCompare(attribute,&quot;fill&quot;) == 0)
            {
              (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                &amp;montage_info-&gt;fill,exception);
              break;
            }
          if (LocaleCompare(attribute,&quot;font&quot;) == 0)
            {
              (void) CloneString(&amp;montage_info-&gt;font,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;frame&quot;) == 0)
            {
              char
                *p;

              p=SvPV(ST(i),na);
              if (IsGeometry(p) == MagickFalse)
                {
                  ThrowPerlException(exception,OptionError,&quot;MissingGeometry&quot;,
                    p);
                  break;
                }
              (void) CloneString(&amp;montage_info-&gt;frame,p);
              if (*p == &#039;\0&#039;)
                montage_info-&gt;frame=(char *) NULL;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;G&#039;:
        case &#039;g&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              char
                *p;

              p=SvPV(ST(i),na);
              if (IsGeometry(p) == MagickFalse)
                {
                  ThrowPerlException(exception,OptionError,&quot;MissingGeometry&quot;,
                    p);
                  break;
                }
             (void) CloneString(&amp;montage_info-&gt;geometry,p);
             if (*p == &#039;\0&#039;)
               montage_info-&gt;geometry=(char *) NULL;
             break;
           }
         if (LocaleCompare(attribute,&quot;gravity&quot;) == 0)
           {
             ssize_t
               in;

             in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
               MagickGravityOptions,MagickFalse,SvPV(ST(i),na));
             if (in &lt; 0)
               {
                 ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                   SvPV(ST(i),na));
                 return;
               }
             montage_info-&gt;gravity=(GravityType) in;
             for (next=image; next; next=next-&gt;next)
               next-&gt;gravity=(GravityType) in;
             break;
           }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;L&#039;:
        case &#039;l&#039;:
        {
          if (LocaleCompare(attribute,&quot;label&quot;) == 0)
            {
              for (next=image; next; next=next-&gt;next)
                (void) SetImageProperty(next,&quot;label&quot;,InterpretImageProperties(
                  info ? info-&gt;image_info : (ImageInfo *) NULL,next,
                  SvPV(ST(i),na),exception),exception);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;M&#039;:
        case &#039;m&#039;:
        {
          if (LocaleCompare(attribute,&quot;mattecolor&quot;) == 0)
            {
              (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                &amp;montage_info-&gt;alpha_color,exception);
              for (next=image; next; next=next-&gt;next)
                next-&gt;alpha_color=montage_info-&gt;alpha_color;
              break;
            }
          if (LocaleCompare(attribute,&quot;mode&quot;) == 0)
            {
              ssize_t
                in;

              in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
                MagickModeOptions,MagickFalse,SvPV(ST(i),na));
              switch (in)
              {
                default:
                {
                  ThrowPerlException(exception,OptionError,
                    &quot;UnrecognizedModeType&quot;,SvPV(ST(i),na));
                  break;
                }
                case FrameMode:
                {
                  (void) CloneString(&amp;montage_info-&gt;frame,&quot;15x15+3+3&quot;);
                  montage_info-&gt;shadow=MagickTrue;
                  break;
                }
                case UnframeMode:
                {
                  montage_info-&gt;frame=(char *) NULL;
                  montage_info-&gt;shadow=MagickFalse;
                  montage_info-&gt;border_width=0;
                  break;
                }
                case ConcatenateMode:
                {
                  montage_info-&gt;frame=(char *) NULL;
                  montage_info-&gt;shadow=MagickFalse;
                  (void) CloneString(&amp;montage_info-&gt;geometry,&quot;+0+0&quot;);
                  montage_info-&gt;border_width=0;
                }
              }
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;P&#039;:
        case &#039;p&#039;:
        {
          if (LocaleCompare(attribute,&quot;pointsize&quot;) == 0)
            {
              montage_info-&gt;pointsize=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;S&#039;:
        case &#039;s&#039;:
        {
          if (LocaleCompare(attribute,&quot;shadow&quot;) == 0)
            {
              sp=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
                MagickBooleanOptions,MagickFalse,SvPV(ST(i),na));
              if (sp &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
             montage_info-&gt;shadow=sp != 0 ? MagickTrue : MagickFalse;
             break;
            }
          if (LocaleCompare(attribute,&quot;stroke&quot;) == 0)
            {
              (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                &amp;montage_info-&gt;stroke,exception);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;T&#039;:
        case &#039;t&#039;:
        {
          if (LocaleCompare(attribute,&quot;texture&quot;) == 0)
            {
              (void) CloneString(&amp;montage_info-&gt;texture,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;tile&quot;) == 0)
            {
              char *p=SvPV(ST(i),na);
              if (IsGeometry(p) == MagickFalse)
                {
                  ThrowPerlException(exception,OptionError,&quot;MissingGeometry&quot;,
                    p);
                  break;
                }
              (void) CloneString(&amp;montage_info-&gt;tile,p);
              if (*p == &#039;\0&#039;)
                montage_info-&gt;tile=(char *) NULL;
              break;
            }
          if (LocaleCompare(attribute,&quot;title&quot;) == 0)
            {
              (void) CloneString(&amp;montage_info-&gt;title,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;transparent&quot;) == 0)
            {
              PixelInfo
                transparent_color;

              QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                &amp;transparent_color,exception);
              for (next=image; next; next=next-&gt;next)
                (void) TransparentPaintImage(next,&amp;transparent_color,
                  TransparentAlpha,MagickFalse,exception);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    image=MontageImageList(info-&gt;image_info,montage_info,image,exception);
    montage_info=DestroyMontageInfo(montage_info);
    if (image == (Image *) NULL)
      goto PerlException;
    if (transparent_color.alpha != TransparentAlpha)
      for (next=image; next; next=next-&gt;next)
        (void) TransparentPaintImage(next,&amp;transparent_color,
          TransparentAlpha,MagickFalse,exception);
    for (  ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   M o r p h                                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Morph(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    MorphImage  = 1
    morph       = 2
    morphimage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      i,
      number_frames;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    av=NULL;
    attribute=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    /*
      Get attribute.
    */
    number_frames=30;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;F&#039;:
        case &#039;f&#039;:
        {
          if (LocaleCompare(attribute,&quot;frames&quot;) == 0)
            {
              number_frames=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    image=MorphImages(image,(size_t) number_frames,exception);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   M o s a i c                                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Mosaic(ref)
  Image::Magick ref=NO_INIT
  ALIAS:
    MosaicImage   = 1
    mosaic        = 2
    mosaicimage   = 3
  PPCODE:
  {
    AV
      *av;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    image=MergeImageLayers(image,MosaicLayer,exception);
    /*
      Create blessed Perl array for the returned image.
    */
    av=newAV();
    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    AddImageToRegistry(sv,image);
    rv=newRV(sv);
    av_push(av,sv_bless(rv,hv));
    SvREFCNT_dec(sv);
    (void) CopyMagickString(info-&gt;image_info-&gt;filename,image-&gt;filename,
      MagickPathExtent);
    SetImageInfo(info-&gt;image_info,0,exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);  /* return messages in string context */
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   P e r c e p t u a l H a s h                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
PerceptualHash(ref)
  Image::Magick ref = NO_INIT
  ALIAS:
    PerceptualHashImage = 1
    perceptualhash      = 2
    perceptualhashimage = 3
  PPCODE:
  {
    AV
      *av;

    ChannelPerceptualHash
      *channel_phash;

    char
      message[MagickPathExtent];

    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      count;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    av=newAV();
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    count=0;
    for ( ; image; image=image-&gt;next)
    {
      ssize_t
        i;

      channel_phash=GetImagePerceptualHash(image,exception);
      if (channel_phash == (ChannelPerceptualHash *) NULL)
        continue;
      count++;
      for (i=0; i &lt; (ssize_t) GetPixelChannels(image); i++)
      {
        ssize_t
          j;

        PixelChannel channel=GetPixelChannelChannel(image,i);
        PixelTrait traits=GetPixelChannelTraits(image,channel);
        if (traits == UndefinedPixelTrait)
          continue;
        EXTEND(sp,((ssize_t) GetPixelChannels(image)*
          MaximumNumberOfPerceptualHashes*
          (ssize_t) channel_phash[0].number_colorspaces*(i+1)*count));
        for (j=0; j &lt; MaximumNumberOfPerceptualHashes; j++)
        {
          ssize_t
            k;

          for (k=0; k &lt; (ssize_t) channel_phash[0].number_colorspaces; k++)
          {
            (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,
              channel_phash[channel].phash[k][j]);
            PUSHs(sv_2mortal(newSVpv(message,0)));
          }
        }
      }
      channel_phash=(ChannelPerceptualHash *)
        RelinquishMagickMemory(channel_phash);
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   P i n g                                                                   #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Ping(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    PingImage  = 1
    ping       = 2
    pingimage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      **keep,
      **list,
      **p;

    ExceptionInfo
      *exception;

    Image
      *image,
      *next;

    int
      n;

    MagickBooleanType
      status;

    ssize_t
      ac,
      i;

    STRLEN
      *length;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,
      *reference;

    size_t
      count;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    package_info=(struct PackageInfo *) NULL;
    ac=(items &lt; 2) ? 1 : items-1;
    list=(char **) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*list));
    keep=list;
    length=(STRLEN *) NULL;
    if (list == (char **) NULL)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    keep=list;
    length=(STRLEN *) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*length));
    if (length == (STRLEN *) NULL)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    if (SvTYPE(reference) != SVt_PVAV)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    package_info=ClonePackageInfo(info,exception);
    n=1;
    if (items &lt;= 1)
      *list=(char *) (*package_info-&gt;image_info-&gt;filename ?
        package_info-&gt;image_info-&gt;filename : &quot;XC:black&quot;);
    else
      for (n=0, i=0; i &lt; ac; i++)
      {
        list[n]=(char *) SvPV(ST(i+1),length[n]);
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;blob&quot;))
          {
            void
              *blob;

            i++;
            blob=(void *) (SvPV(ST(i+1),length[n]));
            SetImageInfoBlob(package_info-&gt;image_info,blob,(size_t) length[n]);
          }
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;filename&quot;))
          continue;
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;file&quot;))
          {
            FILE
              *file;

            PerlIO
              *io_info;

            i++;
            io_info=IoIFP(sv_2io(ST(i+1)));
            if (io_info == (PerlIO *) NULL)
              {
                ThrowPerlException(exception,BlobError,&quot;UnableToOpenFile&quot;,
                  PackageName);
                continue;
              }
            file=PerlIO_findFILE(io_info);
            if (file == (FILE *) NULL)
              {
                ThrowPerlException(exception,BlobError,&quot;UnableToOpenFile&quot;,
                  PackageName);
                continue;
              }
            SetImageInfoFile(package_info-&gt;image_info,file);
          }
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;magick&quot;))
          continue;
        n++;
      }
    list[n]=(char *) NULL;
    keep=list;
    status=ExpandFilenames(&amp;n,&amp;list);
    if (status == MagickFalse)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    count=0;
    for (i=0; i &lt; n; i++)
    {
      (void) CopyMagickString(package_info-&gt;image_info-&gt;filename,list[i],
        MagickPathExtent);
      image=PingImage(package_info-&gt;image_info,exception);
      if (image == (Image *) NULL)
        break;
      if ((package_info-&gt;image_info-&gt;file != (FILE *) NULL) ||
          (package_info-&gt;image_info-&gt;blob != (void *) NULL))
        DisassociateImageStream(image);
      count+=GetImageListLength(image);
      EXTEND(sp,4*(ssize_t) count);
      for (next=image; next; next=next-&gt;next)
      {
        PUSHs(sv_2mortal(newSViv((ssize_t) next-&gt;columns)));
        PUSHs(sv_2mortal(newSViv((ssize_t) next-&gt;rows)));
        PUSHs(sv_2mortal(newSViv((ssize_t) GetBlobSize(next))));
        PUSHs(sv_2mortal(newSVpv(next-&gt;magick,0)));
      }
      image=DestroyImageList(image);
    }
    /*
      Free resources.
    */
    for (i=0; i &lt; n; i++)
      if (list[i] != (char *) NULL)
        for (p=keep; list[i] != *p++; )
          if (*p == NULL)
            {
              list[i]=(char *) RelinquishMagickMemory(list[i]);
              break;
            }

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    if (list &amp;&amp; (list != keep))
      list=(char **) RelinquishMagickMemory(list);
    if (keep)
      keep=(char **) RelinquishMagickMemory(keep);
    if (length)
      length=(STRLEN *) RelinquishMagickMemory(length);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   P r e v i e w                                                             #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Preview(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    PreviewImage = 1
    preview      = 2
    previewimage = 3
  PPCODE:
  {
    AV
      *av;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image,
      *preview_image;

    PreviewType
      preview_type;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    preview_type=GammaPreview;
    if (items &gt; 1)
      preview_type=(PreviewType)
        ParseCommandOption(MagickPreviewOptions,MagickFalse,SvPV(ST(1),na));
    for ( ; image; image=image-&gt;next)
    {
      preview_image=PreviewImage(image,preview_type,exception);
      if (preview_image == (Image *) NULL)
        goto PerlException;
      AddImageToRegistry(sv,preview_image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y C o l o r                                                       #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryColor(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    querycolor = 1
  PPCODE:
  {
    char
      *name;

    ExceptionInfo
      *exception;

    PixelInfo
      color;

    ssize_t
      i;

    SV
      *perl_exception;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (items == 1)
      {
        const ColorInfo
          **colorlist;

        size_t
          colors;

        colorlist=GetColorInfoList(&quot;*&quot;,&amp;colors,exception);
        EXTEND(sp,(ssize_t) colors);
        for (i=0; i &lt; (ssize_t) colors; i++)
        {
          PUSHs(sv_2mortal(newSVpv(colorlist[i]-&gt;name,0)));
        }
        colorlist=(const ColorInfo **)
          RelinquishMagickMemory((ColorInfo **) colorlist);
        goto PerlException;
      }
    EXTEND(sp,5*items);
    for (i=1; i &lt; items; i++)
    {
      name=(char *) SvPV(ST(i),na);
      if (QueryColorCompliance(name,AllCompliance,&amp;color,exception) == MagickFalse)
        {
          PUSHs(&amp;sv_undef);
          continue;
        }
      PUSHs(sv_2mortal(newSViv((ssize_t) floor(color.red+0.5))));
      PUSHs(sv_2mortal(newSViv((ssize_t) floor(color.green+0.5))));
      PUSHs(sv_2mortal(newSViv((ssize_t) floor(color.blue+0.5))));
      if (color.colorspace == CMYKColorspace)
        PUSHs(sv_2mortal(newSViv((ssize_t) floor(color.black+0.5))));
      if (color.alpha_trait != UndefinedPixelTrait)
        PUSHs(sv_2mortal(newSViv((ssize_t) floor(color.alpha+0.5))));
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y C o l o r N a m e                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryColorname(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    querycolorname = 1
  PPCODE:
  {
    AV
      *av;

    char
      message[MagickPathExtent];

    ExceptionInfo
      *exception;

    Image
      *image;

    PixelInfo
      target_color;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    EXTEND(sp,items);
    for (i=1; i &lt; items; i++)
    {
      (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,&amp;target_color,
        exception);
      (void) QueryColorname(image,&amp;target_color,SVGCompliance,message,
        exception);
      PUSHs(sv_2mortal(newSVpv(message,0)));
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y F o n t                                                         #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryFont(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    queryfont = 1
  PPCODE:
  {
    char
      *name,
      message[MagickPathExtent];

    ExceptionInfo
      *exception;

    ssize_t
      i;

    SV
      *perl_exception;

    volatile const TypeInfo
      *type_info;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (items == 1)
      {
        const TypeInfo
          **typelist;

        size_t
          types;

        typelist=GetTypeInfoList(&quot;*&quot;,&amp;types,exception);
        EXTEND(sp,(ssize_t) types);
        for (i=0; i &lt; (ssize_t) types; i++)
        {
          PUSHs(sv_2mortal(newSVpv(typelist[i]-&gt;name,0)));
        }
        typelist=(const TypeInfo **) RelinquishMagickMemory((TypeInfo **)
          typelist);
        goto PerlException;
      }
    EXTEND(sp,10*items);
    for (i=1; i &lt; items; i++)
    {
      name=(char *) SvPV(ST(i),na);
      type_info=GetTypeInfo(name,exception);
      if (type_info == (TypeInfo *) NULL)
        {
          PUSHs(&amp;sv_undef);
          continue;
        }
      if (type_info-&gt;name == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;name,0)));
      if (type_info-&gt;description == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;description,0)));
      if (type_info-&gt;family == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;family,0)));
      if (type_info-&gt;style == UndefinedStyle)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(CommandOptionToMnemonic(MagickStyleOptions,
          type_info-&gt;style),0)));
      if (type_info-&gt;stretch == UndefinedStretch)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(CommandOptionToMnemonic(MagickStretchOptions,
          type_info-&gt;stretch),0)));
      (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;,(double)
        type_info-&gt;weight);
      PUSHs(sv_2mortal(newSVpv(message,0)));
      if (type_info-&gt;encoding == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;encoding,0)));
      if (type_info-&gt;foundry == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;foundry,0)));
      if (type_info-&gt;format == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;format,0)));
      if (type_info-&gt;metrics == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;metrics,0)));
      if (type_info-&gt;glyphs == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(type_info-&gt;glyphs,0)));
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y F o n t M e t r i c s                                           #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryFontMetrics(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    queryfontmetrics = 1
  PPCODE:
  {
    AffineMatrix
      affine,
      current;

    AV
      *av;

    char
      *attribute;

    double
      x,
      y;

    DrawInfo
      *draw_info;

    ExceptionInfo
      *exception;

    GeometryInfo
      geometry_info;

    Image
      *image;

    MagickBooleanType
      status;

    MagickStatusType
      flags;

    ssize_t
      i,
      type;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    TypeMetric
      metrics;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    package_info=(struct PackageInfo *) NULL;
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    package_info=ClonePackageInfo(info,exception);
    draw_info=CloneDrawInfo(package_info-&gt;image_info,(DrawInfo *) NULL);
    CloneString(&amp;draw_info-&gt;text,&quot;&quot;);
    current=draw_info-&gt;affine;
    GetAffineMatrix(&amp;affine);
    x=0.0;
    y=0.0;
    EXTEND(sp,7*items);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;A&#039;:
        case &#039;a&#039;:
        {
          if (LocaleCompare(attribute,&quot;antialias&quot;) == 0)
            {
              type=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (type &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              draw_info-&gt;text_antialias=type != 0 ? MagickTrue : MagickFalse;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;d&#039;:
        case &#039;D&#039;:
        {
          if (LocaleCompare(attribute,&quot;density&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;density,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;direction&quot;) == 0)
            {
              draw_info-&gt;direction=(DirectionType) ParseCommandOption(
                MagickDirectionOptions,MagickFalse,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;e&#039;:
        case &#039;E&#039;:
        {
          if (LocaleCompare(attribute,&quot;encoding&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;encoding,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;f&#039;:
        case &#039;F&#039;:
        {
          if (LocaleCompare(attribute,&quot;family&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;family,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;fill&quot;) == 0)
            {
              if (info)
                (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                  &amp;draw_info-&gt;fill,exception);
              break;
            }
          if (LocaleCompare(attribute,&quot;font&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;font,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;geometry,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;gravity&quot;) == 0)
            {
              draw_info-&gt;gravity=(GravityType) ParseCommandOption(
                MagickGravityOptions,MagickFalse,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;i&#039;:
        case &#039;I&#039;:
        {
          if (LocaleCompare(attribute,&quot;interline-spacing&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;interline_spacing=geometry_info.rho;
              break;
            }
          if (LocaleCompare(attribute,&quot;interword-spacing&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;interword_spacing=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;k&#039;:
        case &#039;K&#039;:
        {
          if (LocaleCompare(attribute,&quot;kerning&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;kerning=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;p&#039;:
        case &#039;P&#039;:
        {
          if (LocaleCompare(attribute,&quot;pointsize&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;pointsize=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;r&#039;:
        case &#039;R&#039;:
        {
          if (LocaleCompare(attribute,&quot;rotate&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              affine.rx=geometry_info.rho;
              affine.ry=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                affine.ry=affine.rx;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;s&#039;:
        case &#039;S&#039;:
        {
          if (LocaleCompare(attribute,&quot;scale&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              affine.sx=geometry_info.rho;
              affine.sy=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                affine.sy=affine.sx;
              break;
            }
          if (LocaleCompare(attribute,&quot;skew&quot;) == 0)
            {
              double
                x_angle,
                y_angle;

              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              x_angle=geometry_info.rho;
              y_angle=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                y_angle=x_angle;
              affine.ry=tan(DegreesToRadians(fmod(x_angle,360.0)));
              affine.rx=tan(DegreesToRadians(fmod(y_angle,360.0)));
              break;
            }
          if (LocaleCompare(attribute,&quot;stroke&quot;) == 0)
            {
              if (info)
                (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                  &amp;draw_info-&gt;stroke,exception);
              break;
            }
          if (LocaleCompare(attribute,&quot;style&quot;) == 0)
            {
              type=ParseCommandOption(MagickStyleOptions,MagickFalse,
                SvPV(ST(i),na));
              if (type &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              draw_info-&gt;style=(StyleType) type;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;t&#039;:
        case &#039;T&#039;:
        {
          if (LocaleCompare(attribute,&quot;text&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;text,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;translate&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              affine.tx=geometry_info.rho;
              affine.ty=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                affine.ty=affine.tx;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;w&#039;:
        case &#039;W&#039;:
        {
          if (LocaleCompare(attribute,&quot;weight&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;weight=(size_t) geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;x&#039;:
        case &#039;X&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              x=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;y&#039;:
        case &#039;Y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              y=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    draw_info-&gt;affine.sx=current.sx*affine.sx+current.ry*affine.rx;
    draw_info-&gt;affine.rx=current.rx*affine.sx+current.sy*affine.rx;
    draw_info-&gt;affine.ry=current.sx*affine.ry+current.ry*affine.sy;
    draw_info-&gt;affine.sy=current.rx*affine.ry+current.sy*affine.sy;
    draw_info-&gt;affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
    draw_info-&gt;affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
    if (draw_info-&gt;geometry == (char *) NULL)
      {
        draw_info-&gt;geometry=AcquireString((char *) NULL);
        (void) FormatLocaleString(draw_info-&gt;geometry,MagickPathExtent,
          &quot;%.17g,%.17g&quot;,x,y);
      }
    status=GetTypeMetrics(image,draw_info,&amp;metrics,exception);
    (void) CatchImageException(image);
    if (status == MagickFalse)
      PUSHs(&amp;sv_undef);
    else
      {
        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.x)));
        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.y)));
        PUSHs(sv_2mortal(newSVnv(metrics.ascent)));
        PUSHs(sv_2mortal(newSVnv(metrics.descent)));
        PUSHs(sv_2mortal(newSVnv(metrics.width)));
        PUSHs(sv_2mortal(newSVnv(metrics.height)));
        PUSHs(sv_2mortal(newSVnv(metrics.max_advance)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x1)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y1)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x2)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y2)));
        PUSHs(sv_2mortal(newSVnv(metrics.origin.x)));
        PUSHs(sv_2mortal(newSVnv(metrics.origin.y)));
      }
    draw_info=DestroyDrawInfo(draw_info);

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y M u l t i l i n e F o n t M e t r i c s                         #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryMultilineFontMetrics(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    querymultilinefontmetrics = 1
  PPCODE:
  {
    AffineMatrix
      affine,
      current;

    AV
      *av;

    char
      *attribute;

    double
      x,
      y;

    DrawInfo
      *draw_info;

    ExceptionInfo
      *exception;

    GeometryInfo
      geometry_info;

    Image
      *image;

    MagickBooleanType
      status;

    MagickStatusType
      flags;

    ssize_t
      i,
      type;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    TypeMetric
      metrics;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    package_info=(struct PackageInfo *) NULL;
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    package_info=ClonePackageInfo(info,exception);
    draw_info=CloneDrawInfo(package_info-&gt;image_info,(DrawInfo *) NULL);
    CloneString(&amp;draw_info-&gt;text,&quot;&quot;);
    current=draw_info-&gt;affine;
    GetAffineMatrix(&amp;affine);
    x=0.0;
    y=0.0;
    EXTEND(sp,7*items);
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;A&#039;:
        case &#039;a&#039;:
        {
          if (LocaleCompare(attribute,&quot;antialias&quot;) == 0)
            {
              type=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (type &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              draw_info-&gt;text_antialias=type != 0 ? MagickTrue : MagickFalse;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;d&#039;:
        case &#039;D&#039;:
        {
          if (LocaleCompare(attribute,&quot;density&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;density,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;e&#039;:
        case &#039;E&#039;:
        {
          if (LocaleCompare(attribute,&quot;encoding&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;encoding,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;f&#039;:
        case &#039;F&#039;:
        {
          if (LocaleCompare(attribute,&quot;family&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;family,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;fill&quot;) == 0)
            {
              if (info)
                (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                  &amp;draw_info-&gt;fill,exception);
              break;
            }
          if (LocaleCompare(attribute,&quot;font&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;font,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;geometry,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;gravity&quot;) == 0)
            {
              draw_info-&gt;gravity=(GravityType) ParseCommandOption(
                MagickGravityOptions,MagickFalse,SvPV(ST(i),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;p&#039;:
        case &#039;P&#039;:
        {
          if (LocaleCompare(attribute,&quot;pointsize&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;pointsize=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;r&#039;:
        case &#039;R&#039;:
        {
          if (LocaleCompare(attribute,&quot;rotate&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              affine.rx=geometry_info.rho;
              affine.ry=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                affine.ry=affine.rx;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;s&#039;:
        case &#039;S&#039;:
        {
          if (LocaleCompare(attribute,&quot;scale&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              affine.sx=geometry_info.rho;
              affine.sy=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                affine.sy=affine.sx;
              break;
            }
          if (LocaleCompare(attribute,&quot;skew&quot;) == 0)
            {
              double
                x_angle,
                y_angle;

              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              x_angle=geometry_info.rho;
              y_angle=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                y_angle=x_angle;
              affine.ry=tan(DegreesToRadians(fmod(x_angle,360.0)));
              affine.rx=tan(DegreesToRadians(fmod(y_angle,360.0)));
              break;
            }
          if (LocaleCompare(attribute,&quot;stroke&quot;) == 0)
            {
              if (info)
                (void) QueryColorCompliance(SvPV(ST(i),na),AllCompliance,
                  &amp;draw_info-&gt;stroke,exception);
              break;
            }
          if (LocaleCompare(attribute,&quot;style&quot;) == 0)
            {
              type=ParseCommandOption(MagickStyleOptions,MagickFalse,
                SvPV(ST(i),na));
              if (type &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
              draw_info-&gt;style=(StyleType) type;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;t&#039;:
        case &#039;T&#039;:
        {
          if (LocaleCompare(attribute,&quot;text&quot;) == 0)
            {
              CloneString(&amp;draw_info-&gt;text,SvPV(ST(i),na));
              break;
            }
          if (LocaleCompare(attribute,&quot;translate&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              affine.tx=geometry_info.rho;
              affine.ty=geometry_info.sigma;
              if ((flags &amp; SigmaValue) == 0)
                affine.ty=affine.tx;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;w&#039;:
        case &#039;W&#039;:
        {
          if (LocaleCompare(attribute,&quot;weight&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              draw_info-&gt;weight=(size_t) geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;x&#039;:
        case &#039;X&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              x=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;y&#039;:
        case &#039;Y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              flags=ParseGeometry(SvPV(ST(i),na),&amp;geometry_info);
              y=geometry_info.rho;
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    draw_info-&gt;affine.sx=current.sx*affine.sx+current.ry*affine.rx;
    draw_info-&gt;affine.rx=current.rx*affine.sx+current.sy*affine.rx;
    draw_info-&gt;affine.ry=current.sx*affine.ry+current.ry*affine.sy;
    draw_info-&gt;affine.sy=current.rx*affine.ry+current.sy*affine.sy;
    draw_info-&gt;affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
    draw_info-&gt;affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
    if (draw_info-&gt;geometry == (char *) NULL)
      {
        draw_info-&gt;geometry=AcquireString((char *) NULL);
        (void) FormatLocaleString(draw_info-&gt;geometry,MagickPathExtent,
          &quot;%.17g,%.17g&quot;,x,y);
      }
    status=GetMultilineTypeMetrics(image,draw_info,&amp;metrics,exception);
    (void) CatchException(exception);
    if (status == MagickFalse)
      PUSHs(&amp;sv_undef);
    else
      {
        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.x)));
        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.y)));
        PUSHs(sv_2mortal(newSVnv(metrics.ascent)));
        PUSHs(sv_2mortal(newSVnv(metrics.descent)));
        PUSHs(sv_2mortal(newSVnv(metrics.width)));
        PUSHs(sv_2mortal(newSVnv(metrics.height)));
        PUSHs(sv_2mortal(newSVnv(metrics.max_advance)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x1)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y1)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x2)));
        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y2)));
        PUSHs(sv_2mortal(newSVnv(metrics.origin.x)));
        PUSHs(sv_2mortal(newSVnv(metrics.origin.y)));
      }
    draw_info=DestroyDrawInfo(draw_info);

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* can&#039;t return warning messages */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y F o r m a t                                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryFormat(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    queryformat = 1
  PPCODE:
  {
    char
      *name;

    ExceptionInfo
      *exception;

    ssize_t
      i;

    SV
      *perl_exception;

    volatile const MagickInfo
      *magick_info;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (items == 1)
      {
        char
          format[MagickPathExtent];

        const MagickInfo
          **format_list;

        size_t
          types;

        format_list=GetMagickInfoList(&quot;*&quot;,&amp;types,exception);
        EXTEND(sp,(ssize_t) types);
        for (i=0; i &lt; (ssize_t) types; i++)
        {
          (void) CopyMagickString(format,format_list[i]-&gt;name,MagickPathExtent);
          LocaleLower(format);
          PUSHs(sv_2mortal(newSVpv(format,0)));
        }
        format_list=(const MagickInfo **)
          RelinquishMagickMemory((MagickInfo *) format_list);
        goto PerlException;
      }
    EXTEND(sp,8*items);
    for (i=1; i &lt; items; i++)
    {
      name=(char *) SvPV(ST(i),na);
      magick_info=GetMagickInfo(name,exception);
      if (magick_info == (const MagickInfo *) NULL)
        {
          PUSHs(&amp;sv_undef);
          continue;
        }
      if (magick_info-&gt;description == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(magick_info-&gt;description,0)));
      if (magick_info-&gt;magick_module == (char *) NULL)
        PUSHs(&amp;sv_undef);
      else
        PUSHs(sv_2mortal(newSVpv(magick_info-&gt;magick_module,0)));
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   Q u e r y O p t i o n                                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
QueryOption(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    queryoption = 1
  PPCODE:
  {
    char
      **options;

    ExceptionInfo
      *exception;

    ssize_t
      i,
      j,
      option;

    SV
      *perl_exception;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    EXTEND(sp,8*items);
    for (i=1; i &lt; items; i++)
    {
      option=ParseCommandOption(MagickListOptions,MagickFalse,(char *)
        SvPV(ST(i),na));
      options=GetCommandOptions((CommandOption) option);
      if (options == (char **) NULL)
        PUSHs(&amp;sv_undef);
      else
        {
          for (j=0; options[j] != (char *) NULL; j++)
            PUSHs(sv_2mortal(newSVpv(options[j],0)));
          options=DestroyStringList(options);
        }
    }

    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   R e a d                                                                   #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Read(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    ReadImage  = 1
    read       = 2
    readimage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      **keep,
      **list,
      **p;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    int
      n;

    MagickBooleanType
      status;

    ssize_t
      ac,
      i,
      number_images;

    STRLEN
      *length;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,  /* Perl variable for storing messages */
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    package_info=(struct PackageInfo *) NULL;
    number_images=0;
    ac=(items &lt; 2) ? 1 : items-1;
    list=(char **) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*list));
    keep=list;
    length=(STRLEN *) NULL;
    if (list == (char **) NULL)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    length=(STRLEN *) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*length));
    if (length == (STRLEN *) NULL)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    if (SvTYPE(reference) != SVt_PVAV)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    package_info=ClonePackageInfo(info,exception);
    n=1;
    if (items &lt;= 1)
      *list=(char *) (*package_info-&gt;image_info-&gt;filename ?
        package_info-&gt;image_info-&gt;filename : &quot;XC:black&quot;);
    else
      for (n=0, i=0; i &lt; ac; i++)
      {
        list[n]=(char *) SvPV(ST(i+1),length[n]);
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;blob&quot;))
          {
            void
              *blob;

            i++;
            blob=(void *) (SvPV(ST(i+1),length[n]));
            SetImageInfoBlob(package_info-&gt;image_info,blob,(size_t) length[n]);
          }
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;filename&quot;))
          continue;
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;file&quot;))
          {
            FILE
              *file;

            PerlIO
              *io_info;

            i++;
            io_info=IoIFP(sv_2io(ST(i+1)));
            if (io_info == (PerlIO *) NULL)
              {
                ThrowPerlException(exception,BlobError,&quot;UnableToOpenFile&quot;,
                  PackageName);
                continue;
              }
            file=PerlIO_findFILE(io_info);
            if (file == (FILE *) NULL)
              {
                ThrowPerlException(exception,BlobError,&quot;UnableToOpenFile&quot;,
                  PackageName);
                continue;
              }
            SetImageInfoFile(package_info-&gt;image_info,file);
          }
        if ((items &gt;= 3) &amp;&amp; strEQcase(list[n],&quot;magick&quot;))
          continue;
        n++;
      }
    list[n]=(char *) NULL;
    keep=list;
    status=ExpandFilenames(&amp;n,&amp;list);
    if (status == MagickFalse)
      {
        ThrowPerlException(exception,ResourceLimitError,
          &quot;MemoryAllocationFailed&quot;,PackageName);
        goto PerlException;
      }
    number_images=0;
    for (i=0; i &lt; n; i++)
    {
      if ((package_info-&gt;image_info-&gt;file == (FILE *) NULL) &amp;&amp;
          (package_info-&gt;image_info-&gt;blob == (void *) NULL))
        image=ReadImages(package_info-&gt;image_info,list[i],exception);
      else
        {
          image=ReadImages(package_info-&gt;image_info,
            package_info-&gt;image_info-&gt;filename,exception);
          if (image != (Image *) NULL)
            DisassociateImageStream(image);
        }
      if (image == (Image *) NULL)
        break;
      for ( ; image; image=image-&gt;next)
      {
        AddImageToRegistry(sv,image);
        rv=newRV(sv);
        av_push(av,sv_bless(rv,hv));
        SvREFCNT_dec(sv);
        number_images++;
      }
    }
    /*
      Free resources.
    */
    for (i=0; i &lt; n; i++)
      if (list[i] != (char *) NULL)
        for (p=keep; list[i] != *p++; )
          if (*p == (char *) NULL)
            {
              list[i]=(char *) RelinquishMagickMemory(list[i]);
              break;
            }

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    if (list &amp;&amp; (list != keep))
      list=(char **) RelinquishMagickMemory(list);
    if (keep)
      keep=(char **) RelinquishMagickMemory(keep);
    if (length)
      length=(STRLEN *) RelinquishMagickMemory(length);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) number_images);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   R e m o t e                                                               #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Remote(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    RemoteCommand  = 1
    remote         = 2
    remoteCommand  = 3
  PPCODE:
  {
    AV
      *av;

    ExceptionInfo
      *exception;

    ssize_t
      i;

    SV
      *perl_exception,
      *reference;

    struct PackageInfo
      *info;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    for (i=1; i &lt; items; i++)
      (void) RemoteDisplayCommand(info-&gt;image_info,(char *) NULL,(char *)
        SvPV(ST(i),na),exception);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);    /* throw away all errors */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   S e t                                                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Set(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    SetAttributes  = 1
    SetAttribute   = 2
    set            = 3
    setattributes  = 4
    setattribute   = 5
  PPCODE:
  {
    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (items == 2)
      SetAttribute(aTHX_ info,image,&quot;size&quot;,ST(1),exception);
    else
      for (i=2; i &lt; items; i+=2)
        SetAttribute(aTHX_ info,image,SvPV(ST(i-1),na),ST(i),exception);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) (SvCUR(perl_exception) != 0));
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   S e t P i x e l                                                           #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
SetPixel(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    setpixel = 1
    setPixel = 2
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ChannelType
      channel,
      channel_mask;

    ExceptionInfo
      *exception;

    Image
      *image;

    MagickBooleanType
      normalize;

    Quantum
      *q;

    RectangleInfo
      region;

    ssize_t
      i,
      option;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    av=(AV *) NULL;
    normalize=MagickTrue;
    region.x=0;
    region.y=0;
    region.width=image-&gt;columns;
    region.height=1;
    if (items == 1)
      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&amp;region);
    channel=DefaultChannels;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;channel&quot;) == 0)
            {
              ssize_t
                option;

              option=ParseChannelOption(SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  return;
                }
              channel=(ChannelType) option;
              break;
            }
          if (LocaleCompare(attribute,&quot;color&quot;) == 0)
            {
              if (SvTYPE(ST(i)) != SVt_RV)
                {
                  char
                    message[MagickPathExtent];

                  (void) FormatLocaleString(message,MagickPathExtent,
                    &quot;invalid %.60s value&quot;,attribute);
                  ThrowPerlException(exception,OptionError,message,
                    SvPV(ST(i),na));
                }
              av=(AV *) SvRV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&amp;region);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;N&#039;:
        case &#039;n&#039;:
        {
          if (LocaleCompare(attribute,&quot;normalize&quot;) == 0)
            {
              option=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  break;
                }
             normalize=option != 0 ? MagickTrue : MagickFalse;
             break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;x&#039;:
        case &#039;X&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              region.x=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;y&#039;:
        case &#039;Y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              region.y=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    (void) SetImageStorageClass(image,DirectClass,exception);
    channel_mask=SetImageChannelMask(image,channel);
    q=GetAuthenticPixels(image,region.x,region.y,1,1,exception);
    if ((q == (Quantum *) NULL) || (av == (AV *) NULL) ||
        (SvTYPE(av) != SVt_PVAV))
      PUSHs(&amp;sv_undef);
    else
      {
        double
          scale;

        ssize_t
          i;

        i=0;
        scale=1.0;
        if (normalize != MagickFalse)
          scale=QuantumRange;
        if (((GetPixelRedTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
            (i &lt;= av_len(av)))
          {
            SetPixelRed(image,ClampToQuantum(scale*SvNV(*(
              av_fetch(av,i,0)))),q);
            i++;
          }
        if (((GetPixelGreenTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
            (i &lt;= av_len(av)))
          {
            SetPixelGreen(image,ClampToQuantum(scale*SvNV(*(
              av_fetch(av,i,0)))),q);
            i++;
          }
        if (((GetPixelBlueTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
            (i &lt;= av_len(av)))
          {
            SetPixelBlue(image,ClampToQuantum(scale*SvNV(*(
              av_fetch(av,i,0)))),q);
            i++;
          }
        if ((((GetPixelBlackTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
            (image-&gt;colorspace == CMYKColorspace)) &amp;&amp; (i &lt;= av_len(av)))
          {
            SetPixelBlack(image,ClampToQuantum(scale*
              SvNV(*(av_fetch(av,i,0)))),q);
            i++;
          }
        if (((GetPixelAlphaTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
            (i &lt;= av_len(av)))
          {
            SetPixelAlpha(image,ClampToQuantum(scale*
              SvNV(*(av_fetch(av,i,0)))),q);
            i++;
          }
        (void) SyncAuthenticPixels(image,exception);
      }
    (void) SetImageChannelMask(image,channel_mask);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   S e t P i x e l s                                                         #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
SetPixels(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    setpixels = 1
    setPixels = 2
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ChannelType
      channel,
      channel_mask;

    ExceptionInfo
      *exception;

    Image
      *image;

    Quantum
      *q;

    RectangleInfo
      region;

    ssize_t
      i;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;  /* reference is the SV* of ref=SvIV(reference) */

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    reference=SvRV(ST(0));
    av=(AV *) reference;
    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
      exception);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    av=(AV *) NULL;
    region.x=0;
    region.y=0;
    region.width=image-&gt;columns;
    region.height=1;
    if (items == 1)
      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&amp;region);
    channel=DefaultChannels;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;C&#039;:
        case &#039;c&#039;:
        {
          if (LocaleCompare(attribute,&quot;channel&quot;) == 0)
            {
              ssize_t
                option;

              option=ParseChannelOption(SvPV(ST(i),na));
              if (option &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  return;
                }
              channel=(ChannelType) option;
              break;
            }
          if (LocaleCompare(attribute,&quot;color&quot;) == 0)
            {
              if (SvTYPE(ST(i)) != SVt_RV)
                {
                  char
                    message[MagickPathExtent];

                  (void) FormatLocaleString(message,MagickPathExtent,
                    &quot;invalid %.60s value&quot;,attribute);
                  ThrowPerlException(exception,OptionError,message,
                    SvPV(ST(i),na));
                }
              av=(AV *) SvRV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;g&#039;:
        case &#039;G&#039;:
        {
          if (LocaleCompare(attribute,&quot;geometry&quot;) == 0)
            {
              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&amp;region);
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;h&#039;:
        case &#039;H&#039;:
        {
          if (LocaleCompare(attribute,&quot;height&quot;) == 0)
            {
              region.height=(size_t) SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;w&#039;:
        case &#039;W&#039;:
        {
          if (LocaleCompare(attribute,&quot;width&quot;) == 0)
            {
              region.width=(size_t) SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;x&#039;:
        case &#039;X&#039;:
        {
          if (LocaleCompare(attribute,&quot;x&quot;) == 0)
            {
              region.x=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;y&#039;:
        case &#039;Y&#039;:
        {
          if (LocaleCompare(attribute,&quot;y&quot;) == 0)
            {
              region.y=SvIV(ST(i));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    (void) SetImageStorageClass(image,DirectClass,exception);
    channel_mask=SetImageChannelMask(image,channel);
    q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
      exception);
    if ((q == (Quantum *) NULL) || (av == (AV *) NULL) ||
        (SvTYPE(av) != SVt_PVAV))
      PUSHs(&amp;sv_undef);
    else
      {
        double
          scale;

        ssize_t
          i,
          n,
          number_pixels;

        i=0;
        n=0;
        scale=(double) QuantumRange;
        number_pixels=(ssize_t) (region.width*region.height);
        while ((n &lt; number_pixels) &amp;&amp; (i &lt; av_len(av)))
        {
          if (((GetPixelRedTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
              (i &lt;= av_len(av)))
            {
              SetPixelRed(image,ClampToQuantum(scale*SvNV(*(
                av_fetch(av,i,0)))),q);
              i++;
            }
          if (((GetPixelGreenTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
              (i &lt;= av_len(av)))
            {
              SetPixelGreen(image,ClampToQuantum(scale*SvNV(*(
                av_fetch(av,i,0)))),q);
              i++;
            }
          if (((GetPixelBlueTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
              (i &lt;= av_len(av)))
            {
              SetPixelBlue(image,ClampToQuantum(scale*SvNV(*(
                av_fetch(av,i,0)))),q);
              i++;
            }
          if ((((GetPixelBlackTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
              (image-&gt;colorspace == CMYKColorspace)) &amp;&amp; (i &lt;= av_len(av)))
            {
             SetPixelBlack(image,ClampToQuantum(scale*
                SvNV(*(av_fetch(av,i,0)))),q);
              i++;
            }
          if (((GetPixelAlphaTraits(image) &amp; UpdatePixelTrait) != 0) &amp;&amp;
              (i &lt;= av_len(av)))
            {
              SetPixelAlpha(image,ClampToQuantum(scale*
                SvNV(*(av_fetch(av,i,0)))),q);
              i++;
            }
         	n++;
         	q+=image-&gt;number_channels;
        }
        (void) SyncAuthenticPixels(image,exception);
      }
    (void) SetImageChannelMask(image,channel_mask);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   S m u s h                                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Smush(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    SmushImage  = 1
    smush       = 2
    smushimage  = 3
  PPCODE:
  {
    AV
      *av;

    char
      *attribute;

    ExceptionInfo
      *exception;

    HV
      *hv;

    Image
      *image;

    ssize_t
      i,
      offset,
      stack;

    struct PackageInfo
      *info;

    SV
      *av_reference,
      *perl_exception,
      *reference,
      *rv,
      *sv;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    sv=NULL;
    attribute=NULL;
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    hv=SvSTASH(reference);
    av=newAV();
    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
    /*
      Get options.
    */
    offset=0;
    stack=MagickTrue;
    for (i=2; i &lt; items; i+=2)
    {
      attribute=(char *) SvPV(ST(i-1),na);
      switch (*attribute)
      {
        case &#039;O&#039;:
        case &#039;o&#039;:
        {
          if (LocaleCompare(attribute,&quot;offset&quot;) == 0)
            {
              offset=(ssize_t) StringToLong((char *) SvPV(ST(1),na));
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        case &#039;S&#039;:
        case &#039;s&#039;:
        {
          if (LocaleCompare(attribute,&quot;stack&quot;) == 0)
            {
              stack=ParseCommandOption(MagickBooleanOptions,MagickFalse,
                SvPV(ST(i),na));
              if (stack &lt; 0)
                {
                  ThrowPerlException(exception,OptionError,&quot;UnrecognizedType&quot;,
                    SvPV(ST(i),na));
                  return;
                }
              break;
            }
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
        default:
        {
          ThrowPerlException(exception,OptionError,&quot;UnrecognizedAttribute&quot;,
            attribute);
          break;
        }
      }
    }
    image=SmushImages(image,stack != 0 ? MagickTrue : MagickFalse,offset,
      exception);
    if (image == (Image *) NULL)
      goto PerlException;
    for ( ; image; image=image-&gt;next)
    {
      AddImageToRegistry(sv,image);
      rv=newRV(sv);
      av_push(av,sv_bless(rv,hv));
      SvREFCNT_dec(sv);
    }
    exception=DestroyExceptionInfo(exception);
    ST(0)=av_reference;
    SvREFCNT_dec(perl_exception);
    XSRETURN(1);

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   S t a t i s t i c s                                                       #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Statistics(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    StatisticsImage = 1
    statistics      = 2
    statisticsimage = 3
  PPCODE:
  {
#define ChannelStatistics(channel) \
{ \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    (double) channel_statistics[channel].depth); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].minima/QuantumRange); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].maxima/QuantumRange); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].mean/QuantumRange); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].standard_deviation/QuantumRange); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].kurtosis); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].skewness); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
  (void) FormatLocaleString(message,MagickPathExtent,&quot;%.17g&quot;, \
    channel_statistics[channel].entropy); \
  PUSHs(sv_2mortal(newSVpv(message,0))); \
}

    AV
      *av;

    char
      message[MagickPathExtent];

    ChannelStatistics
      *channel_statistics;

    ExceptionInfo
      *exception;

    Image
      *image;

    ssize_t
      count;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    av=NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    av=newAV();
    SvREFCNT_dec(av);
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    count=0;
    for ( ; image; image=image-&gt;next)
    {
      ssize_t
        i;

      channel_statistics=GetImageStatistics(image,exception);
      if (channel_statistics == (ChannelStatistics *) NULL)
        continue;
      count++;
      for (i=0; i &lt; (ssize_t) GetPixelChannels(image); i++)
      {
        PixelChannel channel=GetPixelChannelChannel(image,i);
        PixelTrait traits=GetPixelChannelTraits(image,channel);
        if (traits == UndefinedPixelTrait)
          continue;
        EXTEND(sp,8*(i+1)*count);
        ChannelStatistics(channel);
      }
      EXTEND(sp,8*(i+1)*count);
      ChannelStatistics(CompositePixelChannel);
      channel_statistics=(ChannelStatistics *)
        RelinquishMagickMemory(channel_statistics);
    }

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   S y n c A u t h e n t i c P i x e l s                                     #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
SyncAuthenticPixels(ref,...)
  Image::Magick ref = NO_INIT
  ALIAS:
    Syncauthenticpixels = 1
    SyncImagePixels = 2
    syncimagepixels = 3
  CODE:
  {
    ExceptionInfo
      *exception;

    Image
      *image;

    MagickBooleanType
      status;

    struct PackageInfo
      *info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }

    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }

    status=SyncAuthenticPixels(image,exception);
    if (status != MagickFalse)
      return;

  PerlException:
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    SvREFCNT_dec(perl_exception);  /* throw away all errors */
  }

#
###############################################################################
#                                                                             #
#                                                                             #
#                                                                             #
#   W r i t e                                                                 #
#                                                                             #
#                                                                             #
#                                                                             #
###############################################################################
#
#
void
Write(ref,...)
  Image::Magick ref=NO_INIT
  ALIAS:
    WriteImage    = 1
    write         = 2
    writeimage    = 3
  PPCODE:
  {
    char
      filename[MagickPathExtent];

    ExceptionInfo
      *exception;

    Image
      *image,
      *next;

    ssize_t
      i,
      number_images,
      scene;

    struct PackageInfo
      *info,
      *package_info;

    SV
      *perl_exception,
      *reference;

    PERL_UNUSED_VAR(ref);
    PERL_UNUSED_VAR(ix);
    exception=AcquireExceptionInfo();
    perl_exception=newSVpv(&quot;&quot;,0);
    number_images=0;
    package_info=(struct PackageInfo *) NULL;
    if (sv_isobject(ST(0)) == 0)
      {
        ThrowPerlException(exception,OptionError,&quot;ReferenceIsNotMyType&quot;,
          PackageName);
        goto PerlException;
      }
    reference=SvRV(ST(0));
    image=SetupList(aTHX_ reference,&amp;info,(SV ***) NULL,exception);
    if (image == (Image *) NULL)
      {
        ThrowPerlException(exception,OptionError,&quot;NoImagesDefined&quot;,
          PackageName);
        goto PerlException;
      }
    scene=0;
    for (next=image; next; next=next-&gt;next)
      next-&gt;scene=(size_t) scene++;
    package_info=ClonePackageInfo(info,exception);
    if (items == 2)
      SetAttribute(aTHX_ package_info,NULL,&quot;filename&quot;,ST(1),exception);
    else
      if (items &gt; 2)
        for (i=2; i &lt; items; i+=2)
          SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),
            exception);
    (void) CopyMagickString(filename,package_info-&gt;image_info-&gt;filename,
      MagickPathExtent);
    for (next=image; next; next=next-&gt;next)
      (void) CopyMagickString(next-&gt;filename,filename,MagickPathExtent);
    *package_info-&gt;image_info-&gt;magick=&#039;\0&#039;;
    SetImageInfo(package_info-&gt;image_info,(unsigned int)
      GetImageListLength(image),exception);
    for (next=image; next; next=next-&gt;next)
    {
      (void) WriteImage(package_info-&gt;image_info,next,exception);
      number_images++;
      if (package_info-&gt;image_info-&gt;adjoin)
        break;
    }

  PerlException:
    if (package_info != (struct PackageInfo *) NULL)
      DestroyPackageInfo(package_info);
    InheritPerlException(exception,perl_exception);
    exception=DestroyExceptionInfo(exception);
    sv_setiv(perl_exception,(IV) number_images);
    SvPOK_on(perl_exception);
    ST(0)=sv_2mortal(perl_exception);
    XSRETURN(1);
  }
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2FPerlMagick'>🔙 Back</a></p>