perlmagick.patch

   1 diff -urN ImageMagick-6.9.7-0/PerlMagick/Magick.pm ImageMagick-6.9.6-6/PerlMagick/Magick.pm
   2 --- ImageMagick-6.9.7-0/PerlMagick/Magick.pm    1970-01-01 01:00:00.000000000 +0100
   3 +++ ImageMagick-6.9.6-6/PerlMagick/Magick.pm    2016-11-25 16:58:55.000000000 +0100
   4 @@ -0,0 +1,144 @@
   5 +package Image::Magick;
   6 +
   7 +#  Copyright 1999-2016 ImageMagick Studio LLC, a non-profit organization
   8 +#  dedicated to making software imaging solutions freely available.
   9 +#
  10 +#  You may not use this file except in compliance with the License.  You may
  11 +#  obtain a copy of the License at
  12 +#
  13 +#    http://www.imagemagick.org/script/license.php
  14 +#
  15 +#  Unless required by applicable law or agreed to in writing, software
  16 +#  distributed under the License is distributed on an "AS IS" BASIS,
  17 +#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18 +#  See the License for the specific language governing permissions and
  19 +#  limitations under the License.
  20 +#
  21 +#  Initial version, written by Kyle Shorter.
  22 +
  23 +use strict;
  24 +use Carp;
  25 +use vars qw($VERSION @ISA @EXPORT $AUTOLOAD);
  26 +
  27 +require 5.002;
  28 +require Exporter;
  29 +require DynaLoader;
  30 +require AutoLoader;
  31 +
  32 +@ISA = qw(Exporter DynaLoader);
  33 +# Items to export into callers namespace by default. Note: do not export
  34 +# names by default without a very good reason. Use EXPORT_OK instead.
  35 +# Do not simply export all your public functions/methods/constants.
  36 +@EXPORT =
  37 +  qw(
  38 +      Success Transparent Opaque QuantumDepth QuantumRange MaxRGB
  39 +      WarningException ResourceLimitWarning TypeWarning OptionWarning
  40 +      DelegateWarning MissingDelegateWarning CorruptImageWarning
  41 +      FileOpenWarning BlobWarning StreamWarning CacheWarning CoderWarning
  42 +      ModuleWarning DrawWarning ImageWarning XServerWarning RegistryWarning
  43 +      ConfigureWarning ErrorException ResourceLimitError TypeError
  44 +      OptionError DelegateError MissingDelegateError CorruptImageError
  45 +      FileOpenError BlobError StreamError CacheError CoderError
  46 +      ModuleError DrawError ImageError XServerError RegistryError
  47 +      ConfigureError FatalErrorException
  48 +    );
  49 +
  50 +$VERSION = '6.96';
  51 +
  52 +sub AUTOLOAD {
  53 +    # This AUTOLOAD is used to 'autoload' constants from the constant()
  54 +    # XS function.  If a constant is not found then control is passed
  55 +    # to the AUTOLOAD in AutoLoader.
  56 +
  57 +    my $constname;
  58 +    ($constname = $AUTOLOAD) =~ s/.*:://;
  59 +    die "&${AUTOLOAD} not defined. The required ImageMagick libraries are not installed or not installed properly.\n" if $constname eq 'constant';
  60 +    my $val = constant($constname, @_ ? $_[0] : 0);
  61 +    if ($! != 0) {
  62 +       if ($! =~ /Invalid/) {
  63 +               $AutoLoader::AUTOLOAD = $AUTOLOAD;
  64 +               goto &AutoLoader::AUTOLOAD;
  65 +       }
  66 +       else {
  67 +               my($pack,$file,$line) = caller;
  68 +               die "Your vendor has not defined PerlMagick macro $pack\:\:$constname, used at $file line $line.\n";
  69 +       }
  70 +    }
  71 +    eval "sub $AUTOLOAD { $val }";
  72 +    goto &$AUTOLOAD;
  73 +}
  74 +
  75 +bootstrap Image::Magick $VERSION;
  76 +
  77 +# Preloaded methods go here.
  78 +
  79 +sub new
  80 +{
  81 +    my $this = shift;
  82 +    my $class = ref($this) || $this || "Image::Magick";
  83 +    my $self = [ ];
  84 +    bless $self, $class;
  85 +    $self->set(@_) if @_;
  86 +    return $self;
  87 +}
  88 +
  89 +sub New
  90 +{
  91 +    my $this = shift;
  92 +    my $class = ref($this) || $this || "Image::Magick";
  93 +    my $self = [ ];
  94 +    bless $self, $class;
  95 +    $self->set(@_) if @_;
  96 +    return $self;
  97 +}
  98 +
  99 +# Autoload methods go after =cut, and are processed by the autosplit program.
 100 +
 101 +END { UNLOAD () };
 102 +
 103 +1;
 104 +__END__
 105 +
 106 +=head1 NAME
 107 +
 108 +Image::Magick - objected-oriented Perl interface to ImageMagick. Use it to create, edit, compose, or convert bitmap images from within a Perl script.
 109 +
 110 +=head1 SYNOPSIS
 111 +
 112 +  use Image::Magick;
 113 +  $p = new Image::Magick;
 114 +  $p->Read("imagefile");
 115 +  $p->Set(attribute => value, ...)
 116 +  ($a, ...) = $p->Get("attribute", ...)
 117 +  $p->routine(parameter => value, ...)
 118 +  $p->Mogrify("Routine", parameter => value, ...)
 119 +  $p->Write("filename");
 120 +
 121 +=head1 DESCRIPTION
 122 +
 123 +This Perl extension allows the reading, manipulation and writing of
 124 +a large number of image file formats using the ImageMagick library.
 125 +It was originally developed to be used by CGI scripts for Web pages.
 126 +
 127 +A web page has been set up for this extension. See:
 128 +
 129 +        file:///usr/share/doc/ImageMagick-6.8.0/www/perl-magick.html
 130 +        http://www.imagemagick.org/script/perl-magick.php
 131 +
 132 +If you have problems, go to
 133 +
 134 +   http://www.imagemagick.org/discourse-server/viewforum.php?f=7
 135 +
 136 +=head1 AUTHOR
 137 +
 138 +Kyle Shorter   magick-users@imagemagick.org
 139 +
 140 +=head1 BUGS
 141 +
 142 +Has all the bugs of ImageMagick and much, much more!
 143 +
 144 +=head1 SEE ALSO
 145 +
 146 +perl(1).
 147 +
 148 +=cut
 149 diff -urN ImageMagick-6.9.7-0/PerlMagick/Magick.xs ImageMagick-6.9.6-6/PerlMagick/Magick.xs
 150 --- ImageMagick-6.9.7-0/PerlMagick/Magick.xs    1970-01-01 01:00:00.000000000 +0100
 151 +++ ImageMagick-6.9.6-6/PerlMagick/Magick.xs    2016-11-25 16:58:55.000000000 +0100
 152 @@ -0,0 +1,14450 @@
 153 +/*
 154 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 155 +%                                                                             %
 156 +%                                                                             %
 157 +%                         PPPP   EEEEE  RRRR   L                              %
 158 +%                         P   P  E      R   R  L                              %
 159 +%                         PPPP   EEE    RRRR   L                              %
 160 +%                         P      E      R  R   L                              %
 161 +%                         P      EEEEE  R   R  LLLLL                          %
 162 +%                                                                             %
 163 +%                  M   M   AAA    GGGG  IIIII   CCCC  K   K                   %
 164 +%                  MM MM  A   A  G        I    C      K  K                    %
 165 +%                  M M M  AAAAA  G GGG    I    C      KKK                     %
 166 +%                  M   M  A   A  G   G    I    C      K  K                    %
 167 +%                  M   M  A   A   GGGG  IIIII   CCCC  K   K                   %
 168 +%                                                                             %
 169 +%                                                                             %
 170 +%                Object-oriented Perl interface to ImageMagick                %
 171 +%                                                                             %
 172 +%                            Software Design                                  %
 173 +%                              Kyle Shorter                                   %
 174 +%                                 Cristy                                      %
 175 +%                             February 1997                                   %
 176 +%                                                                             %
 177 +%                                                                             %
 178 +%  Copyright 1999-2016 ImageMagick Studio LLC, a non-profit organization      %
 179 +%  dedicated to making software imaging solutions freely available.           %
 180 +%                                                                             %
 181 +%  You may not use this file except in compliance with the License.  You may  %
 182 +%  obtain a copy of the License at                                            %
 183 +%                                                                             %
 184 +%    http://www.imagemagick.org/script/license.php                            %
 185 +%                                                                             %
 186 +%  Unless required by applicable law or agreed to in writing, software        %
 187 +%  distributed under the License is distributed on an "AS IS" BASIS,          %
 188 +%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
 189 +%  See the License for the specific language governing permissions and        %
 190 +%  limitations under the License.                                             %
 191 +%                                                                             %
 192 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 193 +%
 194 +%  PerlMagick is an objected-oriented Perl interface to ImageMagick.  Use
 195 +%  the module to read, manipulate, or write an image or image sequence from
 196 +%  within a Perl script.  This makes PerlMagick suitable for Web CGI scripts.
 197 +%
 198 +*/
 199 +\f
 200 +/*
 201 +  Include declarations.
 202 +*/
 203 +#if defined(__cplusplus) || defined(c_plusplus)
 204 +extern "C" {
 205 +#endif
 206 +
 207 +#define PERL_NO_GET_CONTEXT
 208 +#include "EXTERN.h"
 209 +#include "perl.h"
 210 +#include "XSUB.h"
 211 +#include <math.h>
 212 +#include <magick/MagickCore.h>
 213 +#undef tainted
 214 +
 215 +#if defined(__cplusplus) || defined(c_plusplus)
 216 +}
 217 +#endif
 218 +\f
 219 +/*
 220 +  Define declarations.
 221 +*/
 222 +#ifndef aTHX_
 223 +#define aTHX_
 224 +#define pTHX_
 225 +#define dTHX
 226 +#endif
 227 +#define DegreesToRadians(x)  (MagickPI*(x)/180.0)
 228 +#define EndOf(array)  (&array[NumberOf(array)])
 229 +#define MagickPI  3.14159265358979323846264338327950288419716939937510
 230 +#define MaxArguments  33
 231 +#ifndef na
 232 +#define na  PL_na
 233 +#endif
 234 +#define NumberOf(array)  (sizeof(array)/sizeof(*array))
 235 +#define PackageName   "Image::Magick"
 236 +#if PERL_VERSION <= 6
 237 +#define PerlIO  FILE
 238 +#define PerlIO_importFILE(f, fl)  (f)
 239 +#define PerlIO_findFILE(f)  NULL
 240 +#endif
 241 +#ifndef sv_undef
 242 +#define sv_undef  PL_sv_undef
 243 +#endif
 244 +
 245 +#define AddImageToRegistry(sv,image) \
 246 +{ \
 247 +  if (magick_registry != (SplayTreeInfo *) NULL) \
 248 +    { \
 249 +      (void) AddValueToSplayTree(magick_registry,image,image); \
 250 +      (sv)=newSViv(PTR2IV(image)); \
 251 +    } \
 252 +}
 253 +
 254 +#define DeleteImageFromRegistry(reference,image) \
 255 +{ \
 256 +  if (magick_registry != (SplayTreeInfo *) NULL) \
 257 +    { \
 258 +      if (GetImageReferenceCount(image) == 1) \
 259 +       (void) DeleteNodeByValueFromSplayTree(magick_registry,image); \
 260 +      image=DestroyImage(image); \
 261 +      sv_setiv(reference,0); \
 262 +    } \
 263 +}
 264 +
 265 +#define InheritPerlException(exception,perl_exception) \
 266 +{ \
 267 +  char \
 268 +    message[MaxTextExtent]; \
 269 + \
 270 +  if ((exception)->severity != UndefinedException) \
 271 +    { \
 272 +      (void) FormatLocaleString(message,MaxTextExtent,"Exception %d: %s%s%s%s",\
 273 +        (exception)->severity, (exception)->reason ? \
 274 +        GetLocaleExceptionMessage((exception)->severity,(exception)->reason) : \
 275 +        "Unknown", (exception)->description ? " (" : "", \
 276 +        (exception)->description ? GetLocaleExceptionMessage( \
 277 +        (exception)->severity,(exception)->description) : "", \
 278 +        (exception)->description ? ")" : ""); \
 279 +      if ((perl_exception) != (SV *) NULL) \
 280 +        { \
 281 +          if (SvCUR(perl_exception)) \
 282 +            sv_catpv(perl_exception,"\n"); \
 283 +          sv_catpv(perl_exception,message); \
 284 +        } \
 285 +    } \
 286 +}
 287 +
 288 +#define ThrowPerlException(exception,severity,tag,reason) \
 289 +  (void) ThrowMagickException(exception,GetMagickModule(),severity, \
 290 +    tag,"`%s'",reason); \
 291 +\f
 292 +/*
 293 +  Typedef and structure declarations.
 294 +*/
 295 +typedef enum
 296 +{
 297 +  ArrayReference = (~0),
 298 +  RealReference = (~0)-1,
 299 +  FileReference = (~0)-2,
 300 +  ImageReference = (~0)-3,
 301 +  IntegerReference = (~0)-4,
 302 +  StringReference = (~0)-5
 303 +} MagickReference;
 304 +
 305 +typedef struct _Arguments
 306 +{
 307 +  const char
 308 +    *method;
 309 +
 310 +  ssize_t
 311 +    type;
 312 +} Arguments;
 313 +
 314 +struct ArgumentList
 315 +{
 316 +  ssize_t
 317 +    integer_reference;
 318 +
 319 +  MagickRealType
 320 +    real_reference;
 321 +
 322 +  const char
 323 +    *string_reference;
 324 +
 325 +  Image
 326 +    *image_reference;
 327 +
 328 +  SV
 329 +    *array_reference;
 330 +
 331 +  FILE
 332 +    *file_reference;
 333 +
 334 +  size_t
 335 +    length;
 336 +};
 337 +
 338 +struct PackageInfo
 339 +{
 340 +  ImageInfo
 341 +    *image_info;
 342 +};
 343 +
 344 +typedef void
 345 +  *Image__Magick;  /* data type for the Image::Magick package */
 346 +\f
 347 +/*
 348 +  Static declarations.
 349 +*/
 350 +static struct
 351 +  Methods
 352 +  {
 353 +    const char
 354 +      *name;
 355 +
 356 +    Arguments
 357 +      arguments[MaxArguments];
 358 +  } Methods[] =
 359 +  {
 360 +    { "Comment", { {"comment", StringReference} } },
 361 +    { "Label", { {"label", StringReference} } },
 362 +    { "AddNoise", { {"noise", MagickNoiseOptions},
 363 +      {"channel", MagickChannelOptions} } },
 364 +    { "Colorize", { {"fill", StringReference}, {"opacity", StringReference} } },
 365 +    { "Border", { {"geometry", StringReference}, {"width", IntegerReference},
 366 +      {"height", IntegerReference}, {"fill", StringReference},
 367 +      {"bordercolor", StringReference}, {"color", StringReference},
 368 +      {"compose", MagickComposeOptions} } },
 369 +    { "Blur", { {"geometry", StringReference}, {"radius", RealReference},
 370 +      {"sigma", RealReference}, {"channel", MagickChannelOptions} } },
 371 +    { "Chop", { {"geometry", StringReference}, {"width", IntegerReference},
 372 +      {"height", IntegerReference}, {"x", IntegerReference},
 373 +      {"y", IntegerReference}, {"gravity", MagickGravityOptions} } },
 374 +    { "Crop", { {"geometry", StringReference}, {"width", IntegerReference},
 375 +      {"height", IntegerReference}, {"x", IntegerReference},
 376 +      {"y", IntegerReference}, {"fuzz", StringReference},
 377 +      {"gravity", MagickGravityOptions} } },
 378 +    { "Despeckle", },
 379 +    { "Edge", { {"radius", RealReference} } },
 380 +    { "Emboss", { {"geometry", StringReference}, {"radius", RealReference},
 381 +      {"sigma", RealReference} } },
 382 +    { "Enhance", },
 383 +    { "Flip", },
 384 +    { "Flop", },
 385 +    { "Frame", { {"geometry", StringReference}, {"width", IntegerReference},
 386 +      {"height", IntegerReference}, {"inner", IntegerReference},
 387 +      {"outer", IntegerReference}, {"fill", StringReference},
 388 +      {"color", StringReference}, {"compose", MagickComposeOptions} } },
 389 +    { "Implode", { {"amount", RealReference},
 390 +      {"interpolate", MagickInterpolateOptions} } },
 391 +    { "Magnify", },
 392 +    { "MedianFilter", { {"geometry", StringReference},
 393 +      {"width", IntegerReference},{"height", IntegerReference},
 394 +      {"channel", MagickChannelOptions} } },
 395 +    { "Minify", },
 396 +    { "OilPaint", { {"radius", RealReference} } },
 397 +    { "ReduceNoise", { {"geometry", StringReference},
 398 +      {"width", IntegerReference},{"height", IntegerReference},
 399 +      {"channel", MagickChannelOptions} } },
 400 +    { "Roll", { {"geometry", StringReference}, {"x", IntegerReference},
 401 +      {"y", IntegerReference} } },
 402 +    { "Rotate", { {"degrees", RealReference}, {"fill", StringReference},
 403 +      {"color", StringReference}, {"background", StringReference} } },
 404 +    { "Sample", { {"geometry", StringReference}, {"width", IntegerReference},
 405 +      {"height", IntegerReference} } },
 406 +    { "Scale", { {"geometry", StringReference}, {"width", IntegerReference},
 407 +      {"height", IntegerReference} } },
 408 +    { "Shade", { {"geometry", StringReference}, {"azimuth", RealReference},
 409 +      {"elevation", RealReference}, {"gray", MagickBooleanOptions} } },
 410 +    { "Sharpen", { {"geometry", StringReference}, {"radius", RealReference},
 411 +      {"sigma", RealReference}, {"channel", MagickChannelOptions} } },
 412 +    { "Shear", { {"geometry", StringReference}, {"x", RealReference},
 413 +      {"y", RealReference}, { "fill", StringReference},
 414 +      {"color", StringReference} } },
 415 +    { "Spread", { {"radius", RealReference},
 416 +      {"interpolate", MagickInterpolateOptions} } },
 417 +    { "Swirl", { {"degrees", RealReference},
 418 +      {"interpolate", MagickInterpolateOptions} } },
 419 +    { "Resize", { {"geometry", StringReference}, {"width", IntegerReference},
 420 +      {"height", IntegerReference}, {"filter", MagickFilterOptions},
 421 +      {"support", StringReference }, {"blur", RealReference } } },
 422 +    { "Zoom", { {"geometry", StringReference}, {"width", IntegerReference},
 423 +      {"height", IntegerReference}, {"filter", MagickFilterOptions},
 424 +      {"support", RealReference }, {"blur", RealReference } } },
 425 +    { "Annotate", { {"text", StringReference}, {"font", StringReference},
 426 +      {"pointsize", RealReference}, {"density", StringReference},
 427 +      {"undercolor", StringReference}, {"stroke", StringReference},
 428 +      {"fill", StringReference}, {"geometry", StringReference},
 429 +      {"pen", StringReference}, {"x", RealReference},
 430 +      {"y", RealReference}, {"gravity", MagickGravityOptions},
 431 +      {"translate", StringReference}, {"scale", StringReference},
 432 +      {"rotate", RealReference}, {"skewX", RealReference},
 433 +      {"skewY", RealReference}, {"strokewidth", RealReference},
 434 +      {"antialias", MagickBooleanOptions}, {"family", StringReference},
 435 +      {"style", MagickStyleOptions}, {"stretch", MagickStretchOptions},
 436 +      {"weight", IntegerReference}, {"align", MagickAlignOptions},
 437 +      {"encoding", StringReference}, {"affine", ArrayReference},
 438 +      {"fill-pattern", ImageReference}, {"stroke-pattern", ImageReference},
 439 +      {"tile", ImageReference}, {"kerning", RealReference},
 440 +      {"interline-spacing", RealReference},
 441 +      {"interword-spacing", RealReference},
 442 +      {"direction", MagickDirectionOptions} } },
 443 +    { "ColorFloodfill", { {"geometry", StringReference},
 444 +      {"x", IntegerReference}, {"y", IntegerReference},
 445 +      {"fill", StringReference}, {"bordercolor", StringReference},
 446 +      {"fuzz", StringReference}, {"invert", MagickBooleanOptions} } },
 447 +    { "Composite", { {"image", ImageReference},
 448 +      {"compose", MagickComposeOptions}, {"geometry", StringReference},
 449 +      {"x", IntegerReference}, {"y", IntegerReference},
 450 +      {"gravity", MagickGravityOptions}, {"opacity", StringReference},
 451 +      {"tile", MagickBooleanOptions}, {"rotate", RealReference},
 452 +      {"color", StringReference}, {"mask", ImageReference},
 453 +      {"channel", MagickChannelOptions},
 454 +      {"interpolate", MagickInterpolateOptions}, {"args", StringReference},
 455 +      {"blend", StringReference} } },
 456 +    { "Contrast", { {"sharpen", MagickBooleanOptions} } },
 457 +    { "CycleColormap", { {"display", IntegerReference} } },
 458 +    { "Draw", { {"primitive", MagickPrimitiveOptions},
 459 +      {"points", StringReference}, {"method", MagickMethodOptions},
 460 +      {"stroke", StringReference}, {"fill", StringReference},
 461 +      {"strokewidth", RealReference}, {"font", StringReference},
 462 +      {"bordercolor", StringReference}, {"x", RealReference},
 463 +      {"y", RealReference}, {"translate", StringReference},
 464 +      {"scale", StringReference}, {"rotate", RealReference},
 465 +      {"skewX", RealReference}, {"skewY", RealReference},
 466 +      {"tile", ImageReference}, {"pointsize", RealReference},
 467 +      {"antialias", MagickBooleanOptions}, {"density", StringReference},
 468 +      {"linewidth", RealReference}, {"affine", ArrayReference},
 469 +      {"stroke-dashoffset", RealReference},
 470 +      {"stroke-dasharray", ArrayReference},
 471 +      {"interpolate", MagickInterpolateOptions},
 472 +      {"origin", StringReference}, {"text", StringReference},
 473 +      {"fill-pattern", ImageReference}, {"stroke-pattern", ImageReference},
 474 +      {"vector-graphics", StringReference}, {"kerning", RealReference},
 475 +      {"interline-spacing", RealReference},
 476 +      {"interword-spacing", RealReference},
 477 +      {"direction", MagickDirectionOptions} } },
 478 +    { "Equalize", { {"channel", MagickChannelOptions} } },
 479 +    { "Gamma", { {"gamma", StringReference}, {"channel", MagickChannelOptions},
 480 +      {"red", RealReference}, {"green", RealReference},
 481 +      {"blue", RealReference} } },
 482 +    { "Map", { {"image", ImageReference}, {"dither", MagickBooleanOptions},
 483 +      {"dither-method", MagickDitherOptions} } },
 484 +    { "MatteFloodfill", { {"geometry", StringReference},
 485 +      {"x", IntegerReference}, {"y", IntegerReference},
 486 +      {"opacity", StringReference}, {"bordercolor", StringReference},
 487 +      {"fuzz", StringReference}, {"invert", MagickBooleanOptions} } },
 488 +    { "Modulate", { {"factor", StringReference}, {"hue", RealReference},
 489 +      {"saturation", RealReference}, {"whiteness", RealReference},
 490 +      {"brightness", RealReference}, {"lightness", RealReference},
 491 +      {"blackness", RealReference} } },
 492 +    { "Negate", { {"gray", MagickBooleanOptions},
 493 +      {"channel", MagickChannelOptions} } },
 494 +    { "Normalize", { {"channel", MagickChannelOptions} } },
 495 +    { "NumberColors", },
 496 +    { "Opaque", { {"color", StringReference}, {"fill", StringReference},
 497 +      {"fuzz", StringReference}, {"channel", MagickChannelOptions},
 498 +      {"invert", MagickBooleanOptions} } },
 499 +    { "Quantize", { {"colors", IntegerReference},
 500 +      {"treedepth", IntegerReference}, {"colorspace", MagickColorspaceOptions},
 501 +      {"dither", MagickBooleanOptions}, {"measure", MagickBooleanOptions},
 502 +      {"global", MagickBooleanOptions}, {"transparent-color", StringReference},
 503 +      {"dither-method", MagickDitherOptions} } },
 504 +    { "Raise", { {"geometry", StringReference}, {"width", IntegerReference},
 505 +      {"height", IntegerReference}, {"raise", MagickBooleanOptions} } },
 506 +    { "Segment", { {"geometry", StringReference},
 507 +      {"cluster-threshold", RealReference},
 508 +      {"smoothing-threshold", RealReference},
 509 +      {"colorspace", MagickColorspaceOptions},
 510 +      {"verbose", MagickBooleanOptions} } },
 511 +    { "Signature", },
 512 +    { "Solarize", { {"geometry", StringReference},
 513 +      {"threshold", StringReference}, {"channel", MagickChannelOptions} } },
 514 +    { "Sync", },
 515 +    { "Texture", { {"texture", ImageReference} } },
 516 +    { "Evaluate", { {"value", RealReference},
 517 +      {"operator", MagickEvaluateOptions},
 518 +      {"channel", MagickChannelOptions} } },
 519 +    { "Transparent", { {"color", StringReference}, {"opacity", StringReference},
 520 +      {"fuzz", StringReference}, {"invert", MagickBooleanOptions} } },
 521 +    { "Threshold", { {"threshold", StringReference},
 522 +      {"channel", MagickChannelOptions} } },
 523 +    { "Charcoal", { {"geometry", StringReference}, {"radius", RealReference},
 524 +      {"sigma", RealReference} } },
 525 +    { "Trim", { {"fuzz", StringReference} } },
 526 +    { "Wave", { {"geometry", StringReference}, {"amplitude", RealReference},
 527 +      {"wavelength", RealReference},
 528 +      {"interpolate", MagickInterpolateOptions} } },
 529 +    { "Separate", { {"channel", MagickChannelOptions} } },
 530 +    { "Condense", },
 531 +    { "Stereo", { {"image", ImageReference}, {"x", IntegerReference},
 532 +      {"y", IntegerReference} } },
 533 +    { "Stegano", { {"image", ImageReference}, {"offset", IntegerReference} } },
 534 +    { "Deconstruct", },
 535 +    { "GaussianBlur", { {"geometry", StringReference},
 536 +      {"radius", RealReference}, {"sigma", RealReference},
 537 +      {"channel", MagickChannelOptions} } },
 538 +    { "Convolve", { {"coefficients", ArrayReference},
 539 +      {"channel", MagickChannelOptions}, {"bias", StringReference} } },
 540 +    { "Profile", { {"name", StringReference}, {"profile", StringReference},
 541 +      { "rendering-intent", MagickIntentOptions},
 542 +      { "black-point-compensation", MagickBooleanOptions} } },
 543 +    { "UnsharpMask", { {"geometry", StringReference},
 544 +      {"radius", RealReference}, {"sigma", RealReference},
 545 +      {"amount", RealReference}, {"threshold", RealReference},
 546 +      {"channel", MagickChannelOptions} } },
 547 +    { "MotionBlur", { {"geometry", StringReference},
 548 +      {"radius", RealReference}, {"sigma", RealReference},
 549 +      {"angle", RealReference}, {"channel", MagickChannelOptions} } },
 550 +    { "OrderedDither", { {"threshold", StringReference},
 551 +      {"channel", MagickChannelOptions} } },
 552 +    { "Shave", { {"geometry", StringReference}, {"width", IntegerReference},
 553 +      {"height", IntegerReference} } },
 554 +    { "Level", { {"levels", StringReference}, {"black-point", RealReference},
 555 +      {"white-point", RealReference}, {"gamma", RealReference},
 556 +      {"channel", MagickChannelOptions}, {"level", StringReference} } },
 557 +    { "Clip", { {"id", StringReference}, {"inside", MagickBooleanOptions} } },
 558 +    { "AffineTransform", { {"affine", ArrayReference},
 559 +      {"translate", StringReference}, {"scale", StringReference},
 560 +      {"rotate", RealReference}, {"skewX", RealReference},
 561 +      {"skewY", RealReference}, {"interpolate", MagickInterpolateOptions},
 562 +      {"background", StringReference} } },
 563 +    { "Difference", { {"image", ImageReference}, {"fuzz", StringReference} } },
 564 +    { "AdaptiveThreshold", { {"geometry", StringReference},
 565 +      {"width", IntegerReference}, {"height", IntegerReference},
 566 +      {"offset", IntegerReference} } },
 567 +    { "Resample", { {"density", StringReference}, {"x", RealReference},
 568 +      {"y", RealReference}, {"filter", MagickFilterOptions},
 569 +      {"support", RealReference }, {"blur", RealReference } } },
 570 +    { "Describe", { {"file", FileReference} } },
 571 +    { "BlackThreshold", { {"threshold", StringReference},
 572 +      {"channel", MagickChannelOptions} } },
 573 +    { "WhiteThreshold", { {"threshold", StringReference},
 574 +      {"channel", MagickChannelOptions} } },
 575 +    { "RotationalBlur", { {"geometry", StringReference},
 576 +      {"angle", RealReference}, {"channel", MagickChannelOptions} } },
 577 +    { "Thumbnail", { {"geometry", StringReference}, {"width", IntegerReference},
 578 +      {"height", IntegerReference} } },
 579 +    { "Strip", },
 580 +    { "Tint", { {"fill", StringReference}, {"opacity", StringReference} } },
 581 +    { "Channel", { {"channel", MagickChannelOptions} } },
 582 +    { "Splice", { {"geometry", StringReference}, {"width", IntegerReference},
 583 +      {"height", IntegerReference}, {"x", IntegerReference},
 584 +      {"y", IntegerReference}, {"fuzz", StringReference},
 585 +      {"background", StringReference}, {"gravity", MagickGravityOptions} } },
 586 +    { "Posterize", { {"levels", IntegerReference},
 587 +      {"dither", MagickBooleanOptions} } },
 588 +    { "Shadow", { {"geometry", StringReference}, {"opacity", RealReference},
 589 +      {"sigma", RealReference}, {"x", IntegerReference},
 590 +      {"y", IntegerReference} } },
 591 +    { "Identify", { {"file", FileReference}, {"features", StringReference},
 592 +      {"unique", MagickBooleanOptions} } },
 593 +    { "SepiaTone", { {"threshold", RealReference} } },
 594 +    { "SigmoidalContrast", { {"geometry", StringReference},
 595 +      {"contrast", RealReference}, {"mid-point", RealReference},
 596 +      {"channel", MagickChannelOptions}, {"sharpen", MagickBooleanOptions} } },
 597 +    { "Extent", { {"geometry", StringReference}, {"width", IntegerReference},
 598 +      {"height", IntegerReference}, {"x", IntegerReference},
 599 +      {"y", IntegerReference}, {"fuzz", StringReference},
 600 +      {"background", StringReference}, {"gravity", MagickGravityOptions} } },
 601 +    { "Vignette", { {"geometry", StringReference}, {"radius", RealReference},
 602 +      {"sigma", RealReference}, {"x", IntegerReference},
 603 +      {"y", IntegerReference}, {"background", StringReference} } },
 604 +    { "ContrastStretch", { {"levels", StringReference},
 605 +      {"black-point", RealReference},{"white-point", RealReference},
 606 +      {"channel", MagickChannelOptions} } },
 607 +    { "Sans0", },
 608 +    { "Sans1", },
 609 +    { "AdaptiveSharpen", { {"geometry", StringReference},
 610 +      {"radius", RealReference}, {"sigma", RealReference},
 611 +      {"channel", MagickChannelOptions} } },
 612 +    { "Transpose", },
 613 +    { "Transverse", },
 614 +    { "AutoOrient", },
 615 +    { "AdaptiveBlur", { {"geometry", StringReference},
 616 +      {"radius", RealReference}, {"sigma", RealReference},
 617 +      {"channel", MagickChannelOptions} } },
 618 +    { "Sketch", { {"geometry", StringReference},
 619 +      {"radius", RealReference}, {"sigma", RealReference},
 620 +      {"angle", RealReference} } },
 621 +    { "UniqueColors", },
 622 +    { "AdaptiveResize", { {"geometry", StringReference},
 623 +      {"width", IntegerReference}, {"height", IntegerReference},
 624 +      {"filter", MagickFilterOptions}, {"support", StringReference },
 625 +      {"blur", RealReference } } },
 626 +    { "ClipMask", { {"mask", ImageReference} } },
 627 +    { "LinearStretch", { {"levels", StringReference},
 628 +      {"black-point", RealReference},{"white-point", RealReference} } },
 629 +    { "Recolor", { {"matrix", ArrayReference} } },
 630 +    { "Mask", { {"mask", ImageReference} } },
 631 +    { "Polaroid", { {"caption", StringReference}, {"angle", RealReference},
 632 +      {"font", StringReference}, {"stroke", StringReference},
 633 +      {"fill", StringReference}, {"strokewidth", RealReference},
 634 +      {"pointsize", RealReference}, {"gravity", MagickGravityOptions},
 635 +      {"background", StringReference} } },
 636 +    { "FloodfillPaint", { {"geometry", StringReference},
 637 +      {"x", IntegerReference}, {"y", IntegerReference},
 638 +      {"fill", StringReference}, {"bordercolor", StringReference},
 639 +      {"fuzz", StringReference}, {"channel", MagickChannelOptions},
 640 +      {"invert", MagickBooleanOptions} } },
 641 +    { "Distort", { {"points", ArrayReference}, {"method", MagickDistortOptions},
 642 +      {"virtual-pixel", MagickVirtualPixelOptions},
 643 +      {"best-fit", MagickBooleanOptions} } },
 644 +    { "Clut", { {"image", ImageReference},
 645 +      {"channel", MagickChannelOptions} } },
 646 +    { "LiquidRescale", { {"geometry", StringReference},
 647 +      {"width", IntegerReference}, {"height", IntegerReference},
 648 +      {"delta-x", RealReference}, {"rigidity", RealReference } } },
 649 +    { "Encipher", { {"passphrase", StringReference} } },
 650 +    { "Decipher", { {"passphrase", StringReference} } },
 651 +    { "Deskew", { {"geometry", StringReference},
 652 +      {"threshold", StringReference} } },
 653 +    { "Remap", { {"image", ImageReference}, {"dither", MagickBooleanOptions},
 654 +      {"dither-method", MagickDitherOptions} } },
 655 +    { "SparseColor", { {"points", ArrayReference},
 656 +      {"method", MagickSparseColorOptions},
 657 +      {"virtual-pixel", MagickVirtualPixelOptions},
 658 +      {"channel", MagickChannelOptions} } },
 659 +    { "Function", { {"parameters", ArrayReference},
 660 +      {"function", MagickFunctionOptions},
 661 +      {"virtual-pixel", MagickVirtualPixelOptions} } },
 662 +    { "SelectiveBlur", { {"geometry", StringReference},
 663 +      {"radius", RealReference}, {"sigma", RealReference},
 664 +      {"threshold", RealReference}, {"channel", MagickChannelOptions} } },
 665 +    { "HaldClut", { {"image", ImageReference},
 666 +      {"channel", MagickChannelOptions} } },
 667 +    { "BlueShift", { {"factor", StringReference} } },
 668 +    { "ForwardFourierTransform", { {"magnitude", MagickBooleanOptions} } },
 669 +    { "InverseFourierTransform", { {"magnitude", MagickBooleanOptions} } },
 670 +    { "ColorDecisionList", {
 671 +      {"color-correction-collection", StringReference} } },
 672 +    { "AutoGamma", { {"channel", MagickChannelOptions} } },
 673 +    { "AutoLevel", { {"channel", MagickChannelOptions} } },
 674 +    { "LevelColors", { {"invert", MagickBooleanOptions},
 675 +      {"black-point", StringReference}, {"white-point", StringReference},
 676 +      {"channel", MagickChannelOptions}, {"invert", MagickBooleanOptions} } },
 677 +    { "Clamp", { {"channel", MagickChannelOptions} } },
 678 +    { "Filter", { {"kernel", StringReference},
 679 +      {"channel", MagickChannelOptions}, {"bias", StringReference} } },
 680 +    { "BrightnessContrast", { {"levels", StringReference},
 681 +      {"brightness", RealReference},{"contrast", RealReference},
 682 +      {"channel", MagickChannelOptions} } },
 683 +    { "Morphology", { {"kernel", StringReference},
 684 +      {"channel", MagickChannelOptions}, {"method", MagickMorphologyOptions},
 685 +      {"iterations", IntegerReference} } },
 686 +    { "ColorMatrix", { {"matrix", ArrayReference} } },
 687 +    { "Color", { {"color", StringReference} } },
 688 +    { "Mode", { {"geometry", StringReference},
 689 +      {"width", IntegerReference},{"height", IntegerReference},
 690 +      {"channel", MagickChannelOptions} } },
 691 +    { "Statistic", { {"geometry", StringReference},
 692 +      {"width", IntegerReference},{"height", IntegerReference},
 693 +      {"channel", MagickChannelOptions}, {"type", MagickStatisticOptions} } },
 694 +    { "Perceptible", { {"epsilon", RealReference},
 695 +      {"channel", MagickChannelOptions} } },
 696 +    { "Poly", { {"terms", ArrayReference},
 697 +      {"channel", MagickChannelOptions} } },
 698 +    { "Grayscale", { {"method", MagickPixelIntensityOptions} } },
 699 +    { "CannyEdge", { {"geometry", StringReference},
 700 +      {"radius", RealReference}, {"sigma", RealReference},
 701 +      {"lower-percent", RealReference}, {"upper-percent", RealReference} } },
 702 +    { "HoughLine", { {"geometry", StringReference},
 703 +      {"width", IntegerReference}, {"height", IntegerReference},
 704 +      {"threshold", IntegerReference} } },
 705 +    { "MeanShift", { {"geometry", StringReference},
 706 +      {"width", IntegerReference}, {"height", IntegerReference},
 707 +      {"distance", RealReference} } },
 708 +    { "Kuwahara", { {"geometry", StringReference}, {"radius", RealReference},
 709 +      {"sigma", RealReference}, {"channel", MagickChannelOptions} } },
 710 +    { "ConnectedComponents", { {"connectivity", IntegerReference} } },
 711 +    { "CopyPixels", { {"image", ImageReference}, {"geometry", StringReference},
 712 +      {"width", IntegerReference}, {"height", IntegerReference},
 713 +      {"x", IntegerReference}, {"y", IntegerReference},
 714 +      {"gravity", MagickGravityOptions}, {"offset", StringReference},
 715 +      {"dx", IntegerReference}, {"dy", IntegerReference} } },
 716 +    { "WaveletDenoise", {  {"geometry", StringReference},
 717 +      {"threshold", RealReference}, {"softness", RealReference} } },
 718 +  };
 719 +
 720 +static SplayTreeInfo
 721 +  *magick_registry = (SplayTreeInfo *) NULL;
 722 +\f
 723 +/*
 724 +  Forward declarations.
 725 +*/
 726 +static Image
 727 +  *SetupList(pTHX_ SV *,struct PackageInfo **,SV ***,ExceptionInfo *);
 728 +
 729 +static ssize_t
 730 +  strEQcase(const char *,const char *);
 731 +\f
 732 +/*
 733 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 734 +%                                                                             %
 735 +%                                                                             %
 736 +%                                                                             %
 737 +%   C l o n e P a c k a g e I n f o                                           %
 738 +%                                                                             %
 739 +%                                                                             %
 740 +%                                                                             %
 741 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 742 +%
 743 +%  ClonePackageInfo makes a duplicate of the given info, or if info is NULL,
 744 +%  a new one.
 745 +%
 746 +%  The format of the ClonePackageInfo routine is:
 747 +%
 748 +%      struct PackageInfo *ClonePackageInfo(struct PackageInfo *info,
 749 +%        exception)
 750 +%
 751 +%  A description of each parameter follows:
 752 +%
 753 +%    o info: a structure of type info.
 754 +%
 755 +%    o exception: Return any errors or warnings in this structure.
 756 +%
 757 +*/
 758 +static struct PackageInfo *ClonePackageInfo(struct PackageInfo *info,
 759 +  ExceptionInfo *exception)
 760 +{
 761 +  struct PackageInfo
 762 +    *clone_info;
 763 +
 764 +  clone_info=(struct PackageInfo *) AcquireQuantumMemory(1,sizeof(*clone_info));
 765 +  if (clone_info == (struct PackageInfo *) NULL)
 766 +    {
 767 +      ThrowPerlException(exception,ResourceLimitError,
 768 +        "UnableToClonePackageInfo",PackageName);
 769 +      return((struct PackageInfo *) NULL);
 770 +    }
 771 +  if (info == (struct PackageInfo *) NULL)
 772 +    {
 773 +      clone_info->image_info=CloneImageInfo((ImageInfo *) NULL);
 774 +      return(clone_info);
 775 +    }
 776 +  *clone_info=(*info);
 777 +  clone_info->image_info=CloneImageInfo(info->image_info);
 778 +  return(clone_info);
 779 +}
 780 +\f
 781 +/*
 782 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 783 +%                                                                             %
 784 +%                                                                             %
 785 +%                                                                             %
 786 +%   c o n s t a n t                                                           %
 787 +%                                                                             %
 788 +%                                                                             %
 789 +%                                                                             %
 790 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 791 +%
 792 +%  constant() returns a double value for the specified name.
 793 +%
 794 +%  The format of the constant routine is:
 795 +%
 796 +%      double constant(char *name,ssize_t sans)
 797 +%
 798 +%  A description of each parameter follows:
 799 +%
 800 +%    o value: Method constant returns a double value for the specified name.
 801 +%
 802 +%    o name: The name of the constant.
 803 +%
 804 +%    o sans: This integer value is not used.
 805 +%
 806 +*/
 807 +static double constant(char *name,ssize_t sans)
 808 +{
 809 +  (void) sans;
 810 +  errno=0;
 811 +  switch (*name)
 812 +  {
 813 +    case 'B':
 814 +    {
 815 +      if (strEQ(name,"BlobError"))
 816 +        return(BlobError);
 817 +      if (strEQ(name,"BlobWarning"))
 818 +        return(BlobWarning);
 819 +      break;
 820 +    }
 821 +    case 'C':
 822 +    {
 823 +      if (strEQ(name,"CacheError"))
 824 +        return(CacheError);
 825 +      if (strEQ(name,"CacheWarning"))
 826 +        return(CacheWarning);
 827 +      if (strEQ(name,"CoderError"))
 828 +        return(CoderError);
 829 +      if (strEQ(name,"CoderWarning"))
 830 +        return(CoderWarning);
 831 +      if (strEQ(name,"ConfigureError"))
 832 +        return(ConfigureError);
 833 +      if (strEQ(name,"ConfigureWarning"))
 834 +        return(ConfigureWarning);
 835 +      if (strEQ(name,"CorruptImageError"))
 836 +        return(CorruptImageError);
 837 +      if (strEQ(name,"CorruptImageWarning"))
 838 +        return(CorruptImageWarning);
 839 +      break;
 840 +    }
 841 +    case 'D':
 842 +    {
 843 +      if (strEQ(name,"DelegateError"))
 844 +        return(DelegateError);
 845 +      if (strEQ(name,"DelegateWarning"))
 846 +        return(DelegateWarning);
 847 +      if (strEQ(name,"DrawError"))
 848 +        return(DrawError);
 849 +      if (strEQ(name,"DrawWarning"))
 850 +        return(DrawWarning);
 851 +      break;
 852 +    }
 853 +    case 'E':
 854 +    {
 855 +      if (strEQ(name,"ErrorException"))
 856 +        return(ErrorException);
 857 +      if (strEQ(name,"ExceptionError"))
 858 +        return(CoderError);
 859 +      if (strEQ(name,"ExceptionWarning"))
 860 +        return(CoderWarning);
 861 +      break;
 862 +    }
 863 +    case 'F':
 864 +    {
 865 +      if (strEQ(name,"FatalErrorException"))
 866 +        return(FatalErrorException);
 867 +      if (strEQ(name,"FileOpenError"))
 868 +        return(FileOpenError);
 869 +      if (strEQ(name,"FileOpenWarning"))
 870 +        return(FileOpenWarning);
 871 +      break;
 872 +    }
 873 +    case 'I':
 874 +    {
 875 +      if (strEQ(name,"ImageError"))
 876 +        return(ImageError);
 877 +      if (strEQ(name,"ImageWarning"))
 878 +        return(ImageWarning);
 879 +      break;
 880 +    }
 881 +    case 'M':
 882 +    {
 883 +      if (strEQ(name,"MaxRGB"))
 884 +        return(QuantumRange);
 885 +      if (strEQ(name,"MissingDelegateError"))
 886 +        return(MissingDelegateError);
 887 +      if (strEQ(name,"MissingDelegateWarning"))
 888 +        return(MissingDelegateWarning);
 889 +      if (strEQ(name,"ModuleError"))
 890 +        return(ModuleError);
 891 +      if (strEQ(name,"ModuleWarning"))
 892 +        return(ModuleWarning);
 893 +      break;
 894 +    }
 895 +    case 'O':
 896 +    {
 897 +      if (strEQ(name,"Opaque"))
 898 +        return(OpaqueOpacity);
 899 +      if (strEQ(name,"OptionError"))
 900 +        return(OptionError);
 901 +      if (strEQ(name,"OptionWarning"))
 902 +        return(OptionWarning);
 903 +      break;
 904 +    }
 905 +    case 'Q':
 906 +    {
 907 +      if (strEQ(name,"MAGICKCORE_QUANTUM_DEPTH"))
 908 +        return(MAGICKCORE_QUANTUM_DEPTH);
 909 +      if (strEQ(name,"QuantumDepth"))
 910 +        return(MAGICKCORE_QUANTUM_DEPTH);
 911 +      if (strEQ(name,"QuantumRange"))
 912 +        return(QuantumRange);
 913 +      break;
 914 +    }
 915 +    case 'R':
 916 +    {
 917 +      if (strEQ(name,"ResourceLimitError"))
 918 +        return(ResourceLimitError);
 919 +      if (strEQ(name,"ResourceLimitWarning"))
 920 +        return(ResourceLimitWarning);
 921 +      if (strEQ(name,"RegistryError"))
 922 +        return(RegistryError);
 923 +      if (strEQ(name,"RegistryWarning"))
 924 +        return(RegistryWarning);
 925 +      break;
 926 +    }
 927 +    case 'S':
 928 +    {
 929 +      if (strEQ(name,"StreamError"))
 930 +        return(StreamError);
 931 +      if (strEQ(name,"StreamWarning"))
 932 +        return(StreamWarning);
 933 +      if (strEQ(name,"Success"))
 934 +        return(0);
 935 +      break;
 936 +    }
 937 +    case 'T':
 938 +    {
 939 +      if (strEQ(name,"Transparent"))
 940 +        return(TransparentOpacity);
 941 +      if (strEQ(name,"TypeError"))
 942 +        return(TypeError);
 943 +      if (strEQ(name,"TypeWarning"))
 944 +        return(TypeWarning);
 945 +      break;
 946 +    }
 947 +    case 'W':
 948 +    {
 949 +      if (strEQ(name,"WarningException"))
 950 +        return(WarningException);
 951 +      break;
 952 +    }
 953 +    case 'X':
 954 +    {
 955 +      if (strEQ(name,"XServerError"))
 956 +        return(XServerError);
 957 +      if (strEQ(name,"XServerWarning"))
 958 +        return(XServerWarning);
 959 +      break;
 960 +    }
 961 +  }
 962 +  errno=EINVAL;
 963 +  return(0);
 964 +}
 965 +\f
 966 +/*
 967 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 968 +%                                                                             %
 969 +%                                                                             %
 970 +%                                                                             %
 971 +%   D e s t r o y P a c k a g e I n f o                                       %
 972 +%                                                                             %
 973 +%                                                                             %
 974 +%                                                                             %
 975 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 976 +%
 977 +%  Method DestroyPackageInfo frees a previously created info structure.
 978 +%
 979 +%  The format of the DestroyPackageInfo routine is:
 980 +%
 981 +%      DestroyPackageInfo(struct PackageInfo *info)
 982 +%
 983 +%  A description of each parameter follows:
 984 +%
 985 +%    o info: a structure of type info.
 986 +%
 987 +*/
 988 +static void DestroyPackageInfo(struct PackageInfo *info)
 989 +{
 990 +  info->image_info=DestroyImageInfo(info->image_info);
 991 +  info=(struct PackageInfo *) RelinquishMagickMemory(info);
 992 +}
 993 +\f
 994 +/*
 995 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 996 +%                                                                             %
 997 +%                                                                             %
 998 +%                                                                             %
 999 +%   G e t L i s t                                                             %
1000 +%                                                                             %
1001 +%                                                                             %
1002 +%                                                                             %
1003 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1004 +%
1005 +%  Method GetList is recursively called by SetupList to traverse the
1006 +%  Image__Magick reference.  If building an reference_vector (see SetupList),
1007 +%  *current is the current position in *reference_vector and *last is the final
1008 +%  entry in *reference_vector.
1009 +%
1010 +%  The format of the GetList routine is:
1011 +%
1012 +%      GetList(info)
1013 +%
1014 +%  A description of each parameter follows:
1015 +%
1016 +%    o info: a structure of type info.
1017 +%
1018 +*/
1019 +static Image *GetList(pTHX_ SV *reference,SV ***reference_vector,
1020 +  ssize_t *current,ssize_t *last,ExceptionInfo *exception)
1021 +{
1022 +  Image
1023 +    *image;
1024 +
1025 +  if (reference == (SV *) NULL)
1026 +    return(NULL);
1027 +  switch (SvTYPE(reference))
1028 +  {
1029 +    case SVt_PVAV:
1030 +    {
1031 +      AV
1032 +        *av;
1033 +
1034 +      Image
1035 +        *head,
1036 +        *previous;
1037 +
1038 +      register ssize_t
1039 +        i;
1040 +
1041 +      ssize_t
1042 +        n;
1043 +
1044 +      /*
1045 +        Array of images.
1046 +      */
1047 +      previous=(Image *) NULL;
1048 +      head=(Image *) NULL;
1049 +      av=(AV *) reference;
1050 +      n=av_len(av);
1051 +      for (i=0; i <= n; i++)
1052 +      {
1053 +        SV
1054 +          **rv;
1055 +
1056 +        rv=av_fetch(av,i,0);
1057 +        if (rv && *rv && sv_isobject(*rv))
1058 +          {
1059 +            image=GetList(aTHX_ SvRV(*rv),reference_vector,current,last,
1060 +              exception);
1061 +            if (image == (Image *) NULL)
1062 +              continue;
1063 +            if (image == previous)
1064 +              {
1065 +                image=CloneImage(image,0,0,MagickTrue,exception);
1066 +                if (image == (Image *) NULL)
1067 +                  return(NULL);
1068 +              }
1069 +            image->previous=previous;
1070 +            *(previous ? &previous->next : &head)=image;
1071 +            for (previous=image; previous->next; previous=previous->next) ;
1072 +          }
1073 +      }
1074 +      return(head);
1075 +    }
1076 +    case SVt_PVMG:
1077 +    {
1078 +      /*
1079 +        Blessed scalar, one image.
1080 +      */
1081 +      image=INT2PTR(Image *,SvIV(reference));
1082 +      if (image == (Image *) NULL)
1083 +        return(NULL);
1084 +      image->previous=(Image *) NULL;
1085 +      image->next=(Image *) NULL;
1086 +      if (reference_vector)
1087 +        {
1088 +          if (*current == *last)
1089 +            {
1090 +              *last+=256;
1091 +              if (*reference_vector == (SV **) NULL)
1092 +                *reference_vector=(SV **) AcquireQuantumMemory(*last,
1093 +                  sizeof(*reference_vector));
1094 +              else
1095 +                *reference_vector=(SV **) ResizeQuantumMemory(*reference_vector,
1096 +                  *last,sizeof(*reference_vector));
1097 +            }
1098 +          if (*reference_vector == (SV **) NULL)
1099 +            {
1100 +              ThrowPerlException(exception,ResourceLimitError,
1101 +                "MemoryAllocationFailed",PackageName);
1102 +              return((Image *) NULL);
1103 +            }
1104 +          (*reference_vector)[*current]=reference;
1105 +          (*reference_vector)[++(*current)]=NULL;
1106 +        }
1107 +      return(image);
1108 +    }
1109 +    default:
1110 +      break;
1111 +  }
1112 +  (void) fprintf(stderr,"GetList: UnrecognizedType %.20g\n",
1113 +    (double) SvTYPE(reference));
1114 +  return((Image *) NULL);
1115 +}
1116 +\f
1117 +/*
1118 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1119 +%                                                                             %
1120 +%                                                                             %
1121 +%                                                                             %
1122 +%   G e t P a c k a g e I n f o                                               %
1123 +%                                                                             %
1124 +%                                                                             %
1125 +%                                                                             %
1126 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1127 +%
1128 +%  Method GetPackageInfo looks up or creates an info structure for the given
1129 +%  Image__Magick reference.  If it does create a new one, the information in
1130 +%  package_info is used to initialize it.
1131 +%
1132 +%  The format of the GetPackageInfo routine is:
1133 +%
1134 +%      struct PackageInfo *GetPackageInfo(void *reference,
1135 +%        struct PackageInfo *package_info,ExceptionInfo *exception)
1136 +%
1137 +%  A description of each parameter follows:
1138 +%
1139 +%    o info: a structure of type info.
1140 +%
1141 +%    o exception: Return any errors or warnings in this structure.
1142 +%
1143 +*/
1144 +static struct PackageInfo *GetPackageInfo(pTHX_ void *reference,
1145 +  struct PackageInfo *package_info,ExceptionInfo *exception)
1146 +{
1147 +  char
1148 +    message[MaxTextExtent];
1149 +
1150 +  struct PackageInfo
1151 +    *clone_info;
1152 +
1153 +  SV
1154 +    *sv;
1155 +
1156 +  (void) FormatLocaleString(message,MaxTextExtent,"%s::package%s%p",
1157 +    PackageName,XS_VERSION,reference);
1158 +  sv=perl_get_sv(message,(TRUE | 0x02));
1159 +  if (sv == (SV *) NULL)
1160 +    {
1161 +      ThrowPerlException(exception,ResourceLimitError,"UnableToGetPackageInfo",
1162 +        message);
1163 +      return(package_info);
1164 +    }
1165 +  if (SvREFCNT(sv) == 0)
1166 +    (void) SvREFCNT_inc(sv);
1167 +  if (SvIOKp(sv) && (clone_info=INT2PTR(struct PackageInfo *,SvIV(sv))))
1168 +    return(clone_info);
1169 +  clone_info=ClonePackageInfo(package_info,exception);
1170 +  sv_setiv(sv,PTR2IV(clone_info));
1171 +  return(clone_info);
1172 +}
1173 +\f
1174 +/*
1175 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1176 +%                                                                             %
1177 +%                                                                             %
1178 +%                                                                             %
1179 +%   S e t A t t r i b u t e                                                   %
1180 +%                                                                             %
1181 +%                                                                             %
1182 +%                                                                             %
1183 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1184 +%
1185 +%  SetAttribute() sets the attribute to the value in sval.  This can change
1186 +%  either or both of image or info.
1187 +%
1188 +%  The format of the SetAttribute routine is:
1189 +%
1190 +%      SetAttribute(struct PackageInfo *info,Image *image,char *attribute,
1191 +%        SV *sval,ExceptionInfo *exception)
1192 +%
1193 +%  A description of each parameter follows:
1194 +%
1195 +%    o list: a list of strings.
1196 +%
1197 +%    o string: a character string.
1198 +%
1199 +*/
1200 +
1201 +static double SiPrefixToDoubleInterval(const char *string,const double interval)
1202 +{
1203 +  char
1204 +    *q;
1205 +
1206 +  double
1207 +    value;
1208 +
1209 +  value=InterpretSiPrefixValue(string,&q);
1210 +  if (*q == '%')
1211 +    value*=interval/100.0;
1212 +  return(value);
1213 +}
1214 +
1215 +static inline double StringToDouble(const char *string,char **sentinal)
1216 +{
1217 +  return(InterpretLocaleValue(string,sentinal));
1218 +}
1219 +
1220 +static double StringToDoubleInterval(const char *string,const double interval)
1221 +{
1222 +  char
1223 +    *q;
1224 +
1225 +  double
1226 +    value;
1227 +
1228 +  value=InterpretLocaleValue(string,&q);
1229 +  if (*q == '%')
1230 +    value*=interval/100.0;
1231 +  return(value);
1232 +}
1233 +
1234 +static inline ssize_t StringToLong(const char *value)
1235 +{
1236 +  return(strtol(value,(char **) NULL,10));
1237 +}
1238 +
1239 +static void SetAttribute(pTHX_ struct PackageInfo *info,Image *image,
1240 +  const char *attribute,SV *sval,ExceptionInfo *exception)
1241 +{
1242 +  GeometryInfo
1243 +    geometry_info;
1244 +
1245 +  long
1246 +    x,
1247 +    y;
1248 +
1249 +  MagickPixelPacket
1250 +    pixel;
1251 +
1252 +  MagickStatusType
1253 +    flags;
1254 +
1255 +  PixelPacket
1256 +    *color,
1257 +    target_color;
1258 +
1259 +  ssize_t
1260 +    sp;
1261 +
1262 +  switch (*attribute)
1263 +  {
1264 +    case 'A':
1265 +    case 'a':
1266 +    {
1267 +      if (LocaleCompare(attribute,"adjoin") == 0)
1268 +        {
1269 +          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
1270 +            SvPV(sval,na)) : SvIV(sval);
1271 +          if (sp < 0)
1272 +            {
1273 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
1274 +                SvPV(sval,na));
1275 +              break;
1276 +            }
1277 +          if (info)
1278 +            info->image_info->adjoin=sp != 0 ? MagickTrue : MagickFalse;
1279 +          break;
1280 +        }
1281 +      if (LocaleCompare(attribute,"alpha") == 0)
1282 +        {
1283 +          sp=SvPOK(sval) ? ParseCommandOption(MagickAlphaOptions,MagickFalse,
1284 +            SvPV(sval,na)) : SvIV(sval);
1285 +          if (sp < 0)
1286 +            {
1287 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
1288 +                SvPV(sval,na));
1289 +              break;
1290 +            }
1291 +          for ( ; image; image=image->next)
1292 +            (void) SetImageAlphaChannel(image,(AlphaChannelType) sp);
1293 +          break;
1294 +        }
1295 +      if (LocaleCompare(attribute,"antialias") == 0)
1296 +        {
1297 +          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
1298 +            SvPV(sval,na)) : SvIV(sval);
1299 +          if (sp < 0)
1300 +            {
1301 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
1302 +                SvPV(sval,na));
1303 +              break;
1304 +            }
1305 +          if (info)
1306 +            info->image_info->antialias=sp != 0 ? MagickTrue : MagickFalse;
1307 +          break;
1308 +        }
1309 +      if (LocaleCompare(attribute,"area-limit") == 0)
1310 +        {
1311 +          MagickSizeType
1312 +            limit;
1313 +
1314 +          limit=MagickResourceInfinity;
1315 +          if (LocaleCompare(SvPV(sval,na),"unlimited") != 0)
1316 +            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
1317 +              100.0);
1318 +          (void) SetMagickResourceLimit(AreaResource,limit);
1319 +          break;
1320 +        }
1321 +      if (LocaleCompare(attribute,"attenuate") == 0)
1322 +        {
1323 +          if (info)
1324 +            (void) SetImageOption(info->image_info,attribute,SvPV(sval,na));
1325 +          break;
1326 +        }
1327 +      if (LocaleCompare(attribute,"authenticate") == 0)
1328 +        {
1329 +          if (info)
1330 +            (void) CloneString(&info->image_info->authenticate,SvPV(sval,na));
1331 +          break;
1332 +        }
1333 +      if (info)
1334 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1335 +      for ( ; image; image=image->next)
1336 +        SetImageProperty(image,attribute,SvPV(sval,na));
1337 +      break;
1338 +    }
1339 +    case 'B':
1340 +    case 'b':
1341 +    {
1342 +      if (LocaleCompare(attribute,"background") == 0)
1343 +        {
1344 +          (void) QueryColorDatabase(SvPV(sval,na),&target_color,exception);
1345 +          if (info)
1346 +            info->image_info->background_color=target_color;
1347 +          for ( ; image; image=image->next)
1348 +            image->background_color=target_color;
1349 +          break;
1350 +        }
1351 +      if (LocaleCompare(attribute,"bias") == 0)
1352 +        {
1353 +          for ( ; image; image=image->next)
1354 +            image->bias=StringToDoubleInterval(SvPV(sval,na),(double)
1355 +              QuantumRange+1.0);
1356 +          break;
1357 +        }
1358 +      if (LocaleCompare(attribute,"blue-primary") == 0)
1359 +        {
1360 +          for ( ; image; image=image->next)
1361 +          {
1362 +            flags=ParseGeometry(SvPV(sval,na),&geometry_info);
1363 +            image->chromaticity.blue_primary.x=geometry_info.rho;
1364 +            image->chromaticity.blue_primary.y=geometry_info.sigma;
1365 +            if ((flags & SigmaValue) == 0)
1366 +              image->chromaticity.blue_primary.y=
1367 +                image->chromaticity.blue_primary.x;
1368 +          }
1369 +          break;
1370 +        }
1371 +      if (LocaleCompare(attribute,"bordercolor") == 0)
1372 +        {
1373 +          (void) QueryColorDatabase(SvPV(sval,na),&target_color,exception);
1374 +          if (info)
1375 +            info->image_info->border_color=target_color;
1376 +          for ( ; image; image=image->next)
1377 +            image->border_color=target_color;
1378 +          break;
1379 +        }
1380 +      if (info)
1381 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1382 +      for ( ; image; image=image->next)
1383 +        SetImageProperty(image,attribute,SvPV(sval,na));
1384 +      break;
1385 +    }
1386 +    case 'C':
1387 +    case 'c':
1388 +    {
1389 +      if (LocaleCompare(attribute,"cache-threshold") == 0)
1390 +        {
1391 +          (void) SetMagickResourceLimit(MemoryResource,(MagickSizeType)
1392 +            SiPrefixToDoubleInterval(SvPV(sval,na),100.0));
1393 +          (void) SetMagickResourceLimit(MapResource,(MagickSizeType)
1394 +            (2.0*SiPrefixToDoubleInterval(SvPV(sval,na),100.0)));
1395 +          break;
1396 +        }
1397 +      if (LocaleCompare(attribute,"clip-mask") == 0)
1398 +        {
1399 +          Image
1400 +            *clip_mask;
1401 +
1402 +          clip_mask=(Image *) NULL;
1403 +          if (SvPOK(sval))
1404 +            clip_mask=SetupList(aTHX_ SvRV(sval),&info,(SV ***) NULL,exception);
1405 +          for ( ; image; image=image->next)
1406 +            SetImageClipMask(image,clip_mask);
1407 +          break;
1408 +        }
1409 +      if (LocaleNCompare(attribute,"colormap",8) == 0)
1410 +        {
1411 +          for ( ; image; image=image->next)
1412 +          {
1413 +            int
1414 +              items;
1415 +
1416 +            long
1417 +              i;
1418 +
1419 +            if (image->storage_class == DirectClass)
1420 +              continue;
1421 +            i=0;
1422 +            items=sscanf(attribute,"%*[^[][%ld",&i);
1423 +            (void) items;
1424 +            if (i > (ssize_t) image->colors)
1425 +              i%=image->colors;
1426 +            if ((strchr(SvPV(sval,na),',') == 0) ||
1427 +                (strchr(SvPV(sval,na),')') != 0))
1428 +              QueryColorDatabase(SvPV(sval,na),image->colormap+i,exception);
1429 +            else
1430 +              {
1431 +                color=image->colormap+i;
1432 +                pixel.red=color->red;
1433 +                pixel.green=color->green;
1434 +                pixel.blue=color->blue;
1435 +                flags=ParseGeometry(SvPV(sval,na),&geometry_info);
1436 +                pixel.red=geometry_info.rho;
1437 +                pixel.green=geometry_info.sigma;
1438 +                pixel.blue=geometry_info.xi;
1439 +                color->red=ClampToQuantum(pixel.red);
1440 +                color->green=ClampToQuantum(pixel.green);
1441 +                color->blue=ClampToQuantum(pixel.blue);
1442 +              }
1443 +          }
1444 +          break;
1445 +        }
1446 +      if (LocaleCompare(attribute,"colorspace") == 0)
1447 +        {
1448 +          sp=SvPOK(sval) ? ParseCommandOption(MagickColorspaceOptions,
1449 +            MagickFalse,SvPV(sval,na)) : SvIV(sval);
1450 +          if (sp < 0)
1451 +            {
1452 +              ThrowPerlException(exception,OptionError,"UnrecognizedColorspace",
1453 +                SvPV(sval,na));
1454 +              break;
1455 +            }
1456 +          for ( ; image; image=image->next)
1457 +            (void) TransformImageColorspace(image,(ColorspaceType) sp);
1458 +          break;
1459 +        }
1460 +      if (LocaleCompare(attribute,"comment") == 0)
1461 +        {
1462 +          for ( ; image; image=image->next)
1463 +            (void) SetImageProperty(image,"Comment",InterpretImageProperties(
1464 +              info ? info->image_info : (ImageInfo *) NULL,image,
1465 +              SvPV(sval,na)));
1466 +          break;
1467 +        }
1468 +      if (LocaleCompare(attribute,"compression") == 0)
1469 +        {
1470 +          sp=SvPOK(sval) ? ParseCommandOption(MagickCompressOptions,
1471 +            MagickFalse,SvPV(sval,na)) : SvIV(sval);
1472 +          if (sp < 0)
1473 +            {
1474 +              ThrowPerlException(exception,OptionError,
1475 +                "UnrecognizedImageCompression",SvPV(sval,na));
1476 +              break;
1477 +            }
1478 +          if (info)
1479 +            info->image_info->compression=(CompressionType) sp;
1480 +          for ( ; image; image=image->next)
1481 +            image->compression=(CompressionType) sp;
1482 +          break;
1483 +        }
1484 +      if (info)
1485 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1486 +      for ( ; image; image=image->next)
1487 +        SetImageProperty(image,attribute,SvPV(sval,na));
1488 +      break;
1489 +    }
1490 +    case 'D':
1491 +    case 'd':
1492 +    {
1493 +      if (LocaleCompare(attribute,"debug") == 0)
1494 +        {
1495 +          SetLogEventMask(SvPV(sval,na));
1496 +          break;
1497 +        }
1498 +      if (LocaleCompare(attribute,"delay") == 0)
1499 +        {
1500 +          flags=ParseGeometry(SvPV(sval,na),&geometry_info);
1501 +          for ( ; image; image=image->next)
1502 +          {
1503 +            image->delay=(size_t) floor(geometry_info.rho+0.5);
1504 +            if ((flags & SigmaValue) != 0)
1505 +              image->ticks_per_second=(ssize_t)
1506 +                floor(geometry_info.sigma+0.5);
1507 +          }
1508 +          break;
1509 +        }
1510 +      if (LocaleCompare(attribute,"disk-limit") == 0)
1511 +        {
1512 +          MagickSizeType
1513 +            limit;
1514 +
1515 +          limit=MagickResourceInfinity;
1516 +          if (LocaleCompare(SvPV(sval,na),"unlimited") != 0)
1517 +            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
1518 +              100.0);
1519 +          (void) SetMagickResourceLimit(DiskResource,limit);
1520 +          break;
1521 +        }
1522 +      if (LocaleCompare(attribute,"density") == 0)
1523 +        {
1524 +          if (IsGeometry(SvPV(sval,na)) == MagickFalse)
1525 +            {
1526 +              ThrowPerlException(exception,OptionError,"MissingGeometry",
1527 +                SvPV(sval,na));
1528 +              break;
1529 +            }
1530 +          if (info)
1531 +            (void) CloneString(&info->image_info->density,SvPV(sval,na));
1532 +          for ( ; image; image=image->next)
1533 +          {
1534 +            flags=ParseGeometry(SvPV(sval,na),&geometry_info);
1535 +            image->x_resolution=geometry_info.rho;
1536 +            image->y_resolution=geometry_info.sigma;
1537 +            if ((flags & SigmaValue) == 0)
1538 +              image->y_resolution=image->x_resolution;
1539 +          }
1540 +          break;
1541 +        }
1542 +      if (LocaleCompare(attribute,"depth") == 0)
1543 +        {
1544 +          if (info)
1545 +            info->image_info->depth=SvIV(sval);
1546 +          for ( ; image; image=image->next)
1547 +            (void) SetImageDepth(image,SvIV(sval));
1548 +          break;
1549 +        }
1550 +      if (LocaleCompare(attribute,"dispose") == 0)
1551 +        {
1552 +          sp=SvPOK(sval) ? ParseCommandOption(MagickDisposeOptions,MagickFalse,
1553 +            SvPV(sval,na)) : SvIV(sval);
1554 +          if (sp < 0)
1555 +            {
1556 +              ThrowPerlException(exception,OptionError,
1557 +                "UnrecognizedDisposeMethod",SvPV(sval,na));
1558 +              break;
1559 +            }
1560 +          for ( ; image; image=image->next)
1561 +            image->dispose=(DisposeType) sp;
1562 +          break;
1563 +        }
1564 +      if (LocaleCompare(attribute,"dither") == 0)
1565 +        {
1566 +          if (info)
1567 +            {
1568 +              sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,
1569 +                MagickFalse,SvPV(sval,na)) : SvIV(sval);
1570 +              if (sp < 0)
1571 +                {
1572 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
1573 +                    SvPV(sval,na));
1574 +                  break;
1575 +                }
1576 +              info->image_info->dither=sp != 0 ? MagickTrue : MagickFalse;
1577 +            }
1578 +          break;
1579 +        }
1580 +      if (LocaleCompare(attribute,"display") == 0)
1581 +        {
1582 +          display:
1583 +          if (info)
1584 +            (void) CloneString(&info->image_info->server_name,SvPV(sval,na));
1585 +          break;
1586 +        }
1587 +      if (info)
1588 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1589 +      for ( ; image; image=image->next)
1590 +        SetImageProperty(image,attribute,SvPV(sval,na));
1591 +      break;
1592 +    }
1593 +    case 'E':
1594 +    case 'e':
1595 +    {
1596 +      if (LocaleCompare(attribute,"endian") == 0)
1597 +        {
1598 +          sp=SvPOK(sval) ? ParseCommandOption(MagickEndianOptions,MagickFalse,
1599 +            SvPV(sval,na)) : SvIV(sval);
1600 +          if (sp < 0)
1601 +            {
1602 +              ThrowPerlException(exception,OptionError,"UnrecognizedEndianType",
1603 +                SvPV(sval,na));
1604 +              break;
1605 +            }
1606 +          if (info)
1607 +            info->image_info->endian=(EndianType) sp;
1608 +          for ( ; image; image=image->next)
1609 +            image->endian=(EndianType) sp;
1610 +          break;
1611 +        }
1612 +      if (LocaleCompare(attribute,"extract") == 0)
1613 +        {
1614 +          /*
1615 +            Set image extract geometry.
1616 +          */
1617 +          (void) CloneString(&info->image_info->extract,SvPV(sval,na));
1618 +          break;
1619 +        }
1620 +      if (info)
1621 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1622 +      for ( ; image; image=image->next)
1623 +        SetImageProperty(image,attribute,SvPV(sval,na));
1624 +      break;
1625 +    }
1626 +    case 'F':
1627 +    case 'f':
1628 +    {
1629 +      if (LocaleCompare(attribute,"filename") == 0)
1630 +        {
1631 +          if (info)
1632 +            (void) CopyMagickString(info->image_info->filename,SvPV(sval,na),
1633 +              MaxTextExtent);
1634 +          for ( ; image; image=image->next)
1635 +            (void) CopyMagickString(image->filename,SvPV(sval,na),
1636 +              MaxTextExtent);
1637 +          break;
1638 +        }
1639 +      if (LocaleCompare(attribute,"file") == 0)
1640 +        {
1641 +          FILE
1642 +            *file;
1643 +
1644 +          PerlIO
1645 +            *io_info;
1646 +
1647 +          if (info == (struct PackageInfo *) NULL)
1648 +            break;
1649 +          io_info=IoIFP(sv_2io(sval));
1650 +          if (io_info == (PerlIO *) NULL)
1651 +            {
1652 +              ThrowPerlException(exception,BlobError,"UnableToOpenFile",
1653 +                PackageName);
1654 +              break;
1655 +            }
1656 +          file=PerlIO_findFILE(io_info);
1657 +          if (file == (FILE *) NULL)
1658 +            {
1659 +              ThrowPerlException(exception,BlobError,"UnableToOpenFile",
1660 +                PackageName);
1661 +              break;
1662 +            }
1663 +          SetImageInfoFile(info->image_info,file);
1664 +          break;
1665 +        }
1666 +      if (LocaleCompare(attribute,"fill") == 0)
1667 +        {
1668 +          if (info)
1669 +            (void) SetImageOption(info->image_info,"fill",SvPV(sval,na));
1670 +          break;
1671 +        }
1672 +      if (LocaleCompare(attribute,"font") == 0)
1673 +        {
1674 +          if (info)
1675 +            (void) CloneString(&info->image_info->font,SvPV(sval,na));
1676 +          break;
1677 +        }
1678 +      if (LocaleCompare(attribute,"foreground") == 0)
1679 +        break;
1680 +      if (LocaleCompare(attribute,"fuzz") == 0)
1681 +        {
1682 +          if (info)
1683 +            info->image_info->fuzz=StringToDoubleInterval(SvPV(sval,na),(double)
1684 +              QuantumRange+1.0);
1685 +          for ( ; image; image=image->next)
1686 +            image->fuzz=StringToDoubleInterval(SvPV(sval,na),(double)
1687 +              QuantumRange+1.0);
1688 +          break;
1689 +        }
1690 +      if (info)
1691 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1692 +      for ( ; image; image=image->next)
1693 +        SetImageProperty(image,attribute,SvPV(sval,na));
1694 +      break;
1695 +    }
1696 +    case 'G':
1697 +    case 'g':
1698 +    {
1699 +      if (LocaleCompare(attribute,"gamma") == 0)
1700 +        {
1701 +          for ( ; image; image=image->next)
1702 +            image->gamma=SvNV(sval);
1703 +          break;
1704 +        }
1705 +      if (LocaleCompare(attribute,"gravity") == 0)
1706 +        {
1707 +          sp=SvPOK(sval) ? ParseCommandOption(MagickGravityOptions,MagickFalse,
1708 +            SvPV(sval,na)) : SvIV(sval);
1709 +          if (sp < 0)
1710 +            {
1711 +              ThrowPerlException(exception,OptionError,
1712 +                "UnrecognizedGravityType",SvPV(sval,na));
1713 +              break;
1714 +            }
1715 +          if (info)
1716 +            SetImageOption(info->image_info,attribute,SvPV(sval,na));
1717 +          for ( ; image; image=image->next)
1718 +            image->gravity=(GravityType) sp;
1719 +          break;
1720 +        }
1721 +      if (LocaleCompare(attribute,"green-primary") == 0)
1722 +        {
1723 +          for ( ; image; image=image->next)
1724 +          {
1725 +            flags=ParseGeometry(SvPV(sval,na),&geometry_info);
1726 +            image->chromaticity.green_primary.x=geometry_info.rho;
1727 +            image->chromaticity.green_primary.y=geometry_info.sigma;
1728 +            if ((flags & SigmaValue) == 0)
1729 +              image->chromaticity.green_primary.y=
1730 +                image->chromaticity.green_primary.x;
1731 +          }
1732 +          break;
1733 +        }
1734 +      if (info)
1735 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1736 +      for ( ; image; image=image->next)
1737 +        SetImageProperty(image,attribute,SvPV(sval,na));
1738 +      break;
1739 +    }
1740 +    case 'I':
1741 +    case 'i':
1742 +    {
1743 +      if (LocaleNCompare(attribute,"index",5) == 0)
1744 +        {
1745 +          IndexPacket
1746 +            *indexes;
1747 +
1748 +          int
1749 +            items;
1750 +
1751 +          long
1752 +            index;
1753 +
1754 +          register PixelPacket
1755 +            *p;
1756 +
1757 +          CacheView
1758 +            *image_view;
1759 +
1760 +          for ( ; image; image=image->next)
1761 +          {
1762 +            if (image->storage_class != PseudoClass)
1763 +              continue;
1764 +            x=0;
1765 +            y=0;
1766 +            items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
1767 +            (void) items;
1768 +            image_view=AcquireAuthenticCacheView(image,exception);
1769 +            p=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
1770 +            if (p != (PixelPacket *) NULL)
1771 +              {
1772 +                indexes=GetCacheViewAuthenticIndexQueue(image_view);
1773 +                items=sscanf(SvPV(sval,na),"%ld",&index);
1774 +                if ((index >= 0) && (index < (ssize_t) image->colors))
1775 +                  SetPixelIndex(indexes,index);
1776 +                (void) SyncCacheViewAuthenticPixels(image_view,exception);
1777 +              }
1778 +            image_view=DestroyCacheView(image_view);
1779 +          }
1780 +          break;
1781 +        }
1782 +      if (LocaleCompare(attribute,"iterations") == 0)
1783 +        {
1784 +  iterations:
1785 +          for ( ; image; image=image->next)
1786 +            image->iterations=SvIV(sval);
1787 +          break;
1788 +        }
1789 +      if (LocaleCompare(attribute,"interlace") == 0)
1790 +        {
1791 +          sp=SvPOK(sval) ? ParseCommandOption(MagickInterlaceOptions,
1792 +            MagickFalse,SvPV(sval,na)) : SvIV(sval);
1793 +          if (sp < 0)
1794 +            {
1795 +              ThrowPerlException(exception,OptionError,
1796 +                "UnrecognizedInterlaceType",SvPV(sval,na));
1797 +              break;
1798 +            }
1799 +          if (info)
1800 +            info->image_info->interlace=(InterlaceType) sp;
1801 +          for ( ; image; image=image->next)
1802 +            image->interlace=(InterlaceType) sp;
1803 +          break;
1804 +        }
1805 +      if (info)
1806 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1807 +      for ( ; image; image=image->next)
1808 +        SetImageProperty(image,attribute,SvPV(sval,na));
1809 +      break;
1810 +    }
1811 +    case 'L':
1812 +    case 'l':
1813 +    {
1814 +      if (LocaleCompare(attribute,"label") == 0)
1815 +        {
1816 +          for ( ; image; image=image->next)
1817 +            (void) SetImageProperty(image,"label",InterpretImageProperties(
1818 +              info ? info->image_info : (ImageInfo *) NULL,image,
1819 +              SvPV(sval,na)));
1820 +          break;
1821 +        }
1822 +      if (LocaleCompare(attribute,"loop") == 0)
1823 +        goto iterations;
1824 +      if (info)
1825 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1826 +      for ( ; image; image=image->next)
1827 +        SetImageProperty(image,attribute,SvPV(sval,na));
1828 +      break;
1829 +    }
1830 +    case 'M':
1831 +    case 'm':
1832 +    {
1833 +      if (LocaleCompare(attribute,"magick") == 0)
1834 +        {
1835 +          if (info)
1836 +            (void) FormatLocaleString(info->image_info->filename,MaxTextExtent,
1837 +              "%s:",SvPV(sval,na));
1838 +          for ( ; image; image=image->next)
1839 +            (void) CopyMagickString(image->magick,SvPV(sval,na),MaxTextExtent);
1840 +          break;
1841 +        }
1842 +      if (LocaleCompare(attribute,"map-limit") == 0)
1843 +        {
1844 +          MagickSizeType
1845 +            limit;
1846 +
1847 +          limit=MagickResourceInfinity;
1848 +          if (LocaleCompare(SvPV(sval,na),"unlimited") != 0)
1849 +            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
1850 +              100.0);
1851 +          (void) SetMagickResourceLimit(MapResource,limit);
1852 +          break;
1853 +        }
1854 +      if (LocaleCompare(attribute,"mask") == 0)
1855 +        {
1856 +          Image
1857 +            *mask;
1858 +
1859 +          mask=(Image *) NULL;
1860 +          if (SvPOK(sval))
1861 +            mask=SetupList(aTHX_ SvRV(sval),&info,(SV ***) NULL,exception);
1862 +          for ( ; image; image=image->next)
1863 +            SetImageMask(image,mask);
1864 +          break;
1865 +        }
1866 +      if (LocaleCompare(attribute,"mattecolor") == 0)
1867 +        {
1868 +          (void) QueryColorDatabase(SvPV(sval,na),&target_color,exception);
1869 +          if (info)
1870 +            info->image_info->matte_color=target_color;
1871 +          for ( ; image; image=image->next)
1872 +            image->matte_color=target_color;
1873 +          break;
1874 +        }
1875 +      if (LocaleCompare(attribute,"matte") == 0)
1876 +        {
1877 +          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
1878 +            SvPV(sval,na)) : SvIV(sval);
1879 +          if (sp < 0)
1880 +            {
1881 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
1882 +                SvPV(sval,na));
1883 +              break;
1884 +            }
1885 +          for ( ; image; image=image->next)
1886 +            image->matte=sp != 0 ? MagickTrue : MagickFalse;
1887 +          break;
1888 +        }
1889 +      if (LocaleCompare(attribute,"memory-limit") == 0)
1890 +        {
1891 +          MagickSizeType
1892 +            limit;
1893 +
1894 +          limit=MagickResourceInfinity;
1895 +          if (LocaleCompare(SvPV(sval,na),"unlimited") != 0)
1896 +            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
1897 +              100.0);
1898 +          (void) SetMagickResourceLimit(MemoryResource,limit);
1899 +          break;
1900 +        }
1901 +      if (LocaleCompare(attribute,"monochrome") == 0)
1902 +        {
1903 +          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
1904 +            SvPV(sval,na)) : SvIV(sval);
1905 +          if (sp < 0)
1906 +            {
1907 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
1908 +                SvPV(sval,na));
1909 +              break;
1910 +            }
1911 +          if (info)
1912 +            info->image_info->monochrome=sp != 0 ? MagickTrue : MagickFalse;
1913 +          for ( ; image; image=image->next)
1914 +            (void) SetImageType(image,BilevelType);
1915 +          break;
1916 +        }
1917 +      if (info)
1918 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1919 +      for ( ; image; image=image->next)
1920 +        SetImageProperty(image,attribute,SvPV(sval,na));
1921 +      break;
1922 +    }
1923 +    case 'O':
1924 +    case 'o':
1925 +    {
1926 +      if (LocaleCompare(attribute,"option") == 0)
1927 +        {
1928 +          if (info)
1929 +            DefineImageOption(info->image_info,SvPV(sval,na));
1930 +          break;
1931 +        }
1932 +      if (LocaleCompare(attribute,"orientation") == 0)
1933 +        {
1934 +          sp=SvPOK(sval) ? ParseCommandOption(MagickOrientationOptions,
1935 +            MagickFalse,SvPV(sval,na)) : SvIV(sval);
1936 +          if (sp < 0)
1937 +            {
1938 +              ThrowPerlException(exception,OptionError,
1939 +                "UnrecognizedOrientationType",SvPV(sval,na));
1940 +              break;
1941 +            }
1942 +          if (info)
1943 +            info->image_info->orientation=(OrientationType) sp;
1944 +          for ( ; image; image=image->next)
1945 +            image->orientation=(OrientationType) sp;
1946 +          break;
1947 +        }
1948 +      if (info)
1949 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
1950 +      for ( ; image; image=image->next)
1951 +        SetImageProperty(image,attribute,SvPV(sval,na));
1952 +      break;
1953 +    }
1954 +    case 'P':
1955 +    case 'p':
1956 +    {
1957 +      if (LocaleCompare(attribute,"page") == 0)
1958 +        {
1959 +          char
1960 +            *geometry;
1961 +
1962 +          geometry=GetPageGeometry(SvPV(sval,na));
1963 +          if (info)
1964 +            (void) CloneString(&info->image_info->page,geometry);
1965 +          for ( ; image; image=image->next)
1966 +            (void) ParsePageGeometry(image,geometry,&image->page,exception);
1967 +          geometry=(char *) RelinquishMagickMemory(geometry);
1968 +          break;
1969 +        }
1970 +      if (LocaleCompare(attribute,"pen") == 0)
1971 +        {
1972 +          if (info)
1973 +            (void) SetImageOption(info->image_info,"fill",SvPV(sval,na));
1974 +          break;
1975 +        }
1976 +      if (LocaleNCompare(attribute,"pixel",5) == 0)
1977 +        {
1978 +          int
1979 +            items;
1980 +
1981 +          MagickPixelPacket
1982 +            pixel;
1983 +
1984 +          register IndexPacket
1985 +            *indexes;
1986 +
1987 +          register PixelPacket
1988 +            *q;
1989 +
1990 +          CacheView
1991 +            *image_view;
1992 +
1993 +          for ( ; image; image=image->next)
1994 +          {
1995 +            if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1996 +              break;
1997 +            x=0;
1998 +            y=0;
1999 +            items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
2000 +            (void) items;
2001 +            image_view=AcquireAuthenticCacheView(image,exception);
2002 +            q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
2003 +            indexes=GetCacheViewAuthenticIndexQueue(image_view);
2004 +            if (q != (PixelPacket *) NULL)
2005 +              {
2006 +                if ((strchr(SvPV(sval,na),',') == 0) ||
2007 +                    (strchr(SvPV(sval,na),')') != 0))
2008 +                  QueryMagickColor(SvPV(sval,na),&pixel,exception);
2009 +                else
2010 +                  {
2011 +                    GetMagickPixelPacket(image,&pixel);
2012 +                    flags=ParseGeometry(SvPV(sval,na),&geometry_info);
2013 +                    pixel.red=geometry_info.rho;
2014 +                    if ((flags & SigmaValue) != 0)
2015 +                      pixel.green=geometry_info.sigma;
2016 +                    if ((flags & XiValue) != 0)
2017 +                      pixel.blue=geometry_info.xi;
2018 +                    if ((flags & PsiValue) != 0)
2019 +                      pixel.opacity=geometry_info.psi;
2020 +                    if ((flags & ChiValue) != 0)
2021 +                      pixel.index=geometry_info.chi;
2022 +                  }
2023 +                SetPixelRed(q,ClampToQuantum(pixel.red));
2024 +                SetPixelGreen(q,ClampToQuantum(pixel.green));
2025 +                SetPixelBlue(q,ClampToQuantum(pixel.blue));
2026 +                SetPixelOpacity(q,ClampToQuantum(pixel.opacity));
2027 +                if (((image->colorspace == CMYKColorspace) ||
2028 +                     (image->storage_class == PseudoClass)) &&
2029 +                    (indexes != (IndexPacket *) NULL))
2030 +                  SetPixelIndex(indexes,ClampToQuantum(pixel.index));
2031 +                (void) SyncCacheViewAuthenticPixels(image_view,exception);
2032 +              }
2033 +            image_view=DestroyCacheView(image_view);
2034 +          }
2035 +          break;
2036 +        }
2037 +      if (LocaleCompare(attribute,"pointsize") == 0)
2038 +        {
2039 +          if (info)
2040 +            {
2041 +              (void) ParseGeometry(SvPV(sval,na),&geometry_info);
2042 +              info->image_info->pointsize=geometry_info.rho;
2043 +            }
2044 +          break;
2045 +        }
2046 +      if (LocaleCompare(attribute,"preview") == 0)
2047 +        {
2048 +          sp=SvPOK(sval) ? ParseCommandOption(MagickPreviewOptions,MagickFalse,
2049 +            SvPV(sval,na)) : SvIV(sval);
2050 +          if (sp < 0)
2051 +            {
2052 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
2053 +                SvPV(sval,na));
2054 +              break;
2055 +            }
2056 +          if (info)
2057 +            info->image_info->preview_type=(PreviewType) sp;
2058 +          break;
2059 +        }
2060 +      if (info)
2061 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2062 +      for ( ; image; image=image->next)
2063 +        SetImageProperty(image,attribute,SvPV(sval,na));
2064 +      break;
2065 +    }
2066 +    case 'Q':
2067 +    case 'q':
2068 +    {
2069 +      if (LocaleCompare(attribute,"quality") == 0)
2070 +        {
2071 +          if (info)
2072 +            info->image_info->quality=SvIV(sval);
2073 +          for ( ; image; image=image->next)
2074 +            image->quality=SvIV(sval);
2075 +          break;
2076 +        }
2077 +      if (info)
2078 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2079 +      for ( ; image; image=image->next)
2080 +        SetImageProperty(image,attribute,SvPV(sval,na));
2081 +      break;
2082 +    }
2083 +    case 'R':
2084 +    case 'r':
2085 +    {
2086 +      if (LocaleCompare(attribute,"red-primary") == 0)
2087 +        {
2088 +          for ( ; image; image=image->next)
2089 +          {
2090 +            flags=ParseGeometry(SvPV(sval,na),&geometry_info);
2091 +            image->chromaticity.red_primary.x=geometry_info.rho;
2092 +            image->chromaticity.red_primary.y=geometry_info.sigma;
2093 +            if ((flags & SigmaValue) == 0)
2094 +              image->chromaticity.red_primary.y=
2095 +                image->chromaticity.red_primary.x;
2096 +          }
2097 +          break;
2098 +        }
2099 +      if (LocaleCompare(attribute,"render") == 0)
2100 +        {
2101 +          sp=SvPOK(sval) ? ParseCommandOption(MagickIntentOptions,MagickFalse,
2102 +            SvPV(sval,na)) : SvIV(sval);
2103 +          if (sp < 0)
2104 +            {
2105 +              ThrowPerlException(exception,OptionError,"UnrecognizedIntentType",
2106 +                SvPV(sval,na));
2107 +              break;
2108 +            }
2109 +         for ( ; image; image=image->next)
2110 +           image->rendering_intent=(RenderingIntent) sp;
2111 +         break;
2112 +       }
2113 +      if (LocaleCompare(attribute,"repage") == 0)
2114 +        {
2115 +          RectangleInfo
2116 +            geometry;
2117 +
2118 +          for ( ; image; image=image->next)
2119 +          {
2120 +            flags=ParseAbsoluteGeometry(SvPV(sval,na),&geometry);
2121 +            if ((flags & WidthValue) != 0)
2122 +              {
2123 +                if ((flags & HeightValue) == 0)
2124 +                  geometry.height=geometry.width;
2125 +                image->page.width=geometry.width;
2126 +                image->page.height=geometry.height;
2127 +              }
2128 +            if ((flags & AspectValue) != 0)
2129 +              {
2130 +                if ((flags & XValue) != 0)
2131 +                  image->page.x+=geometry.x;
2132 +                if ((flags & YValue) != 0)
2133 +                  image->page.y+=geometry.y;
2134 +              }
2135 +            else
2136 +              {
2137 +                if ((flags & XValue) != 0)
2138 +                  {
2139 +                    image->page.x=geometry.x;
2140 +                    if (((flags & WidthValue) != 0) && (geometry.x > 0))
2141 +                      image->page.width=image->columns+geometry.x;
2142 +                  }
2143 +                if ((flags & YValue) != 0)
2144 +                  {
2145 +                    image->page.y=geometry.y;
2146 +                    if (((flags & HeightValue) != 0) && (geometry.y > 0))
2147 +                      image->page.height=image->rows+geometry.y;
2148 +                  }
2149 +              }
2150 +          }
2151 +          break;
2152 +        }
2153 +      if (info)
2154 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2155 +      for ( ; image; image=image->next)
2156 +        SetImageProperty(image,attribute,SvPV(sval,na));
2157 +      break;
2158 +    }
2159 +    case 'S':
2160 +    case 's':
2161 +    {
2162 +      if (LocaleCompare(attribute,"sampling-factor") == 0)
2163 +        {
2164 +          if (IsGeometry(SvPV(sval,na)) == MagickFalse)
2165 +            {
2166 +              ThrowPerlException(exception,OptionError,"MissingGeometry",
2167 +                SvPV(sval,na));
2168 +              break;
2169 +            }
2170 +          if (info)
2171 +            (void) CloneString(&info->image_info->sampling_factor,
2172 +              SvPV(sval,na));
2173 +          break;
2174 +        }
2175 +      if (LocaleCompare(attribute,"scene") == 0)
2176 +        {
2177 +          for ( ; image; image=image->next)
2178 +            image->scene=SvIV(sval);
2179 +          break;
2180 +        }
2181 +      if (LocaleCompare(attribute,"subimage") == 0)
2182 +        {
2183 +          if (info)
2184 +            info->image_info->subimage=SvIV(sval);
2185 +          break;
2186 +        }
2187 +      if (LocaleCompare(attribute,"subrange") == 0)
2188 +        {
2189 +          if (info)
2190 +            info->image_info->subrange=SvIV(sval);
2191 +          break;
2192 +        }
2193 +      if (LocaleCompare(attribute,"server") == 0)
2194 +        goto display;
2195 +      if (LocaleCompare(attribute,"size") == 0)
2196 +        {
2197 +          if (info)
2198 +            {
2199 +              if (IsGeometry(SvPV(sval,na)) == MagickFalse)
2200 +                {
2201 +                  ThrowPerlException(exception,OptionError,"MissingGeometry",
2202 +                    SvPV(sval,na));
2203 +                  break;
2204 +                }
2205 +              (void) CloneString(&info->image_info->size,SvPV(sval,na));
2206 +            }
2207 +          break;
2208 +        }
2209 +      if (LocaleCompare(attribute,"stroke") == 0)
2210 +        {
2211 +          if (info)
2212 +            (void) SetImageOption(info->image_info,"stroke",SvPV(sval,na));
2213 +          break;
2214 +        }
2215 +      if (info)
2216 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2217 +      for ( ; image; image=image->next)
2218 +        SetImageProperty(image,attribute,SvPV(sval,na));
2219 +      break;
2220 +    }
2221 +    case 'T':
2222 +    case 't':
2223 +    {
2224 +      if (LocaleCompare(attribute,"texture") == 0)
2225 +        {
2226 +          if (info)
2227 +            (void) CloneString(&info->image_info->texture,SvPV(sval,na));
2228 +          break;
2229 +        }
2230 +      if (LocaleCompare(attribute,"thread-limit") == 0)
2231 +        {
2232 +          MagickSizeType
2233 +            limit;
2234 +
2235 +          limit=MagickResourceInfinity;
2236 +          if (LocaleCompare(SvPV(sval,na),"unlimited") != 0)
2237 +            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
2238 +              100.0);
2239 +          (void) SetMagickResourceLimit(ThreadResource,limit);
2240 +          break;
2241 +        }
2242 +      if (LocaleCompare(attribute,"tile") == 0)
2243 +        {
2244 +          if (info)
2245 +            (void) CloneString(&info->image_info->tile,SvPV(sval,na));
2246 +          break;
2247 +        }
2248 +      if (LocaleCompare(attribute,"tile-offset") == 0)
2249 +        {
2250 +          char
2251 +            *geometry;
2252 +
2253 +          geometry=GetPageGeometry(SvPV(sval,na));
2254 +          if (info)
2255 +            (void) CloneString(&info->image_info->page,geometry);
2256 +          for ( ; image; image=image->next)
2257 +            (void) ParsePageGeometry(image,geometry,&image->tile_offset,
2258 +              exception);
2259 +          geometry=(char *) RelinquishMagickMemory(geometry);
2260 +          break;
2261 +        }
2262 +      if (LocaleCompare(attribute,"time-limit") == 0)
2263 +        {
2264 +          MagickSizeType
2265 +            limit;
2266 +
2267 +          limit=MagickResourceInfinity;
2268 +          if (LocaleCompare(SvPV(sval,na),"unlimited") != 0)
2269 +            limit=(MagickSizeType) SiPrefixToDoubleInterval(SvPV(sval,na),
2270 +              100.0);
2271 +          (void) SetMagickResourceLimit(TimeResource,limit);
2272 +          break;
2273 +        }
2274 +      if (LocaleCompare(attribute,"transparent-color") == 0)
2275 +        {
2276 +          (void) QueryColorDatabase(SvPV(sval,na),&target_color,exception);
2277 +          if (info)
2278 +            info->image_info->transparent_color=target_color;
2279 +          for ( ; image; image=image->next)
2280 +            image->transparent_color=target_color;
2281 +          break;
2282 +        }
2283 +      if (LocaleCompare(attribute,"type") == 0)
2284 +        {
2285 +          sp=SvPOK(sval) ? ParseCommandOption(MagickTypeOptions,MagickFalse,
2286 +            SvPV(sval,na)) : SvIV(sval);
2287 +          if (sp < 0)
2288 +            {
2289 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
2290 +                SvPV(sval,na));
2291 +              break;
2292 +            }
2293 +          if (info)
2294 +            info->image_info->type=(ImageType) sp;
2295 +          for ( ; image; image=image->next)
2296 +            SetImageType(image,(ImageType) sp);
2297 +          break;
2298 +        }
2299 +      if (info)
2300 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2301 +      for ( ; image; image=image->next)
2302 +        SetImageProperty(image,attribute,SvPV(sval,na));
2303 +      break;
2304 +    }
2305 +    case 'U':
2306 +    case 'u':
2307 +    {
2308 +      if (LocaleCompare(attribute,"units") == 0)
2309 +        {
2310 +          sp=SvPOK(sval) ? ParseCommandOption(MagickResolutionOptions,
2311 +            MagickFalse,SvPV(sval,na)) : SvIV(sval);
2312 +          if (sp < 0)
2313 +            {
2314 +              ThrowPerlException(exception,OptionError,"UnrecognizedUnitsType",
2315 +                SvPV(sval,na));
2316 +              break;
2317 +            }
2318 +          if (info)
2319 +            info->image_info->units=(ResolutionType) sp;
2320 +          for ( ; image; image=image->next)
2321 +          {
2322 +            ResolutionType
2323 +              units;
2324 +
2325 +            units=(ResolutionType) sp;
2326 +            if (image->units != units)
2327 +              switch (image->units)
2328 +              {
2329 +                case UndefinedResolution:
2330 +                case PixelsPerInchResolution:
2331 +                {
2332 +                  if (units == PixelsPerCentimeterResolution)
2333 +                    {
2334 +                      image->x_resolution*=2.54;
2335 +                      image->y_resolution*=2.54;
2336 +                    }
2337 +                  break;
2338 +                }
2339 +                case PixelsPerCentimeterResolution:
2340 +                {
2341 +                  if (units == PixelsPerInchResolution)
2342 +                    {
2343 +                      image->x_resolution/=2.54;
2344 +                      image->y_resolution/=2.54;
2345 +                    }
2346 +                  break;
2347 +                }
2348 +              }
2349 +            image->units=units;
2350 +          }
2351 +          break;
2352 +        }
2353 +      if (info)
2354 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2355 +      for ( ; image; image=image->next)
2356 +        SetImageProperty(image,attribute,SvPV(sval,na));
2357 +      break;
2358 +    }
2359 +    case 'V':
2360 +    case 'v':
2361 +    {
2362 +      if (LocaleCompare(attribute,"verbose") == 0)
2363 +        {
2364 +          sp=SvPOK(sval) ? ParseCommandOption(MagickBooleanOptions,MagickFalse,
2365 +            SvPV(sval,na)) : SvIV(sval);
2366 +          if (sp < 0)
2367 +            {
2368 +              ThrowPerlException(exception,OptionError,"UnrecognizedType",
2369 +                SvPV(sval,na));
2370 +              break;
2371 +            }
2372 +          if (info)
2373 +            info->image_info->verbose=sp != 0 ? MagickTrue : MagickFalse;
2374 +          break;
2375 +        }
2376 +      if (LocaleCompare(attribute,"view") == 0)
2377 +        {
2378 +          if (info)
2379 +            (void) CloneString(&info->image_info->view,SvPV(sval,na));
2380 +          break;
2381 +        }
2382 +      if (LocaleCompare(attribute,"virtual-pixel") == 0)
2383 +        {
2384 +          sp=SvPOK(sval) ? ParseCommandOption(MagickVirtualPixelOptions,
2385 +            MagickFalse,SvPV(sval,na)) : SvIV(sval);
2386 +          if (sp < 0)
2387 +            {
2388 +              ThrowPerlException(exception,OptionError,
2389 +                "UnrecognizedVirtualPixelMethod",SvPV(sval,na));
2390 +              break;
2391 +            }
2392 +          if (info)
2393 +            info->image_info->virtual_pixel_method=(VirtualPixelMethod) sp;
2394 +          for ( ; image; image=image->next)
2395 +            SetImageVirtualPixelMethod(image,(VirtualPixelMethod) sp);
2396 +          break;
2397 +        }
2398 +      if (info)
2399 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2400 +      for ( ; image; image=image->next)
2401 +        SetImageProperty(image,attribute,SvPV(sval,na));
2402 +      break;
2403 +    }
2404 +    case 'W':
2405 +    case 'w':
2406 +    {
2407 +      if (LocaleCompare(attribute,"white-point") == 0)
2408 +        {
2409 +          for ( ; image; image=image->next)
2410 +          {
2411 +            flags=ParseGeometry(SvPV(sval,na),&geometry_info);
2412 +            image->chromaticity.white_point.x=geometry_info.rho;
2413 +            image->chromaticity.white_point.y=geometry_info.sigma;
2414 +            if ((flags & SigmaValue) == 0)
2415 +              image->chromaticity.white_point.y=
2416 +                image->chromaticity.white_point.x;
2417 +          }
2418 +          break;
2419 +        }
2420 +      if (info)
2421 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2422 +      for ( ; image; image=image->next)
2423 +        SetImageProperty(image,attribute,SvPV(sval,na));
2424 +      break;
2425 +    }
2426 +    default:
2427 +    {
2428 +      if (info)
2429 +        SetImageOption(info->image_info,attribute,SvPV(sval,na));
2430 +      for ( ; image; image=image->next)
2431 +        SetImageProperty(image,attribute,SvPV(sval,na));
2432 +      break;
2433 +    }
2434 +  }
2435 +}
2436 +\f
2437 +/*
2438 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2439 +%                                                                             %
2440 +%                                                                             %
2441 +%                                                                             %
2442 +%   S e t u p L i s t                                                         %
2443 +%                                                                             %
2444 +%                                                                             %
2445 +%                                                                             %
2446 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2447 +%
2448 +%  Method SetupList returns the list of all the images linked by their
2449 +%  image->next and image->previous link lists for use with ImageMagick.  If
2450 +%  info is non-NULL, an info structure is returned in *info.  If
2451 +%  reference_vector is non-NULL,an array of SV* are returned in
2452 +%  *reference_vector.  Reference_vector is used when the images are going to be
2453 +%  replaced with new Image*'s.
2454 +%
2455 +%  The format of the SetupList routine is:
2456 +%
2457 +%      Image *SetupList(SV *reference,struct PackageInfo **info,
2458 +%        SV ***reference_vector,ExceptionInfo *exception)
2459 +%
2460 +%  A description of each parameter follows:
2461 +%
2462 +%    o list: a list of strings.
2463 +%
2464 +%    o string: a character string.
2465 +%
2466 +%    o exception: Return any errors or warnings in this structure.
2467 +%
2468 +*/
2469 +static Image *SetupList(pTHX_ SV *reference,struct PackageInfo **info,
2470 +  SV ***reference_vector,ExceptionInfo *exception)
2471 +{
2472 +  Image
2473 +    *image;
2474 +
2475 +  ssize_t
2476 +    current,
2477 +    last;
2478 +
2479 +  if (reference_vector)
2480 +    *reference_vector=NULL;
2481 +  if (info)
2482 +    *info=NULL;
2483 +  current=0;
2484 +  last=0;
2485 +  image=GetList(aTHX_ reference,reference_vector,&current,&last,exception);
2486 +  if (info && (SvTYPE(reference) == SVt_PVAV))
2487 +    *info=GetPackageInfo(aTHX_ (void *) reference,(struct PackageInfo *) NULL,
2488 +      exception);
2489 +  return(image);
2490 +}
2491 +\f
2492 +/*
2493 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2494 +%                                                                             %
2495 +%                                                                             %
2496 +%                                                                             %
2497 +%   s t r E Q c a s e                                                         %
2498 +%                                                                             %
2499 +%                                                                             %
2500 +%                                                                             %
2501 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2502 +%
2503 +%  strEQcase() compares two strings and returns 0 if they are the
2504 +%  same or if the second string runs out first.  The comparison is case
2505 +%  insensitive.
2506 +%
2507 +%  The format of the strEQcase routine is:
2508 +%
2509 +%      ssize_t strEQcase(const char *p,const char *q)
2510 +%
2511 +%  A description of each parameter follows:
2512 +%
2513 +%    o p: a character string.
2514 +%
2515 +%    o q: a character string.
2516 +%
2517 +%
2518 +*/
2519 +static ssize_t strEQcase(const char *p,const char *q)
2520 +{
2521 +  char
2522 +    c;
2523 +
2524 +  register ssize_t
2525 +    i;
2526 +
2527 +  for (i=0 ; (c=(*q)) != 0; i++)
2528 +  {
2529 +    if ((isUPPER((unsigned char) c) ? toLOWER(c) : c) !=
2530 +        (isUPPER((unsigned char) *p) ? toLOWER(*p) : *p))
2531 +      return(0);
2532 +    p++;
2533 +    q++;
2534 +  }
2535 +  return(((*q == 0) && (*p == 0)) ? i : 0);
2536 +}
2537 +\f
2538 +/*
2539 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2540 +%                                                                             %
2541 +%                                                                             %
2542 +%                                                                             %
2543 +%   I m a g e : : M a g i c k                                                 %
2544 +%                                                                             %
2545 +%                                                                             %
2546 +%                                                                             %
2547 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2548 +%
2549 +%
2550 +*/
2551 +MODULE = Image::Magick PACKAGE = Image::Magick
2552 +
2553 +PROTOTYPES: ENABLE
2554 +
2555 +BOOT:
2556 +  MagickCoreGenesis("PerlMagick",MagickFalse);
2557 +  SetWarningHandler(NULL);
2558 +  SetErrorHandler(NULL);
2559 +  magick_registry=NewSplayTree((int (*)(const void *,const void *))
2560 +    NULL,(void *(*)(void *)) NULL,(void *(*)(void *)) NULL);
2561 +
2562 +void
2563 +UNLOAD()
2564 +  PPCODE:
2565 +  {
2566 +    if (magick_registry != (SplayTreeInfo *) NULL)
2567 +      magick_registry=DestroySplayTree(magick_registry);
2568 +    MagickCoreTerminus();
2569 +  }
2570 +
2571 +double
2572 +constant(name,argument)
2573 +  char *name
2574 +  ssize_t argument
2575 +\f
2576 +#
2577 +###############################################################################
2578 +#                                                                             #
2579 +#                                                                             #
2580 +#                                                                             #
2581 +#   A n i m a t e                                                             #
2582 +#                                                                             #
2583 +#                                                                             #
2584 +#                                                                             #
2585 +###############################################################################
2586 +#
2587 +#
2588 +void
2589 +Animate(ref,...)
2590 +  Image::Magick ref = NO_INIT
2591 +  ALIAS:
2592 +    AnimateImage  = 1
2593 +    animate       = 2
2594 +    animateimage  = 3
2595 +  PPCODE:
2596 +  {
2597 +    ExceptionInfo
2598 +      *exception;
2599 +
2600 +    Image
2601 +      *image;
2602 +
2603 +    register ssize_t
2604 +      i;
2605 +
2606 +    struct PackageInfo
2607 +      *info,
2608 +      *package_info;
2609 +
2610 +    SV
2611 +      *perl_exception,
2612 +      *reference;
2613 +
2614 +    PERL_UNUSED_VAR(ref);
2615 +    PERL_UNUSED_VAR(ix);
2616 +    exception=AcquireExceptionInfo();
2617 +    perl_exception=newSVpv("",0);
2618 +    package_info=(struct PackageInfo *) NULL;
2619 +    if (sv_isobject(ST(0)) == 0)
2620 +      {
2621 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
2622 +          PackageName);
2623 +        goto PerlException;
2624 +      }
2625 +    reference=SvRV(ST(0));
2626 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
2627 +    if (image == (Image *) NULL)
2628 +      {
2629 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
2630 +          PackageName);
2631 +        goto PerlException;
2632 +      }
2633 +    package_info=ClonePackageInfo(info,exception);
2634 +    if (items == 2)
2635 +      SetAttribute(aTHX_ package_info,NULL,"server",ST(1),exception);
2636 +    else
2637 +      if (items > 2)
2638 +        for (i=2; i < items; i+=2)
2639 +          SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),
2640 +            exception);
2641 +    (void) AnimateImages(package_info->image_info,image);
2642 +    (void) CatchImageException(image);
2643 +    InheritException(exception,&image->exception);
2644 +
2645 +  PerlException:
2646 +    if (package_info != (struct PackageInfo *) NULL)
2647 +      DestroyPackageInfo(package_info);
2648 +    InheritPerlException(exception,perl_exception);
2649 +    exception=DestroyExceptionInfo(exception);
2650 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
2651 +    SvPOK_on(perl_exception);
2652 +    ST(0)=sv_2mortal(perl_exception);
2653 +    XSRETURN(1);
2654 +  }
2655 +\f
2656 +#
2657 +###############################################################################
2658 +#                                                                             #
2659 +#                                                                             #
2660 +#                                                                             #
2661 +#   A p p e n d                                                               #
2662 +#                                                                             #
2663 +#                                                                             #
2664 +#                                                                             #
2665 +###############################################################################
2666 +#
2667 +#
2668 +void
2669 +Append(ref,...)
2670 +  Image::Magick ref = NO_INIT
2671 +  ALIAS:
2672 +    AppendImage  = 1
2673 +    append       = 2
2674 +    appendimage  = 3
2675 +  PPCODE:
2676 +  {
2677 +    AV
2678 +      *av;
2679 +
2680 +    char
2681 +      *attribute;
2682 +
2683 +    ExceptionInfo
2684 +      *exception;
2685 +
2686 +    HV
2687 +      *hv;
2688 +
2689 +    Image
2690 +      *image;
2691 +
2692 +    register ssize_t
2693 +      i;
2694 +
2695 +    ssize_t
2696 +      stack;
2697 +
2698 +    struct PackageInfo
2699 +      *info;
2700 +
2701 +    SV
2702 +      *av_reference,
2703 +      *perl_exception,
2704 +      *reference,
2705 +      *rv,
2706 +      *sv;
2707 +
2708 +    PERL_UNUSED_VAR(ref);
2709 +    PERL_UNUSED_VAR(ix);
2710 +    exception=AcquireExceptionInfo();
2711 +    perl_exception=newSVpv("",0);
2712 +    sv=NULL;
2713 +    attribute=NULL;
2714 +    av=NULL;
2715 +    if (sv_isobject(ST(0)) == 0)
2716 +      {
2717 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
2718 +          PackageName);
2719 +        goto PerlException;
2720 +      }
2721 +    reference=SvRV(ST(0));
2722 +    hv=SvSTASH(reference);
2723 +    av=newAV();
2724 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
2725 +    SvREFCNT_dec(av);
2726 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
2727 +    if (image == (Image *) NULL)
2728 +      {
2729 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
2730 +          PackageName);
2731 +        goto PerlException;
2732 +      }
2733 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
2734 +    /*
2735 +      Get options.
2736 +    */
2737 +    stack=MagickTrue;
2738 +    for (i=2; i < items; i+=2)
2739 +    {
2740 +      attribute=(char *) SvPV(ST(i-1),na);
2741 +      switch (*attribute)
2742 +      {
2743 +        case 'S':
2744 +        case 's':
2745 +        {
2746 +          if (LocaleCompare(attribute,"stack") == 0)
2747 +            {
2748 +              stack=ParseCommandOption(MagickBooleanOptions,MagickFalse,
2749 +                SvPV(ST(i),na));
2750 +              if (stack < 0)
2751 +                {
2752 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
2753 +                    SvPV(ST(i),na));
2754 +                  return;
2755 +                }
2756 +              break;
2757 +            }
2758 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
2759 +            attribute);
2760 +          break;
2761 +        }
2762 +        default:
2763 +        {
2764 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
2765 +            attribute);
2766 +          break;
2767 +        }
2768 +      }
2769 +    }
2770 +    image=AppendImages(image,stack != 0 ? MagickTrue : MagickFalse,exception);
2771 +    if (image == (Image *) NULL)
2772 +      goto PerlException;
2773 +    for ( ; image; image=image->next)
2774 +    {
2775 +      AddImageToRegistry(sv,image);
2776 +      rv=newRV(sv);
2777 +      av_push(av,sv_bless(rv,hv));
2778 +      SvREFCNT_dec(sv);
2779 +    }
2780 +    exception=DestroyExceptionInfo(exception);
2781 +    ST(0)=av_reference;
2782 +    SvREFCNT_dec(perl_exception);
2783 +    XSRETURN(1);
2784 +
2785 +  PerlException:
2786 +    InheritPerlException(exception,perl_exception);
2787 +    exception=DestroyExceptionInfo(exception);
2788 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
2789 +    SvPOK_on(perl_exception);
2790 +    ST(0)=sv_2mortal(perl_exception);
2791 +    XSRETURN(1);
2792 +  }
2793 +\f
2794 +#
2795 +###############################################################################
2796 +#                                                                             #
2797 +#                                                                             #
2798 +#                                                                             #
2799 +#   A v e r a g e                                                             #
2800 +#                                                                             #
2801 +#                                                                             #
2802 +#                                                                             #
2803 +###############################################################################
2804 +#
2805 +#
2806 +void
2807 +Average(ref)
2808 +  Image::Magick ref = NO_INIT
2809 +  ALIAS:
2810 +    AverageImage   = 1
2811 +    average        = 2
2812 +    averageimage   = 3
2813 +  PPCODE:
2814 +  {
2815 +    AV
2816 +      *av;
2817 +
2818 +    char
2819 +      *p;
2820 +
2821 +    ExceptionInfo
2822 +      *exception;
2823 +
2824 +    HV
2825 +      *hv;
2826 +
2827 +    Image
2828 +      *image;
2829 +
2830 +    struct PackageInfo
2831 +      *info;
2832 +
2833 +    SV
2834 +      *perl_exception,
2835 +      *reference,
2836 +      *rv,
2837 +      *sv;
2838 +
2839 +    PERL_UNUSED_VAR(ref);
2840 +    PERL_UNUSED_VAR(ix);
2841 +    exception=AcquireExceptionInfo();
2842 +    perl_exception=newSVpv("",0);
2843 +    sv=NULL;
2844 +    if (sv_isobject(ST(0)) == 0)
2845 +      {
2846 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
2847 +          PackageName);
2848 +        goto PerlException;
2849 +      }
2850 +    reference=SvRV(ST(0));
2851 +    hv=SvSTASH(reference);
2852 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
2853 +    if (image == (Image *) NULL)
2854 +      {
2855 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
2856 +          PackageName);
2857 +        goto PerlException;
2858 +      }
2859 +    image=EvaluateImages(image,MeanEvaluateOperator,exception);
2860 +    if (image == (Image *) NULL)
2861 +      goto PerlException;
2862 +    /*
2863 +      Create blessed Perl array for the returned image.
2864 +    */
2865 +    av=newAV();
2866 +    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
2867 +    SvREFCNT_dec(av);
2868 +    AddImageToRegistry(sv,image);
2869 +    rv=newRV(sv);
2870 +    av_push(av,sv_bless(rv,hv));
2871 +    SvREFCNT_dec(sv);
2872 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
2873 +    (void) FormatLocaleString(info->image_info->filename,MaxTextExtent,
2874 +      "average-%.*s",(int) (MaxTextExtent-9),
2875 +      ((p=strrchr(image->filename,'/')) ? p+1 : image->filename));
2876 +    (void) CopyMagickString(image->filename,info->image_info->filename,
2877 +      MaxTextExtent);
2878 +    SetImageInfo(info->image_info,0,exception);
2879 +    exception=DestroyExceptionInfo(exception);
2880 +    SvREFCNT_dec(perl_exception);
2881 +    XSRETURN(1);
2882 +
2883 +  PerlException:
2884 +    InheritPerlException(exception,perl_exception);
2885 +    exception=DestroyExceptionInfo(exception);
2886 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
2887 +    SvPOK_on(perl_exception);
2888 +    ST(0)=sv_2mortal(perl_exception);
2889 +    XSRETURN(1);
2890 +  }
2891 +\f
2892 +#
2893 +###############################################################################
2894 +#                                                                             #
2895 +#                                                                             #
2896 +#                                                                             #
2897 +#   B l o b T o I m a g e                                                     #
2898 +#                                                                             #
2899 +#                                                                             #
2900 +#                                                                             #
2901 +###############################################################################
2902 +#
2903 +#
2904 +void
2905 +BlobToImage(ref,...)
2906 +  Image::Magick ref = NO_INIT
2907 +  ALIAS:
2908 +    BlobToImage  = 1
2909 +    blobtoimage  = 2
2910 +    blobto       = 3
2911 +  PPCODE:
2912 +  {
2913 +    AV
2914 +      *av;
2915 +
2916 +    char
2917 +      **keep,
2918 +      **list;
2919 +
2920 +    ExceptionInfo
2921 +      *exception;
2922 +
2923 +    HV
2924 +      *hv;
2925 +
2926 +    Image
2927 +      *image;
2928 +
2929 +    register char
2930 +      **p;
2931 +
2932 +    register ssize_t
2933 +      i;
2934 +
2935 +    ssize_t
2936 +      ac,
2937 +      n,
2938 +      number_images;
2939 +
2940 +    STRLEN
2941 +      *length;
2942 +
2943 +    struct PackageInfo
2944 +      *info;
2945 +
2946 +    SV
2947 +      *perl_exception,
2948 +      *reference,
2949 +      *rv,
2950 +      *sv;
2951 +
2952 +    PERL_UNUSED_VAR(ref);
2953 +    PERL_UNUSED_VAR(ix);
2954 +    exception=AcquireExceptionInfo();
2955 +    perl_exception=newSVpv("",0);
2956 +    sv=NULL;
2957 +    number_images=0;
2958 +    ac=(items < 2) ? 1 : items-1;
2959 +    length=(STRLEN *) NULL;
2960 +    list=(char **) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*list));
2961 +    if (list == (char **) NULL)
2962 +      {
2963 +        ThrowPerlException(exception,ResourceLimitError,
2964 +          "MemoryAllocationFailed",PackageName);
2965 +        goto PerlException;
2966 +      }
2967 +    length=(STRLEN *) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*length));
2968 +    if (length == (STRLEN *) NULL)
2969 +      {
2970 +        ThrowPerlException(exception,ResourceLimitError,
2971 +          "MemoryAllocationFailed",PackageName);
2972 +        goto PerlException;
2973 +      }
2974 +    if (sv_isobject(ST(0)) == 0)
2975 +      {
2976 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
2977 +          PackageName);
2978 +        goto PerlException;
2979 +      }
2980 +    reference=SvRV(ST(0));
2981 +    hv=SvSTASH(reference);
2982 +    if (SvTYPE(reference) != SVt_PVAV)
2983 +      {
2984 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
2985 +          PackageName);
2986 +        goto PerlException;
2987 +      }
2988 +    av=(AV *) reference;
2989 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
2990 +      exception);
2991 +    n=1;
2992 +    if (items <= 1)
2993 +      {
2994 +        ThrowPerlException(exception,OptionError,"NoBlobDefined",PackageName);
2995 +        goto PerlException;
2996 +      }
2997 +    for (n=0, i=0; i < ac; i++)
2998 +    {
2999 +      list[n]=(char *) (SvPV(ST(i+1),length[n]));
3000 +      if ((items >= 3) && strEQcase((char *) SvPV(ST(i+1),na),"blob"))
3001 +        {
3002 +          list[n]=(char *) (SvPV(ST(i+2),length[n]));
3003 +          continue;
3004 +        }
3005 +      n++;
3006 +    }
3007 +    list[n]=(char *) NULL;
3008 +    keep=list;
3009 +    for (i=number_images=0; i < n; i++)
3010 +    {
3011 +      image=BlobToImage(info->image_info,list[i],length[i],exception);
3012 +      if (image == (Image *) NULL)
3013 +        break;
3014 +      for ( ; image; image=image->next)
3015 +      {
3016 +        AddImageToRegistry(sv,image);
3017 +        rv=newRV(sv);
3018 +        av_push(av,sv_bless(rv,hv));
3019 +        SvREFCNT_dec(sv);
3020 +        number_images++;
3021 +      }
3022 +    }
3023 +    /*
3024 +      Free resources.
3025 +    */
3026 +    for (i=0; i < n; i++)
3027 +      if (list[i] != (char *) NULL)
3028 +        for (p=keep; list[i] != *p++; )
3029 +          if (*p == (char *) NULL)
3030 +            {
3031 +              list[i]=(char *) RelinquishMagickMemory(list[i]);
3032 +              break;
3033 +            }
3034 +
3035 +  PerlException:
3036 +    if (list)
3037 +      list=(char **) RelinquishMagickMemory(list);
3038 +    if (length)
3039 +      length=(STRLEN *) RelinquishMagickMemory(length);
3040 +    InheritPerlException(exception,perl_exception);
3041 +    exception=DestroyExceptionInfo(exception);
3042 +    sv_setiv(perl_exception,(IV) number_images);
3043 +    SvPOK_on(perl_exception);
3044 +    ST(0)=sv_2mortal(perl_exception);
3045 +    XSRETURN(1);
3046 +  }
3047 +\f
3048 +#
3049 +###############################################################################
3050 +#                                                                             #
3051 +#                                                                             #
3052 +#                                                                             #
3053 +#   C l o n e                                                                 #
3054 +#                                                                             #
3055 +#                                                                             #
3056 +#                                                                             #
3057 +###############################################################################
3058 +#
3059 +#
3060 +void
3061 +Clone(ref)
3062 +  Image::Magick ref = NO_INIT
3063 +  ALIAS:
3064 +    CopyImage   = 1
3065 +    copy        = 2
3066 +    copyimage   = 3
3067 +    CloneImage  = 4
3068 +    clone       = 5
3069 +    cloneimage  = 6
3070 +    Clone       = 7
3071 +  PPCODE:
3072 +  {
3073 +    AV
3074 +      *av;
3075 +
3076 +    ExceptionInfo
3077 +      *exception;
3078 +
3079 +    HV
3080 +      *hv;
3081 +
3082 +    Image
3083 +      *clone,
3084 +      *image;
3085 +
3086 +    struct PackageInfo
3087 +      *info;
3088 +
3089 +    SV
3090 +      *perl_exception,
3091 +      *reference,
3092 +      *rv,
3093 +      *sv;
3094 +
3095 +    PERL_UNUSED_VAR(ref);
3096 +    PERL_UNUSED_VAR(ix);
3097 +    exception=AcquireExceptionInfo();
3098 +    perl_exception=newSVpv("",0);
3099 +    sv=NULL;
3100 +    if (sv_isobject(ST(0)) == 0)
3101 +      {
3102 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3103 +          PackageName);
3104 +        goto PerlException;
3105 +      }
3106 +    reference=SvRV(ST(0));
3107 +    hv=SvSTASH(reference);
3108 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3109 +    if (image == (Image *) NULL)
3110 +      {
3111 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3112 +          PackageName);
3113 +        goto PerlException;
3114 +      }
3115 +    /*
3116 +      Create blessed Perl array for the returned image.
3117 +    */
3118 +    av=newAV();
3119 +    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
3120 +    SvREFCNT_dec(av);
3121 +    for ( ; image; image=image->next)
3122 +    {
3123 +      clone=CloneImage(image,0,0,MagickTrue,exception);
3124 +      if (clone == (Image *) NULL)
3125 +        break;
3126 +      AddImageToRegistry(sv,clone);
3127 +      rv=newRV(sv);
3128 +      av_push(av,sv_bless(rv,hv));
3129 +      SvREFCNT_dec(sv);
3130 +    }
3131 +    exception=DestroyExceptionInfo(exception);
3132 +    SvREFCNT_dec(perl_exception);
3133 +    XSRETURN(1);
3134 +
3135 +  PerlException:
3136 +    InheritPerlException(exception,perl_exception);
3137 +    exception=DestroyExceptionInfo(exception);
3138 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
3139 +    SvPOK_on(perl_exception);
3140 +    ST(0)=sv_2mortal(perl_exception);
3141 +    XSRETURN(1);
3142 +  }
3143 +\f
3144 +#
3145 +###############################################################################
3146 +#                                                                             #
3147 +#                                                                             #
3148 +#                                                                             #
3149 +#   C L O N E                                                                 #
3150 +#                                                                             #
3151 +#                                                                             #
3152 +#                                                                             #
3153 +###############################################################################
3154 +#
3155 +#
3156 +void
3157 +CLONE(ref,...)
3158 +  SV *ref;
3159 +  CODE:
3160 +  {
3161 +    PERL_UNUSED_VAR(ref);
3162 +    if (magick_registry != (SplayTreeInfo *) NULL)
3163 +      {
3164 +        register Image
3165 +          *p;
3166 +
3167 +        ResetSplayTreeIterator(magick_registry);
3168 +        p=(Image *) GetNextKeyInSplayTree(magick_registry);
3169 +        while (p != (Image *) NULL)
3170 +        {
3171 +          ReferenceImage(p);
3172 +          p=(Image *) GetNextKeyInSplayTree(magick_registry);
3173 +        }
3174 +      }
3175 +  }
3176 +\f
3177 +#
3178 +###############################################################################
3179 +#                                                                             #
3180 +#                                                                             #
3181 +#                                                                             #
3182 +#   C o a l e s c e                                                           #
3183 +#                                                                             #
3184 +#                                                                             #
3185 +#                                                                             #
3186 +###############################################################################
3187 +#
3188 +#
3189 +void
3190 +Coalesce(ref)
3191 +  Image::Magick ref = NO_INIT
3192 +  ALIAS:
3193 +    CoalesceImage   = 1
3194 +    coalesce        = 2
3195 +    coalesceimage   = 3
3196 +  PPCODE:
3197 +  {
3198 +    AV
3199 +      *av;
3200 +
3201 +    ExceptionInfo
3202 +      *exception;
3203 +
3204 +    HV
3205 +      *hv;
3206 +
3207 +    Image
3208 +      *image;
3209 +
3210 +    struct PackageInfo
3211 +      *info;
3212 +
3213 +    SV
3214 +      *av_reference,
3215 +      *perl_exception,
3216 +      *reference,
3217 +      *rv,
3218 +      *sv;
3219 +
3220 +    PERL_UNUSED_VAR(ref);
3221 +    PERL_UNUSED_VAR(ix);
3222 +    exception=AcquireExceptionInfo();
3223 +    perl_exception=newSVpv("",0);
3224 +    sv=NULL;
3225 +    if (sv_isobject(ST(0)) == 0)
3226 +      {
3227 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3228 +          PackageName);
3229 +        goto PerlException;
3230 +      }
3231 +    reference=SvRV(ST(0));
3232 +    hv=SvSTASH(reference);
3233 +    av=newAV();
3234 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
3235 +    SvREFCNT_dec(av);
3236 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3237 +    if (image == (Image *) NULL)
3238 +      {
3239 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3240 +          PackageName);
3241 +        goto PerlException;
3242 +      }
3243 +    image=CoalesceImages(image,exception);
3244 +    if (image == (Image *) NULL)
3245 +      goto PerlException;
3246 +    for ( ; image; image=image->next)
3247 +    {
3248 +      AddImageToRegistry(sv,image);
3249 +      rv=newRV(sv);
3250 +      av_push(av,sv_bless(rv,hv));
3251 +      SvREFCNT_dec(sv);
3252 +    }
3253 +    exception=DestroyExceptionInfo(exception);
3254 +    ST(0)=av_reference;
3255 +    SvREFCNT_dec(perl_exception);
3256 +    XSRETURN(1);
3257 +
3258 +  PerlException:
3259 +    InheritPerlException(exception,perl_exception);
3260 +    exception=DestroyExceptionInfo(exception);
3261 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
3262 +    SvPOK_on(perl_exception);
3263 +    ST(0)=sv_2mortal(perl_exception);
3264 +    XSRETURN(1);
3265 +  }
3266 +\f
3267 +#
3268 +###############################################################################
3269 +#                                                                             #
3270 +#                                                                             #
3271 +#                                                                             #
3272 +#   C o m p a r e                                                             #
3273 +#                                                                             #
3274 +#                                                                             #
3275 +#                                                                             #
3276 +###############################################################################
3277 +#
3278 +#
3279 +void
3280 +Compare(ref,...)
3281 +  Image::Magick ref = NO_INIT
3282 +  ALIAS:
3283 +    CompareImage = 1
3284 +    compare      = 2
3285 +    compareimage = 3
3286 +  PPCODE:
3287 +  {
3288 +    AV
3289 +      *av;
3290 +
3291 +    char
3292 +      *attribute;
3293 +
3294 +    ChannelType
3295 +      channel;
3296 +
3297 +    double
3298 +      distortion;
3299 +
3300 +    ExceptionInfo
3301 +      *exception;
3302 +
3303 +    HV
3304 +      *hv;
3305 +
3306 +    Image
3307 +      *difference_image,
3308 +      *image,
3309 +      *reconstruct_image;
3310 +
3311 +    MetricType
3312 +      metric;
3313 +
3314 +    register ssize_t
3315 +      i;
3316 +
3317 +    ssize_t
3318 +      option;
3319 +
3320 +    struct PackageInfo
3321 +      *info;
3322 +
3323 +    SV
3324 +      *av_reference,
3325 +      *perl_exception,
3326 +      *reference,
3327 +      *rv,
3328 +      *sv;
3329 +
3330 +    PERL_UNUSED_VAR(ref);
3331 +    PERL_UNUSED_VAR(ix);
3332 +    exception=AcquireExceptionInfo();
3333 +    perl_exception=newSVpv("",0);
3334 +    sv=NULL;
3335 +    av=NULL;
3336 +    attribute=NULL;
3337 +    if (sv_isobject(ST(0)) == 0)
3338 +      {
3339 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3340 +          PackageName);
3341 +        goto PerlException;
3342 +      }
3343 +    reference=SvRV(ST(0));
3344 +    hv=SvSTASH(reference);
3345 +    av=newAV();
3346 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
3347 +    SvREFCNT_dec(av);
3348 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3349 +    if (image == (Image *) NULL)
3350 +      {
3351 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3352 +          PackageName);
3353 +        goto PerlException;
3354 +      }
3355 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
3356 +    /*
3357 +      Get attribute.
3358 +    */
3359 +    channel=DefaultChannels;
3360 +    reconstruct_image=image;
3361 +    metric=RootMeanSquaredErrorMetric;
3362 +    for (i=2; i < items; i+=2)
3363 +    {
3364 +      attribute=(char *) SvPV(ST(i-1),na);
3365 +      switch (*attribute)
3366 +      {
3367 +        case 'C':
3368 +        case 'c':
3369 +        {
3370 +          if (LocaleCompare(attribute,"channel") == 0)
3371 +            {
3372 +              ssize_t
3373 +                option;
3374 +
3375 +              option=ParseChannelOption(SvPV(ST(i),na));
3376 +              if (option < 0)
3377 +                {
3378 +                  ThrowPerlException(exception,OptionError,
3379 +                    "UnrecognizedType",SvPV(ST(i),na));
3380 +                  return;
3381 +                }
3382 +              channel=(ChannelType) option;
3383 +              break;
3384 +            }
3385 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3386 +            attribute);
3387 +          break;
3388 +        }
3389 +        case 'F':
3390 +        case 'f':
3391 +        {
3392 +          if (LocaleCompare(attribute,"fuzz") == 0)
3393 +            {
3394 +              image->fuzz=StringToDoubleInterval(SvPV(ST(i),na),100.0);
3395 +              break;
3396 +            }
3397 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3398 +            attribute);
3399 +          break;
3400 +        }
3401 +        case 'I':
3402 +        case 'i':
3403 +        {
3404 +          if (LocaleCompare(attribute,"image") == 0)
3405 +            {
3406 +              reconstruct_image=SetupList(aTHX_ SvRV(ST(i)),
3407 +                (struct PackageInfo **) NULL,(SV ***) NULL,exception);
3408 +              break;
3409 +            }
3410 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3411 +            attribute);
3412 +          break;
3413 +        }
3414 +        case 'M':
3415 +        case 'm':
3416 +        {
3417 +          if (LocaleCompare(attribute,"metric") == 0)
3418 +            {
3419 +              option=ParseCommandOption(MagickMetricOptions,MagickFalse,
3420 +                SvPV(ST(i),na));
3421 +              if (option < 0)
3422 +                {
3423 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
3424 +                    SvPV(ST(i),na));
3425 +                  break;
3426 +                }
3427 +              metric=(MetricType) option;
3428 +              break;
3429 +            }
3430 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3431 +            attribute);
3432 +          break;
3433 +        }
3434 +        default:
3435 +        {
3436 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3437 +            attribute);
3438 +          break;
3439 +        }
3440 +      }
3441 +    }
3442 +    difference_image=CompareImageChannels(image,reconstruct_image,channel,
3443 +      metric,&distortion,exception);
3444 +    if (difference_image != (Image *) NULL)
3445 +      {
3446 +        difference_image->error.mean_error_per_pixel=distortion;
3447 +        AddImageToRegistry(sv,difference_image);
3448 +        rv=newRV(sv);
3449 +        av_push(av,sv_bless(rv,hv));
3450 +        SvREFCNT_dec(sv);
3451 +      }
3452 +    exception=DestroyExceptionInfo(exception);
3453 +    ST(0)=av_reference;
3454 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
3455 +    XSRETURN(1);
3456 +
3457 +  PerlException:
3458 +    InheritPerlException(exception,perl_exception);
3459 +    exception=DestroyExceptionInfo(exception);
3460 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
3461 +    SvPOK_on(perl_exception);
3462 +    ST(0)=sv_2mortal(perl_exception);
3463 +    XSRETURN(1);
3464 +  }
3465 +\f
3466 +#
3467 +###############################################################################
3468 +#                                                                             #
3469 +#                                                                             #
3470 +#                                                                             #
3471 +#   C o m p a r e L a y e r s                                                 #
3472 +#                                                                             #
3473 +#                                                                             #
3474 +#                                                                             #
3475 +###############################################################################
3476 +#
3477 +#
3478 +void
3479 +CompareLayers(ref)
3480 +  Image::Magick ref = NO_INIT
3481 +  ALIAS:
3482 +    CompareImageLayers   = 1
3483 +    comparelayers        = 2
3484 +    compareimagelayers   = 3
3485 +  PPCODE:
3486 +  {
3487 +    AV
3488 +      *av;
3489 +
3490 +    char
3491 +      *attribute;
3492 +
3493 +    ExceptionInfo
3494 +      *exception;
3495 +
3496 +    HV
3497 +      *hv;
3498 +
3499 +    Image
3500 +      *image;
3501 +
3502 +    ImageLayerMethod
3503 +      method;
3504 +
3505 +    register ssize_t
3506 +      i;
3507 +
3508 +    ssize_t
3509 +      option;
3510 +
3511 +    struct PackageInfo
3512 +      *info;
3513 +
3514 +    SV
3515 +      *av_reference,
3516 +      *perl_exception,
3517 +      *reference,
3518 +      *rv,
3519 +      *sv;
3520 +
3521 +    PERL_UNUSED_VAR(ref);
3522 +    PERL_UNUSED_VAR(ix);
3523 +    exception=AcquireExceptionInfo();
3524 +    perl_exception=newSVpv("",0);
3525 +    sv=NULL;
3526 +    if (sv_isobject(ST(0)) == 0)
3527 +      {
3528 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3529 +          PackageName);
3530 +        goto PerlException;
3531 +      }
3532 +    reference=SvRV(ST(0));
3533 +    hv=SvSTASH(reference);
3534 +    av=newAV();
3535 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
3536 +    SvREFCNT_dec(av);
3537 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3538 +    if (image == (Image *) NULL)
3539 +      {
3540 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3541 +          PackageName);
3542 +        goto PerlException;
3543 +      }
3544 +    method=CompareAnyLayer;
3545 +    for (i=2; i < items; i+=2)
3546 +    {
3547 +      attribute=(char *) SvPV(ST(i-1),na);
3548 +      switch (*attribute)
3549 +      {
3550 +        case 'M':
3551 +        case 'm':
3552 +        {
3553 +          if (LocaleCompare(attribute,"method") == 0)
3554 +            {
3555 +              option=ParseCommandOption(MagickLayerOptions,MagickFalse,
3556 +                SvPV(ST(i),na));
3557 +              if (option < 0)
3558 +                {
3559 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
3560 +                    SvPV(ST(i),na));
3561 +                  break;
3562 +                }
3563 +               method=(ImageLayerMethod) option;
3564 +              break;
3565 +            }
3566 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3567 +            attribute);
3568 +          break;
3569 +        }
3570 +        default:
3571 +        {
3572 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3573 +            attribute);
3574 +          break;
3575 +        }
3576 +      }
3577 +    }
3578 +    image=CompareImageLayers(image,method,exception);
3579 +    if (image == (Image *) NULL)
3580 +      goto PerlException;
3581 +    for ( ; image; image=image->next)
3582 +    {
3583 +      AddImageToRegistry(sv,image);
3584 +      rv=newRV(sv);
3585 +      av_push(av,sv_bless(rv,hv));
3586 +      SvREFCNT_dec(sv);
3587 +    }
3588 +    exception=DestroyExceptionInfo(exception);
3589 +    ST(0)=av_reference;
3590 +    SvREFCNT_dec(perl_exception);
3591 +    XSRETURN(1);
3592 +
3593 +  PerlException:
3594 +    InheritPerlException(exception,perl_exception);
3595 +    exception=DestroyExceptionInfo(exception);
3596 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
3597 +    SvPOK_on(perl_exception);
3598 +    ST(0)=sv_2mortal(perl_exception);
3599 +    XSRETURN(1);
3600 +  }
3601 +\f
3602 +#
3603 +###############################################################################
3604 +#                                                                             #
3605 +#                                                                             #
3606 +#                                                                             #
3607 +#   C o m p l e x I m a g e s                                                 #
3608 +#                                                                             #
3609 +#                                                                             #
3610 +#                                                                             #
3611 +###############################################################################
3612 +#
3613 +#
3614 +void
3615 +ComplexImages(ref)
3616 +  Image::Magick ref = NO_INIT
3617 +  ALIAS:
3618 +    ComplexImages   = 1
3619 +    compleximages   = 2
3620 +  PPCODE:
3621 +  {
3622 +    AV
3623 +      *av;
3624 +
3625 +    char
3626 +      *attribute,
3627 +      *p;
3628 +
3629 +    ExceptionInfo
3630 +      *exception;
3631 +
3632 +    HV
3633 +      *hv;
3634 +
3635 +    Image
3636 +      *image;
3637 +
3638 +    ComplexOperator
3639 +      op;
3640 +
3641 +    register ssize_t
3642 +      i;
3643 +
3644 +    struct PackageInfo
3645 +      *info;
3646 +
3647 +    SV
3648 +      *perl_exception,
3649 +      *reference,
3650 +      *rv,
3651 +      *sv;
3652 +
3653 +    PERL_UNUSED_VAR(ref);
3654 +    PERL_UNUSED_VAR(ix);
3655 +    exception=AcquireExceptionInfo();
3656 +    perl_exception=newSVpv("",0);
3657 +    sv=NULL;
3658 +    if (sv_isobject(ST(0)) == 0)
3659 +      {
3660 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3661 +          PackageName);
3662 +        goto PerlException;
3663 +      }
3664 +    reference=SvRV(ST(0));
3665 +    hv=SvSTASH(reference);
3666 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3667 +    if (image == (Image *) NULL)
3668 +      {
3669 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3670 +          PackageName);
3671 +        goto PerlException;
3672 +      }
3673 +    op=UndefinedComplexOperator;
3674 +    if (items == 2)
3675 +      {
3676 +        ssize_t
3677 +          in;
3678 +
3679 +        in=ParseCommandOption(MagickComplexOptions,MagickFalse,(char *)
3680 +          SvPV(ST(1),na));
3681 +        if (in < 0)
3682 +          {
3683 +            ThrowPerlException(exception,OptionError,"UnrecognizedType",
3684 +              SvPV(ST(1),na));
3685 +            return;
3686 +          }
3687 +        op=(ComplexOperator) in;
3688 +      }
3689 +    else
3690 +      for (i=2; i < items; i+=2)
3691 +      {
3692 +        attribute=(char *) SvPV(ST(i-1),na);
3693 +        switch (*attribute)
3694 +        {
3695 +          case 'O':
3696 +          case 'o':
3697 +          {
3698 +            if (LocaleCompare(attribute,"operator") == 0)
3699 +              {
3700 +                ssize_t
3701 +                  in;
3702 +
3703 +                in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
3704 +                  MagickComplexOptions,MagickFalse,SvPV(ST(i),na));
3705 +                if (in < 0)
3706 +                  {
3707 +                    ThrowPerlException(exception,OptionError,"UnrecognizedType",
3708 +                      SvPV(ST(i),na));
3709 +                    return;
3710 +                  }
3711 +                op=(ComplexOperator) in;
3712 +                break;
3713 +              }
3714 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3715 +              attribute);
3716 +            break;
3717 +          }
3718 +          default:
3719 +          {
3720 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
3721 +              attribute);
3722 +            break;
3723 +          }
3724 +        }
3725 +      }
3726 +    image=ComplexImages(image,op,exception);
3727 +    if (image == (Image *) NULL)
3728 +      goto PerlException;
3729 +    /*
3730 +      Create blessed Perl array for the returned image.
3731 +    */
3732 +    av=newAV();
3733 +    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
3734 +    SvREFCNT_dec(av);
3735 +    AddImageToRegistry(sv,image);
3736 +    rv=newRV(sv);
3737 +    av_push(av,sv_bless(rv,hv));
3738 +    SvREFCNT_dec(sv);
3739 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
3740 +    (void) FormatLocaleString(info->image_info->filename,MaxTextExtent,
3741 +      "complex-%.*s",(int) (MaxTextExtent-9),
3742 +      ((p=strrchr(image->filename,'/')) ? p+1 : image->filename));
3743 +    (void) CopyMagickString(image->filename,info->image_info->filename,
3744 +      MaxTextExtent);
3745 +    SetImageInfo(info->image_info,0,exception);
3746 +    exception=DestroyExceptionInfo(exception);
3747 +    SvREFCNT_dec(perl_exception);
3748 +    XSRETURN(1);
3749 +
3750 +  PerlException:
3751 +    InheritPerlException(exception,perl_exception);
3752 +    exception=DestroyExceptionInfo(exception);
3753 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
3754 +    SvPOK_on(perl_exception);
3755 +    ST(0)=sv_2mortal(perl_exception);
3756 +    XSRETURN(1);
3757 +  }
3758 +\f
3759 +#
3760 +###############################################################################
3761 +#                                                                             #
3762 +#                                                                             #
3763 +#                                                                             #
3764 +#   D e s t r o y                                                             #
3765 +#                                                                             #
3766 +#                                                                             #
3767 +#                                                                             #
3768 +###############################################################################
3769 +#
3770 +#
3771 +void
3772 +DESTROY(ref)
3773 +  Image::Magick ref = NO_INIT
3774 +  PPCODE:
3775 +  {
3776 +    SV
3777 +      *reference;
3778 +
3779 +    PERL_UNUSED_VAR(ref);
3780 +    if (sv_isobject(ST(0)) == 0)
3781 +      croak("ReferenceIsNotMyType");
3782 +    reference=SvRV(ST(0));
3783 +    switch (SvTYPE(reference))
3784 +    {
3785 +      case SVt_PVAV:
3786 +      {
3787 +        char
3788 +          message[MaxTextExtent];
3789 +
3790 +        const SV
3791 +          *key;
3792 +
3793 +        HV
3794 +          *hv;
3795 +
3796 +        GV
3797 +          **gvp;
3798 +
3799 +        struct PackageInfo
3800 +          *info;
3801 +
3802 +        SV
3803 +          *sv;
3804 +
3805 +        /*
3806 +          Array (AV *) reference
3807 +        */
3808 +        (void) FormatLocaleString(message,MaxTextExtent,"package%s%p",
3809 +          XS_VERSION,reference);
3810 +        hv=gv_stashpv(PackageName, FALSE);
3811 +        if (!hv)
3812 +          break;
3813 +        gvp=(GV **) hv_fetch(hv,message,(long) strlen(message),FALSE);
3814 +        if (!gvp)
3815 +          break;
3816 +        sv=GvSV(*gvp);
3817 +        if (sv && (SvREFCNT(sv) == 1) && SvIOK(sv))
3818 +          {
3819 +            info=INT2PTR(struct PackageInfo *,SvIV(sv));
3820 +            DestroyPackageInfo(info);
3821 +          }
3822 +        key=hv_delete(hv,message,(long) strlen(message),G_DISCARD);
3823 +        (void) key;
3824 +        break;
3825 +      }
3826 +      case SVt_PVMG:
3827 +      {
3828 +        Image
3829 +          *image;
3830 +
3831 +        /*
3832 +          Blessed scalar = (Image *) SvIV(reference)
3833 +        */
3834 +        image=INT2PTR(Image *,SvIV(reference));
3835 +        if (image != (Image *) NULL)
3836 +          DeleteImageFromRegistry(reference,image);
3837 +        break;
3838 +      }
3839 +      default:
3840 +        break;
3841 +    }
3842 +  }
3843 +\f
3844 +#
3845 +###############################################################################
3846 +#                                                                             #
3847 +#                                                                             #
3848 +#                                                                             #
3849 +#   D i s p l a y                                                             #
3850 +#                                                                             #
3851 +#                                                                             #
3852 +#                                                                             #
3853 +###############################################################################
3854 +#
3855 +#
3856 +void
3857 +Display(ref,...)
3858 +  Image::Magick ref = NO_INIT
3859 +  ALIAS:
3860 +    DisplayImage  = 1
3861 +    display       = 2
3862 +    displayimage  = 3
3863 +  PPCODE:
3864 +  {
3865 +    ExceptionInfo
3866 +      *exception;
3867 +
3868 +    Image
3869 +      *image;
3870 +
3871 +    register ssize_t
3872 +      i;
3873 +
3874 +    struct PackageInfo
3875 +      *info,
3876 +      *package_info;
3877 +
3878 +    SV
3879 +      *perl_exception,
3880 +      *reference;
3881 +
3882 +    PERL_UNUSED_VAR(ref);
3883 +    PERL_UNUSED_VAR(ix);
3884 +    exception=AcquireExceptionInfo();
3885 +    perl_exception=newSVpv("",0);
3886 +    package_info=(struct PackageInfo *) NULL;
3887 +    if (sv_isobject(ST(0)) == 0)
3888 +      {
3889 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3890 +          PackageName);
3891 +        goto PerlException;
3892 +      }
3893 +    reference=SvRV(ST(0));
3894 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3895 +    if (image == (Image *) NULL)
3896 +      {
3897 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3898 +          PackageName);
3899 +        goto PerlException;
3900 +      }
3901 +    package_info=ClonePackageInfo(info,exception);
3902 +    if (items == 2)
3903 +      SetAttribute(aTHX_ package_info,NULL,"server",ST(1),exception);
3904 +    else
3905 +      if (items > 2)
3906 +        for (i=2; i < items; i+=2)
3907 +          SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),
3908 +            exception);
3909 +    (void) DisplayImages(package_info->image_info,image);
3910 +    (void) CatchImageException(image);
3911 +    InheritException(exception,&image->exception);
3912 +
3913 +  PerlException:
3914 +    if (package_info != (struct PackageInfo *) NULL)
3915 +      DestroyPackageInfo(package_info);
3916 +    InheritPerlException(exception,perl_exception);
3917 +    exception=DestroyExceptionInfo(exception);
3918 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
3919 +    SvPOK_on(perl_exception);
3920 +    ST(0)=sv_2mortal(perl_exception);
3921 +    XSRETURN(1);
3922 +  }
3923 +\f
3924 +#
3925 +###############################################################################
3926 +#                                                                             #
3927 +#                                                                             #
3928 +#                                                                             #
3929 +#   E v a l u a t e I m a g e s                                               #
3930 +#                                                                             #
3931 +#                                                                             #
3932 +#                                                                             #
3933 +###############################################################################
3934 +#
3935 +#
3936 +void
3937 +EvaluateImages(ref)
3938 +  Image::Magick ref = NO_INIT
3939 +  ALIAS:
3940 +    EvaluateImages   = 1
3941 +    evaluateimages   = 2
3942 +  PPCODE:
3943 +  {
3944 +    AV
3945 +      *av;
3946 +
3947 +    char
3948 +      *attribute,
3949 +      *p;
3950 +
3951 +    ExceptionInfo
3952 +      *exception;
3953 +
3954 +    HV
3955 +      *hv;
3956 +
3957 +    Image
3958 +      *image;
3959 +
3960 +    MagickEvaluateOperator
3961 +      op;
3962 +
3963 +    register ssize_t
3964 +      i;
3965 +
3966 +    struct PackageInfo
3967 +      *info;
3968 +
3969 +    SV
3970 +      *perl_exception,
3971 +      *reference,
3972 +      *rv,
3973 +      *sv;
3974 +
3975 +    PERL_UNUSED_VAR(ref);
3976 +    PERL_UNUSED_VAR(ix);
3977 +    exception=AcquireExceptionInfo();
3978 +    perl_exception=newSVpv("",0);
3979 +    sv=NULL;
3980 +    if (sv_isobject(ST(0)) == 0)
3981 +      {
3982 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
3983 +          PackageName);
3984 +        goto PerlException;
3985 +      }
3986 +    reference=SvRV(ST(0));
3987 +    hv=SvSTASH(reference);
3988 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
3989 +    if (image == (Image *) NULL)
3990 +      {
3991 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
3992 +          PackageName);
3993 +        goto PerlException;
3994 +      }
3995 +    op=MeanEvaluateOperator;
3996 +    if (items == 2)
3997 +      {
3998 +        ssize_t
3999 +          in;
4000 +
4001 +        in=ParseCommandOption(MagickEvaluateOptions,MagickFalse,(char *)
4002 +          SvPV(ST(1),na));
4003 +        if (in < 0)
4004 +          {
4005 +            ThrowPerlException(exception,OptionError,"UnrecognizedType",
4006 +              SvPV(ST(1),na));
4007 +            return;
4008 +          }
4009 +        op=(MagickEvaluateOperator) in;
4010 +      }
4011 +    else
4012 +      for (i=2; i < items; i+=2)
4013 +      {
4014 +        attribute=(char *) SvPV(ST(i-1),na);
4015 +        switch (*attribute)
4016 +        {
4017 +          case 'O':
4018 +          case 'o':
4019 +          {
4020 +            if (LocaleCompare(attribute,"operator") == 0)
4021 +              {
4022 +                ssize_t
4023 +                  in;
4024 +
4025 +                in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
4026 +                  MagickEvaluateOptions,MagickFalse,SvPV(ST(i),na));
4027 +                if (in < 0)
4028 +                  {
4029 +                    ThrowPerlException(exception,OptionError,"UnrecognizedType",
4030 +                      SvPV(ST(i),na));
4031 +                    return;
4032 +                  }
4033 +                op=(MagickEvaluateOperator) in;
4034 +                break;
4035 +              }
4036 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4037 +              attribute);
4038 +            break;
4039 +          }
4040 +          default:
4041 +          {
4042 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4043 +              attribute);
4044 +            break;
4045 +          }
4046 +        }
4047 +      }
4048 +    image=EvaluateImages(image,op,exception);
4049 +    if (image == (Image *) NULL)
4050 +      goto PerlException;
4051 +    /*
4052 +      Create blessed Perl array for the returned image.
4053 +    */
4054 +    av=newAV();
4055 +    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
4056 +    SvREFCNT_dec(av);
4057 +    AddImageToRegistry(sv,image);
4058 +    rv=newRV(sv);
4059 +    av_push(av,sv_bless(rv,hv));
4060 +    SvREFCNT_dec(sv);
4061 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
4062 +    (void) FormatLocaleString(info->image_info->filename,MaxTextExtent,
4063 +      "evaluate-%.*s",(int) (MaxTextExtent-9),
4064 +      ((p=strrchr(image->filename,'/')) ? p+1 : image->filename));
4065 +    (void) CopyMagickString(image->filename,info->image_info->filename,
4066 +      MaxTextExtent);
4067 +    SetImageInfo(info->image_info,0,exception);
4068 +    exception=DestroyExceptionInfo(exception);
4069 +    SvREFCNT_dec(perl_exception);
4070 +    XSRETURN(1);
4071 +
4072 +  PerlException:
4073 +    InheritPerlException(exception,perl_exception);
4074 +    exception=DestroyExceptionInfo(exception);
4075 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
4076 +    SvPOK_on(perl_exception);
4077 +    ST(0)=sv_2mortal(perl_exception);
4078 +    XSRETURN(1);
4079 +  }
4080 +\f
4081 +#
4082 +###############################################################################
4083 +#                                                                             #
4084 +#                                                                             #
4085 +#                                                                             #
4086 +#   F e a t u r e s                                                           #
4087 +#                                                                             #
4088 +#                                                                             #
4089 +#                                                                             #
4090 +###############################################################################
4091 +#
4092 +#
4093 +void
4094 +Features(ref,...)
4095 +  Image::Magick ref = NO_INIT
4096 +  ALIAS:
4097 +    FeaturesImage = 1
4098 +    features      = 2
4099 +    featuresimage = 3
4100 +  PPCODE:
4101 +  {
4102 +#define ChannelFeatures(channel,direction) \
4103 +{ \
4104 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4105 +    channel_features[channel].angular_second_moment[direction]); \
4106 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4107 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4108 +    channel_features[channel].contrast[direction]); \
4109 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4110 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4111 +    channel_features[channel].contrast[direction]); \
4112 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4113 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4114 +    channel_features[channel].variance_sum_of_squares[direction]); \
4115 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4116 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4117 +    channel_features[channel].inverse_difference_moment[direction]); \
4118 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4119 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4120 +    channel_features[channel].sum_average[direction]); \
4121 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4122 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4123 +    channel_features[channel].sum_variance[direction]); \
4124 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4125 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4126 +    channel_features[channel].sum_entropy[direction]); \
4127 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4128 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4129 +    channel_features[channel].entropy[direction]); \
4130 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4131 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4132 +    channel_features[channel].difference_variance[direction]); \
4133 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4134 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4135 +    channel_features[channel].difference_entropy[direction]); \
4136 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4137 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4138 +    channel_features[channel].measure_of_correlation_1[direction]); \
4139 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4140 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4141 +    channel_features[channel].measure_of_correlation_2[direction]); \
4142 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4143 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
4144 +    channel_features[channel].maximum_correlation_coefficient[direction]); \
4145 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
4146 +}
4147 +
4148 +    AV
4149 +      *av;
4150 +
4151 +    char
4152 +      *attribute,
4153 +      message[MaxTextExtent];
4154 +
4155 +    ChannelFeatures
4156 +      *channel_features;
4157 +
4158 +    double
4159 +      distance;
4160 +
4161 +    ExceptionInfo
4162 +      *exception;
4163 +
4164 +    Image
4165 +      *image;
4166 +
4167 +    register ssize_t
4168 +      i;
4169 +
4170 +    ssize_t
4171 +      count;
4172 +
4173 +    struct PackageInfo
4174 +      *info;
4175 +
4176 +    SV
4177 +      *perl_exception,
4178 +      *reference;
4179 +
4180 +    PERL_UNUSED_VAR(ref);
4181 +    PERL_UNUSED_VAR(ix);
4182 +    exception=AcquireExceptionInfo();
4183 +    perl_exception=newSVpv("",0);
4184 +    av=NULL;
4185 +    if (sv_isobject(ST(0)) == 0)
4186 +      {
4187 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
4188 +          PackageName);
4189 +        goto PerlException;
4190 +      }
4191 +    reference=SvRV(ST(0));
4192 +    av=newAV();
4193 +    SvREFCNT_dec(av);
4194 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
4195 +    if (image == (Image *) NULL)
4196 +      {
4197 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
4198 +          PackageName);
4199 +        goto PerlException;
4200 +      }
4201 +    distance=1.0;
4202 +    for (i=2; i < items; i+=2)
4203 +    {
4204 +      attribute=(char *) SvPV(ST(i-1),na);
4205 +      switch (*attribute)
4206 +      {
4207 +        case 'D':
4208 +        case 'd':
4209 +        {
4210 +          if (LocaleCompare(attribute,"distance") == 0)
4211 +            {
4212 +              distance=StringToLong((char *) SvPV(ST(1),na));
4213 +              break;
4214 +            }
4215 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4216 +            attribute);
4217 +          break;
4218 +        }
4219 +        default:
4220 +        {
4221 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4222 +            attribute);
4223 +          break;
4224 +        }
4225 +      }
4226 +    }
4227 +    count=0;
4228 +    for ( ; image; image=image->next)
4229 +    {
4230 +      channel_features=GetImageChannelFeatures(image,distance,
4231 +        &image->exception);
4232 +      if (channel_features == (ChannelFeatures *) NULL)
4233 +        continue;
4234 +      count++;
4235 +      EXTEND(sp,280*count);
4236 +      for (i=0; i < 4; i++)
4237 +      {
4238 +        ChannelFeatures(RedChannel,i);
4239 +        ChannelFeatures(GreenChannel,i);
4240 +        ChannelFeatures(BlueChannel,i);
4241 +        if (image->colorspace == CMYKColorspace)
4242 +          ChannelFeatures(IndexChannel,i);
4243 +        if (image->matte != MagickFalse)
4244 +          ChannelFeatures(OpacityChannel,i);
4245 +      }
4246 +      channel_features=(ChannelFeatures *)
4247 +        RelinquishMagickMemory(channel_features);
4248 +    }
4249 +
4250 +  PerlException:
4251 +    InheritPerlException(exception,perl_exception);
4252 +    exception=DestroyExceptionInfo(exception);
4253 +    SvREFCNT_dec(perl_exception);
4254 +  }
4255 +\f
4256 +#
4257 +###############################################################################
4258 +#                                                                             #
4259 +#                                                                             #
4260 +#                                                                             #
4261 +#   F l a t t e n                                                             #
4262 +#                                                                             #
4263 +#                                                                             #
4264 +#                                                                             #
4265 +###############################################################################
4266 +#
4267 +#
4268 +void
4269 +Flatten(ref)
4270 +  Image::Magick ref = NO_INIT
4271 +  ALIAS:
4272 +    FlattenImage   = 1
4273 +    flatten        = 2
4274 +    flattenimage   = 3
4275 +  PPCODE:
4276 +  {
4277 +    AV
4278 +      *av;
4279 +
4280 +    char
4281 +      *attribute,
4282 +      *p;
4283 +
4284 +    ExceptionInfo
4285 +      *exception;
4286 +
4287 +    HV
4288 +      *hv;
4289 +
4290 +    Image
4291 +      *image;
4292 +
4293 +    PixelPacket
4294 +      background_color;
4295 +
4296 +    register ssize_t
4297 +      i;
4298 +
4299 +    struct PackageInfo
4300 +      *info;
4301 +
4302 +    SV
4303 +      *perl_exception,
4304 +      *reference,
4305 +      *rv,
4306 +      *sv;
4307 +
4308 +    PERL_UNUSED_VAR(ref);
4309 +    PERL_UNUSED_VAR(ix);
4310 +    exception=AcquireExceptionInfo();
4311 +    perl_exception=newSVpv("",0);
4312 +    sv=NULL;
4313 +    if (sv_isobject(ST(0)) == 0)
4314 +      {
4315 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
4316 +          PackageName);
4317 +        goto PerlException;
4318 +      }
4319 +    reference=SvRV(ST(0));
4320 +    hv=SvSTASH(reference);
4321 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
4322 +    if (image == (Image *) NULL)
4323 +      {
4324 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
4325 +          PackageName);
4326 +        goto PerlException;
4327 +      }
4328 +    background_color=image->background_color;
4329 +    if (items == 2)
4330 +      (void) QueryColorDatabase((char *) SvPV(ST(1),na),&background_color,
4331 +        exception);
4332 +    else
4333 +      for (i=2; i < items; i+=2)
4334 +      {
4335 +        attribute=(char *) SvPV(ST(i-1),na);
4336 +        switch (*attribute)
4337 +        {
4338 +          case 'B':
4339 +          case 'b':
4340 +          {
4341 +            if (LocaleCompare(attribute,"background") == 0)
4342 +              {
4343 +                (void) QueryColorDatabase((char *) SvPV(ST(1),na),
4344 +                  &background_color,exception);
4345 +                break;
4346 +              }
4347 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4348 +              attribute);
4349 +            break;
4350 +          }
4351 +          default:
4352 +          {
4353 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4354 +              attribute);
4355 +            break;
4356 +          }
4357 +        }
4358 +      }
4359 +    image->background_color=background_color;
4360 +    image=MergeImageLayers(image,FlattenLayer,exception);
4361 +    if (image == (Image *) NULL)
4362 +      goto PerlException;
4363 +    /*
4364 +      Create blessed Perl array for the returned image.
4365 +    */
4366 +    av=newAV();
4367 +    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
4368 +    SvREFCNT_dec(av);
4369 +    AddImageToRegistry(sv,image);
4370 +    rv=newRV(sv);
4371 +    av_push(av,sv_bless(rv,hv));
4372 +    SvREFCNT_dec(sv);
4373 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
4374 +    (void) FormatLocaleString(info->image_info->filename,MaxTextExtent,
4375 +      "flatten-%.*s",(int) (MaxTextExtent-9),
4376 +      ((p=strrchr(image->filename,'/')) ? p+1 : image->filename));
4377 +    (void) CopyMagickString(image->filename,info->image_info->filename,
4378 +      MaxTextExtent);
4379 +    SetImageInfo(info->image_info,0,exception);
4380 +    exception=DestroyExceptionInfo(exception);
4381 +    SvREFCNT_dec(perl_exception);
4382 +    XSRETURN(1);
4383 +
4384 +  PerlException:
4385 +    InheritPerlException(exception,perl_exception);
4386 +    exception=DestroyExceptionInfo(exception);
4387 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
4388 +    SvPOK_on(perl_exception);  /* return messages in string context */
4389 +    ST(0)=sv_2mortal(perl_exception);
4390 +    XSRETURN(1);
4391 +  }
4392 +\f
4393 +#
4394 +###############################################################################
4395 +#                                                                             #
4396 +#                                                                             #
4397 +#                                                                             #
4398 +#   F x                                                                       #
4399 +#                                                                             #
4400 +#                                                                             #
4401 +#                                                                             #
4402 +###############################################################################
4403 +#
4404 +#
4405 +void
4406 +Fx(ref,...)
4407 +  Image::Magick ref = NO_INIT
4408 +  ALIAS:
4409 +    FxImage  = 1
4410 +    fx       = 2
4411 +    fximage  = 3
4412 +  PPCODE:
4413 +  {
4414 +    AV
4415 +      *av;
4416 +
4417 +    char
4418 +      *attribute,
4419 +      expression[MaxTextExtent];
4420 +
4421 +    ChannelType
4422 +      channel;
4423 +
4424 +    ExceptionInfo
4425 +      *exception;
4426 +
4427 +    HV
4428 +      *hv;
4429 +
4430 +    Image
4431 +      *image;
4432 +
4433 +    register ssize_t
4434 +      i;
4435 +
4436 +    struct PackageInfo
4437 +      *info;
4438 +
4439 +    SV
4440 +      *av_reference,
4441 +      *perl_exception,
4442 +      *reference,
4443 +      *rv,
4444 +      *sv;
4445 +
4446 +    PERL_UNUSED_VAR(ref);
4447 +    PERL_UNUSED_VAR(ix);
4448 +    exception=AcquireExceptionInfo();
4449 +    perl_exception=newSVpv("",0);
4450 +    sv=NULL;
4451 +    attribute=NULL;
4452 +    av=NULL;
4453 +    if (sv_isobject(ST(0)) == 0)
4454 +      {
4455 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
4456 +          PackageName);
4457 +        goto PerlException;
4458 +      }
4459 +    reference=SvRV(ST(0));
4460 +    hv=SvSTASH(reference);
4461 +    av=newAV();
4462 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
4463 +    SvREFCNT_dec(av);
4464 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
4465 +    if (image == (Image *) NULL)
4466 +      {
4467 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
4468 +          PackageName);
4469 +        goto PerlException;
4470 +      }
4471 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
4472 +    /*
4473 +      Get options.
4474 +    */
4475 +    channel=DefaultChannels;
4476 +    (void) CopyMagickString(expression,"u",MaxTextExtent);
4477 +    if (items == 2)
4478 +      (void) CopyMagickString(expression,(char *) SvPV(ST(1),na),MaxTextExtent);
4479 +    else
4480 +      for (i=2; i < items; i+=2)
4481 +      {
4482 +        attribute=(char *) SvPV(ST(i-1),na);
4483 +        switch (*attribute)
4484 +        {
4485 +          case 'C':
4486 +          case 'c':
4487 +          {
4488 +            if (LocaleCompare(attribute,"channel") == 0)
4489 +              {
4490 +                ssize_t
4491 +                  option;
4492 +
4493 +                option=ParseChannelOption(SvPV(ST(i),na));
4494 +                if (option < 0)
4495 +                  {
4496 +                    ThrowPerlException(exception,OptionError,
4497 +                      "UnrecognizedType",SvPV(ST(i),na));
4498 +                    return;
4499 +                  }
4500 +                channel=(ChannelType) option;
4501 +                break;
4502 +              }
4503 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4504 +              attribute);
4505 +            break;
4506 +          }
4507 +          case 'E':
4508 +          case 'e':
4509 +          {
4510 +            if (LocaleCompare(attribute,"expression") == 0)
4511 +              {
4512 +                (void) CopyMagickString(expression,SvPV(ST(i),na),
4513 +                  MaxTextExtent);
4514 +                break;
4515 +              }
4516 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4517 +              attribute);
4518 +            break;
4519 +          }
4520 +          default:
4521 +          {
4522 +            ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4523 +              attribute);
4524 +            break;
4525 +          }
4526 +        }
4527 +      }
4528 +    image=FxImageChannel(image,channel,expression,exception);
4529 +    if (image == (Image *) NULL)
4530 +      goto PerlException;
4531 +    for ( ; image; image=image->next)
4532 +    {
4533 +      AddImageToRegistry(sv,image);
4534 +      rv=newRV(sv);
4535 +      av_push(av,sv_bless(rv,hv));
4536 +      SvREFCNT_dec(sv);
4537 +    }
4538 +    exception=DestroyExceptionInfo(exception);
4539 +    ST(0)=av_reference;
4540 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
4541 +    XSRETURN(1);
4542 +
4543 +  PerlException:
4544 +    InheritPerlException(exception,perl_exception);
4545 +    exception=DestroyExceptionInfo(exception);
4546 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
4547 +    SvPOK_on(perl_exception);
4548 +    ST(0)=sv_2mortal(perl_exception);
4549 +    XSRETURN(1);
4550 +  }
4551 +\f
4552 +#
4553 +###############################################################################
4554 +#                                                                             #
4555 +#                                                                             #
4556 +#                                                                             #
4557 +#   G e t                                                                     #
4558 +#                                                                             #
4559 +#                                                                             #
4560 +#                                                                             #
4561 +###############################################################################
4562 +#
4563 +#
4564 +void
4565 +Get(ref,...)
4566 +  Image::Magick ref = NO_INIT
4567 +  ALIAS:
4568 +    GetAttributes = 1
4569 +    GetAttribute  = 2
4570 +    get           = 3
4571 +    getattributes = 4
4572 +    getattribute  = 5
4573 +  PPCODE:
4574 +  {
4575 +    char
4576 +      *attribute,
4577 +      color[MaxTextExtent];
4578 +
4579 +    const char
4580 +      *value;
4581 +
4582 +    ExceptionInfo
4583 +      *exception;
4584 +
4585 +    Image
4586 +      *image;
4587 +
4588 +    long
4589 +      j;
4590 +
4591 +    register ssize_t
4592 +      i;
4593 +
4594 +    struct PackageInfo
4595 +      *info;
4596 +
4597 +    SV
4598 +      *perl_exception,
4599 +      *reference,
4600 +      *s;
4601 +
4602 +    PERL_UNUSED_VAR(ref);
4603 +    PERL_UNUSED_VAR(ix);
4604 +    exception=AcquireExceptionInfo();
4605 +    perl_exception=newSVpv("",0);
4606 +    if (sv_isobject(ST(0)) == 0)
4607 +      {
4608 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
4609 +          PackageName);
4610 +        XSRETURN_EMPTY;
4611 +      }
4612 +    reference=SvRV(ST(0));
4613 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
4614 +    if (image == (Image *) NULL && !info)
4615 +      XSRETURN_EMPTY;
4616 +    EXTEND(sp,items);
4617 +    for (i=1; i < items; i++)
4618 +    {
4619 +      attribute=(char *) SvPV(ST(i),na);
4620 +      s=NULL;
4621 +      switch (*attribute)
4622 +      {
4623 +        case 'A':
4624 +        case 'a':
4625 +        {
4626 +          if (LocaleCompare(attribute,"adjoin") == 0)
4627 +            {
4628 +              if (info)
4629 +                s=newSViv((ssize_t) info->image_info->adjoin);
4630 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4631 +              continue;
4632 +            }
4633 +          if (LocaleCompare(attribute,"antialias") == 0)
4634 +            {
4635 +              if (info)
4636 +                s=newSViv((ssize_t) info->image_info->antialias);
4637 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4638 +              continue;
4639 +            }
4640 +          if (LocaleCompare(attribute,"area") == 0)
4641 +            {
4642 +              s=newSViv(GetMagickResource(AreaResource));
4643 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4644 +              continue;
4645 +            }
4646 +          if (LocaleCompare(attribute,"attenuate") == 0)
4647 +            {
4648 +              const char
4649 +                *value;
4650 +
4651 +              value=GetImageProperty(image,attribute);
4652 +              if (value != (const char *) NULL)
4653 +                s=newSVpv(value,0);
4654 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4655 +              continue;
4656 +            }
4657 +          if (LocaleCompare(attribute,"authenticate") == 0)
4658 +            {
4659 +              if (info)
4660 +                s=newSVpv(info->image_info->authenticate,0);
4661 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4662 +              continue;
4663 +            }
4664 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4665 +            attribute);
4666 +          break;
4667 +        }
4668 +        case 'B':
4669 +        case 'b':
4670 +        {
4671 +          if (LocaleCompare(attribute,"background") == 0)
4672 +            {
4673 +              if (image == (Image *) NULL)
4674 +                break;
4675 +              (void) FormatLocaleString(color,MaxTextExtent,QuantumFormat ","
4676 +                QuantumFormat "," QuantumFormat "," QuantumFormat,
4677 +                image->background_color.red,image->background_color.green,
4678 +                image->background_color.blue,image->background_color.opacity);
4679 +              s=newSVpv(color,0);
4680 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4681 +              continue;
4682 +            }
4683 +          if (LocaleCompare(attribute,"base-columns") == 0)
4684 +            {
4685 +              if (image != (Image *) NULL)
4686 +                s=newSViv((ssize_t) image->magick_columns);
4687 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4688 +              continue;
4689 +            }
4690 +          if (LocaleCompare(attribute,"base-filename") == 0)
4691 +            {
4692 +              if (image != (Image *) NULL)
4693 +                s=newSVpv(image->magick_filename,0);
4694 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4695 +              continue;
4696 +            }
4697 +          if (LocaleCompare(attribute,"base-height") == 0)
4698 +            {
4699 +              if (image != (Image *) NULL)
4700 +                s=newSViv((ssize_t) image->magick_rows);
4701 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4702 +              continue;
4703 +            }
4704 +          if (LocaleCompare(attribute,"base-rows") == 0)
4705 +            {
4706 +              if (image != (Image *) NULL)
4707 +                s=newSViv((ssize_t) image->magick_rows);
4708 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4709 +              continue;
4710 +            }
4711 +          if (LocaleCompare(attribute,"base-width") == 0)
4712 +            {
4713 +              if (image != (Image *) NULL)
4714 +                s=newSViv((ssize_t) image->magick_columns);
4715 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4716 +              continue;
4717 +            }
4718 +          if (LocaleCompare(attribute,"bias") == 0)
4719 +            {
4720 +              if (image != (Image *) NULL)
4721 +                s=newSVnv(image->bias);
4722 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4723 +              continue;
4724 +            }
4725 +          if (LocaleCompare(attribute,"blue-primary") == 0)
4726 +            {
4727 +              if (image == (Image *) NULL)
4728 +                break;
4729 +              (void) FormatLocaleString(color,MaxTextExtent,"%.15g,%.15g",
4730 +                image->chromaticity.blue_primary.x,
4731 +                image->chromaticity.blue_primary.y);
4732 +              s=newSVpv(color,0);
4733 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4734 +              continue;
4735 +            }
4736 +          if (LocaleCompare(attribute,"bordercolor") == 0)
4737 +            {
4738 +              if (image == (Image *) NULL)
4739 +                break;
4740 +              (void) FormatLocaleString(color,MaxTextExtent,QuantumFormat ","
4741 +                QuantumFormat "," QuantumFormat "," QuantumFormat,
4742 +                image->border_color.red,image->border_color.green,
4743 +                image->border_color.blue,image->border_color.opacity);
4744 +              s=newSVpv(color,0);
4745 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4746 +              continue;
4747 +            }
4748 +          if (LocaleCompare(attribute,"bounding-box") == 0)
4749 +            {
4750 +              char
4751 +                geometry[MaxTextExtent];
4752 +
4753 +              RectangleInfo
4754 +                page;
4755 +
4756 +              if (image == (Image *) NULL)
4757 +                break;
4758 +              page=GetImageBoundingBox(image,&image->exception);
4759 +              (void) FormatLocaleString(geometry,MaxTextExtent,
4760 +                "%.20gx%.20g%+.20g%+.20g",(double) page.width,(double)
4761 +                page.height,(double) page.x,(double) page.y);
4762 +              s=newSVpv(geometry,0);
4763 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4764 +              continue;
4765 +            }
4766 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4767 +            attribute);
4768 +          break;
4769 +        }
4770 +        case 'C':
4771 +        case 'c':
4772 +        {
4773 +          if (LocaleCompare(attribute,"class") == 0)
4774 +            {
4775 +              if (image == (Image *) NULL)
4776 +                break;
4777 +              s=newSViv(image->storage_class);
4778 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickClassOptions,
4779 +                image->storage_class));
4780 +              SvIOK_on(s);
4781 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4782 +              continue;
4783 +            }
4784 +          if (LocaleCompare(attribute,"clip-mask") == 0)
4785 +            {
4786 +              if (image != (Image *) NULL)
4787 +                {
4788 +                  SV
4789 +                    *sv;
4790 +
4791 +                  sv=NULL;
4792 +                  if (image->mask == (Image *) NULL)
4793 +                    ClipImage(image);
4794 +                  if (image->mask != (Image *) NULL)
4795 +                    {
4796 +                      AddImageToRegistry(sv,image->mask);
4797 +                      s=sv_bless(newRV(sv),SvSTASH(reference));
4798 +                    }
4799 +                }
4800 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4801 +              continue;
4802 +            }
4803 +          if (LocaleCompare(attribute,"clip-path") == 0)
4804 +            {
4805 +              if (image != (Image *) NULL)
4806 +                {
4807 +                  SV
4808 +                    *sv;
4809 +
4810 +                  sv=NULL;
4811 +                  if (image->clip_mask == (Image *) NULL)
4812 +                    ClipImage(image);
4813 +                  if (image->clip_mask != (Image *) NULL)
4814 +                    {
4815 +                      AddImageToRegistry(sv,image->clip_mask);
4816 +                      s=sv_bless(newRV(sv),SvSTASH(reference));
4817 +                    }
4818 +                }
4819 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4820 +              continue;
4821 +            }
4822 +          if (LocaleCompare(attribute,"compression") == 0)
4823 +            {
4824 +              j=info ? info->image_info->compression : image ?
4825 +                image->compression : UndefinedCompression;
4826 +              if (info)
4827 +                if (info->image_info->compression == UndefinedCompression)
4828 +                  j=image->compression;
4829 +              s=newSViv(j);
4830 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickCompressOptions,
4831 +                j));
4832 +              SvIOK_on(s);
4833 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4834 +              continue;
4835 +            }
4836 +          if (LocaleCompare(attribute,"colorspace") == 0)
4837 +            {
4838 +              j=image ? image->colorspace : RGBColorspace;
4839 +              s=newSViv(j);
4840 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickColorspaceOptions,
4841 +                j));
4842 +              SvIOK_on(s);
4843 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4844 +              continue;
4845 +            }
4846 +          if (LocaleCompare(attribute,"colors") == 0)
4847 +            {
4848 +              if (image != (Image *) NULL)
4849 +                s=newSViv((ssize_t) GetNumberColors(image,(FILE *) NULL,
4850 +                  &image->exception));
4851 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4852 +              continue;
4853 +            }
4854 +          if (LocaleNCompare(attribute,"colormap",8) == 0)
4855 +            {
4856 +              int
4857 +                items;
4858 +
4859 +              if (image == (Image *) NULL || !image->colormap)
4860 +                break;
4861 +              j=0;
4862 +              items=sscanf(attribute,"%*[^[][%ld",&j);
4863 +              (void) items;
4864 +              if (j > (ssize_t) image->colors)
4865 +                j%=image->colors;
4866 +              (void) FormatLocaleString(color,MaxTextExtent,QuantumFormat ","
4867 +                QuantumFormat "," QuantumFormat "," QuantumFormat,
4868 +                image->colormap[j].red,image->colormap[j].green,
4869 +                image->colormap[j].blue,image->colormap[j].opacity);
4870 +              s=newSVpv(color,0);
4871 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4872 +              continue;
4873 +            }
4874 +          if (LocaleCompare(attribute,"columns") == 0)
4875 +            {
4876 +              if (image != (Image *) NULL)
4877 +                s=newSViv((ssize_t) image->columns);
4878 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4879 +              continue;
4880 +            }
4881 +          if (LocaleCompare(attribute,"comment") == 0)
4882 +            {
4883 +              const char
4884 +                *value;
4885 +
4886 +              value=GetImageProperty(image,attribute);
4887 +              if (value != (const char *) NULL)
4888 +                s=newSVpv(value,0);
4889 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4890 +              continue;
4891 +            }
4892 +          if (LocaleCompare(attribute,"copyright") == 0)
4893 +            {
4894 +              s=newSVpv(GetMagickCopyright(),0);
4895 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4896 +              continue;
4897 +            }
4898 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4899 +            attribute);
4900 +          break;
4901 +        }
4902 +        case 'D':
4903 +        case 'd':
4904 +        {
4905 +          if (LocaleCompare(attribute,"density") == 0)
4906 +            {
4907 +              char
4908 +                geometry[MaxTextExtent];
4909 +
4910 +              if (image == (Image *) NULL)
4911 +                break;
4912 +              (void) FormatLocaleString(geometry,MaxTextExtent,"%.15gx%.15g",
4913 +                image->x_resolution,image->y_resolution);
4914 +              s=newSVpv(geometry,0);
4915 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4916 +              continue;
4917 +            }
4918 +          if (LocaleCompare(attribute,"delay") == 0)
4919 +            {
4920 +              if (image != (Image *) NULL)
4921 +                s=newSViv((ssize_t) image->delay);
4922 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4923 +              continue;
4924 +            }
4925 +          if (LocaleCompare(attribute,"depth") == 0)
4926 +            {
4927 +              s=newSViv(MAGICKCORE_QUANTUM_DEPTH);
4928 +              if (image != (Image *) NULL)
4929 +                s=newSViv((ssize_t) GetImageDepth(image,&image->exception));
4930 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4931 +              continue;
4932 +            }
4933 +          if (LocaleCompare(attribute,"directory") == 0)
4934 +            {
4935 +              if (image && image->directory)
4936 +                s=newSVpv(image->directory,0);
4937 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4938 +              continue;
4939 +            }
4940 +          if (LocaleCompare(attribute,"dispose") == 0)
4941 +            {
4942 +              if (image == (Image *) NULL)
4943 +                break;
4944 +
4945 +              s=newSViv(image->dispose);
4946 +              (void) sv_setpv(s,
4947 +                CommandOptionToMnemonic(MagickDisposeOptions,image->dispose));
4948 +              SvIOK_on(s);
4949 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4950 +              continue;
4951 +            }
4952 +          if (LocaleCompare(attribute,"disk") == 0)
4953 +            {
4954 +              s=newSViv(GetMagickResource(DiskResource));
4955 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4956 +              continue;
4957 +            }
4958 +          if (LocaleCompare(attribute,"dither") == 0)
4959 +            {
4960 +              if (info)
4961 +                s=newSViv((ssize_t) info->image_info->dither);
4962 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4963 +              continue;
4964 +            }
4965 +          if (LocaleCompare(attribute,"display") == 0)  /* same as server */
4966 +            {
4967 +              if (info && info->image_info->server_name)
4968 +                s=newSVpv(info->image_info->server_name,0);
4969 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4970 +              continue;
4971 +            }
4972 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
4973 +            attribute);
4974 +          break;
4975 +        }
4976 +        case 'E':
4977 +        case 'e':
4978 +        {
4979 +          if (LocaleCompare(attribute,"elapsed-time") == 0)
4980 +            {
4981 +              if (image != (Image *) NULL)
4982 +                s=newSVnv(GetElapsedTime(&image->timer));
4983 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4984 +              continue;
4985 +            }
4986 +          if (LocaleCompare(attribute,"endian") == 0)
4987 +            {
4988 +              j=info ? info->image_info->endian : image ? image->endian :
4989 +                UndefinedEndian;
4990 +              s=newSViv(j);
4991 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickEndianOptions,j));
4992 +              SvIOK_on(s);
4993 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4994 +              continue;
4995 +            }
4996 +          if (LocaleCompare(attribute,"error") == 0)
4997 +            {
4998 +              if (image != (Image *) NULL)
4999 +                s=newSVnv(image->error.mean_error_per_pixel);
5000 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5001 +              continue;
5002 +            }
5003 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5004 +            attribute);
5005 +          break;
5006 +        }
5007 +        case 'F':
5008 +        case 'f':
5009 +        {
5010 +          if (LocaleCompare(attribute,"filesize") == 0)
5011 +            {
5012 +              if (image != (Image *) NULL)
5013 +                s=newSViv((ssize_t) GetBlobSize(image));
5014 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5015 +              continue;
5016 +            }
5017 +          if (LocaleCompare(attribute,"filename") == 0)
5018 +            {
5019 +              if (info && info->image_info->filename &&
5020 +                  *info->image_info->filename)
5021 +                s=newSVpv(info->image_info->filename,0);
5022 +              if (image != (Image *) NULL)
5023 +                s=newSVpv(image->filename,0);
5024 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5025 +              continue;
5026 +            }
5027 +          if (LocaleCompare(attribute,"filter") == 0)
5028 +            {
5029 +              s=image ? newSViv(image->filter) : newSViv(0);
5030 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickFilterOptions,
5031 +                image->filter));
5032 +              SvIOK_on(s);
5033 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5034 +              continue;
5035 +            }
5036 +          if (LocaleCompare(attribute,"font") == 0)
5037 +            {
5038 +              if (info && info->image_info->font)
5039 +                s=newSVpv(info->image_info->font,0);
5040 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5041 +              continue;
5042 +            }
5043 +          if (LocaleCompare(attribute,"foreground") == 0)
5044 +            continue;
5045 +          if (LocaleCompare(attribute,"format") == 0)
5046 +            {
5047 +              const MagickInfo
5048 +                *magick_info;
5049 +
5050 +              magick_info=(const MagickInfo *) NULL;
5051 +              if (info && (*info->image_info->magick != '\0'))
5052 +                magick_info=GetMagickInfo(info->image_info->magick,exception);
5053 +              if (image != (Image *) NULL)
5054 +                magick_info=GetMagickInfo(image->magick,&image->exception);
5055 +              if ((magick_info != (const MagickInfo *) NULL) &&
5056 +                  (*magick_info->description != '\0'))
5057 +                s=newSVpv((char *) magick_info->description,0);
5058 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5059 +              continue;
5060 +            }
5061 +          if (LocaleCompare(attribute,"fuzz") == 0)
5062 +            {
5063 +              if (info)
5064 +                s=newSVnv(info->image_info->fuzz);
5065 +              if (image != (Image *) NULL)
5066 +                s=newSVnv(image->fuzz);
5067 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5068 +              continue;
5069 +            }
5070 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5071 +            attribute);
5072 +          break;
5073 +        }
5074 +        case 'G':
5075 +        case 'g':
5076 +        {
5077 +          if (LocaleCompare(attribute,"gamma") == 0)
5078 +            {
5079 +              if (image != (Image *) NULL)
5080 +                s=newSVnv(image->gamma);
5081 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5082 +              continue;
5083 +            }
5084 +          if (LocaleCompare(attribute,"geometry") == 0)
5085 +            {
5086 +              if (image && image->geometry)
5087 +                s=newSVpv(image->geometry,0);
5088 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5089 +              continue;
5090 +            }
5091 +          if (LocaleCompare(attribute,"gravity") == 0)
5092 +            {
5093 +              s=image ? newSViv(image->gravity) : newSViv(0);
5094 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickGravityOptions,
5095 +                image->gravity));
5096 +              SvIOK_on(s);
5097 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5098 +              continue;
5099 +            }
5100 +          if (LocaleCompare(attribute,"green-primary") == 0)
5101 +            {
5102 +              if (image == (Image *) NULL)
5103 +                break;
5104 +              (void) FormatLocaleString(color,MaxTextExtent,"%.15g,%.15g",
5105 +                image->chromaticity.green_primary.x,
5106 +                image->chromaticity.green_primary.y);
5107 +              s=newSVpv(color,0);
5108 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5109 +              continue;
5110 +            }
5111 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5112 +            attribute);
5113 +          break;
5114 +        }
5115 +        case 'H':
5116 +        case 'h':
5117 +        {
5118 +          if (LocaleCompare(attribute,"height") == 0)
5119 +            {
5120 +              if (image != (Image *) NULL)
5121 +                s=newSViv((ssize_t) image->rows);
5122 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5123 +              continue;
5124 +            }
5125 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5126 +            attribute);
5127 +          break;
5128 +        }
5129 +        case 'I':
5130 +        case 'i':
5131 +        {
5132 +          if (LocaleCompare(attribute,"icc") == 0)
5133 +            {
5134 +              if (image != (Image *) NULL)
5135 +                {
5136 +                  const StringInfo
5137 +                    *profile;
5138 +
5139 +                  profile=GetImageProfile(image,"icc");
5140 +                  if (profile != (StringInfo *) NULL)
5141 +                    s=newSVpv((const char *) GetStringInfoDatum(profile),
5142 +                      GetStringInfoLength(profile));
5143 +                }
5144 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5145 +              continue;
5146 +            }
5147 +          if (LocaleCompare(attribute,"icm") == 0)
5148 +            {
5149 +              if (image != (Image *) NULL)
5150 +                {
5151 +                  const StringInfo
5152 +                    *profile;
5153 +
5154 +                  profile=GetImageProfile(image,"icm");
5155 +                  if (profile != (const StringInfo *) NULL)
5156 +                    s=newSVpv((const char *) GetStringInfoDatum(profile),
5157 +                      GetStringInfoLength(profile));
5158 +                }
5159 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5160 +              continue;
5161 +            }
5162 +          if (LocaleCompare(attribute,"id") == 0)
5163 +            {
5164 +              if (image != (Image *) NULL)
5165 +                {
5166 +                  char
5167 +                    key[MaxTextExtent];
5168 +
5169 +                  MagickBooleanType
5170 +                    status;
5171 +
5172 +                  static ssize_t
5173 +                    id = 0;
5174 +
5175 +                  (void) FormatLocaleString(key,MaxTextExtent,"%.20g\n",(double)
5176 +                    id);
5177 +                  status=SetImageRegistry(ImageRegistryType,key,image,
5178 +                    &image->exception);
5179 +                  (void) status;
5180 +                  s=newSViv(id++);
5181 +                }
5182 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5183 +              continue;
5184 +            }
5185 +          if (LocaleNCompare(attribute,"index",5) == 0)
5186 +            {
5187 +              char
5188 +                name[MaxTextExtent];
5189 +
5190 +              int
5191 +                items;
5192 +
5193 +              long
5194 +                x,
5195 +                y;
5196 +
5197 +              register const IndexPacket
5198 +                *indexes;
5199 +
5200 +              register const PixelPacket
5201 +                *p;
5202 +
5203 +              CacheView
5204 +                *image_view;
5205 +
5206 +              if (image == (Image *) NULL)
5207 +                break;
5208 +              if (image->storage_class != PseudoClass)
5209 +                break;
5210 +              x=0;
5211 +              y=0;
5212 +              items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
5213 +              (void) items;
5214 +              image_view=AcquireVirtualCacheView(image,exception);
5215 +              p=GetCacheViewVirtualPixels(image_view,x,y,1,1,&image->exception);
5216 +              if (p != (const PixelPacket *) NULL)
5217 +                {
5218 +                  indexes=GetCacheViewVirtualIndexQueue(image_view);
5219 +                  (void) FormatLocaleString(name,MaxTextExtent,QuantumFormat,
5220 +                    GetPixelIndex(indexes));
5221 +                  s=newSVpv(name,0);
5222 +                  PUSHs(s ? sv_2mortal(s) : &sv_undef);
5223 +                }
5224 +              image_view=DestroyCacheView(image_view);
5225 +              continue;
5226 +            }
5227 +          if (LocaleCompare(attribute,"iptc") == 0)
5228 +            {
5229 +              if (image != (Image *) NULL)
5230 +                {
5231 +                  const StringInfo
5232 +                    *profile;
5233 +
5234 +                  profile=GetImageProfile(image,"iptc");
5235 +                  if (profile != (const StringInfo *) NULL)
5236 +                    s=newSVpv((const char *) GetStringInfoDatum(profile),
5237 +                      GetStringInfoLength(profile));
5238 +                }
5239 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5240 +              continue;
5241 +            }
5242 +          if (LocaleCompare(attribute,"iterations") == 0)  /* same as loop */
5243 +            {
5244 +              if (image != (Image *) NULL)
5245 +                s=newSViv((ssize_t) image->iterations);
5246 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5247 +              continue;
5248 +            }
5249 +          if (LocaleCompare(attribute,"interlace") == 0)
5250 +            {
5251 +              j=info ? info->image_info->interlace : image ? image->interlace :
5252 +                UndefinedInterlace;
5253 +              s=newSViv(j);
5254 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickInterlaceOptions,
5255 +                j));
5256 +              SvIOK_on(s);
5257 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5258 +              continue;
5259 +            }
5260 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5261 +            attribute);
5262 +          break;
5263 +        }
5264 +        case 'L':
5265 +        case 'l':
5266 +        {
5267 +          if (LocaleCompare(attribute,"label") == 0)
5268 +            {
5269 +              const char
5270 +                *value;
5271 +
5272 +              if (image == (Image *) NULL)
5273 +                break;
5274 +              value=GetImageProperty(image,"Label");
5275 +              if (value != (const char *) NULL)
5276 +                s=newSVpv(value,0);
5277 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5278 +              continue;
5279 +            }
5280 +          if (LocaleCompare(attribute,"loop") == 0)  /* same as iterations */
5281 +            {
5282 +              if (image != (Image *) NULL)
5283 +                s=newSViv((ssize_t) image->iterations);
5284 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5285 +              continue;
5286 +            }
5287 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5288 +            attribute);
5289 +          break;
5290 +        }
5291 +        case 'M':
5292 +        case 'm':
5293 +        {
5294 +          if (LocaleCompare(attribute,"magick") == 0)
5295 +            {
5296 +              if (info && *info->image_info->magick)
5297 +                s=newSVpv(info->image_info->magick,0);
5298 +              if (image != (Image *) NULL)
5299 +                s=newSVpv(image->magick,0);
5300 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5301 +              continue;
5302 +            }
5303 +          if (LocaleCompare(attribute,"map") == 0)
5304 +            {
5305 +              s=newSViv(GetMagickResource(MapResource));
5306 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5307 +              continue;
5308 +            }
5309 +          if (LocaleCompare(attribute,"maximum-error") == 0)
5310 +            {
5311 +              if (image != (Image *) NULL)
5312 +                s=newSVnv(image->error.normalized_maximum_error);
5313 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5314 +              continue;
5315 +            }
5316 +          if (LocaleCompare(attribute,"memory") == 0)
5317 +            {
5318 +              s=newSViv(GetMagickResource(MemoryResource));
5319 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5320 +              continue;
5321 +            }
5322 +          if (LocaleCompare(attribute,"mean-error") == 0)
5323 +            {
5324 +              if (image != (Image *) NULL)
5325 +                s=newSVnv(image->error.normalized_mean_error);
5326 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5327 +              continue;
5328 +            }
5329 +          if (LocaleCompare(attribute,"mime") == 0)
5330 +            {
5331 +              if (info && *info->image_info->magick)
5332 +                s=newSVpv(MagickToMime(info->image_info->magick),0);
5333 +              if (image != (Image *) NULL)
5334 +                s=newSVpv(MagickToMime(image->magick),0);
5335 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5336 +              continue;
5337 +            }
5338 +          if (LocaleCompare(attribute,"mattecolor") == 0)
5339 +            {
5340 +              if (image == (Image *) NULL)
5341 +                break;
5342 +              (void) FormatLocaleString(color,MaxTextExtent,QuantumFormat ","
5343 +                QuantumFormat "," QuantumFormat "," QuantumFormat,
5344 +                image->matte_color.red,image->matte_color.green,
5345 +                image->matte_color.blue,image->matte_color.opacity);
5346 +              s=newSVpv(color,0);
5347 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5348 +              continue;
5349 +            }
5350 +          if (LocaleCompare(attribute,"matte") == 0)
5351 +            {
5352 +              if (image != (Image *) NULL)
5353 +                s=newSViv((ssize_t) image->matte);
5354 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5355 +              continue;
5356 +            }
5357 +          if (LocaleCompare(attribute,"mime") == 0)
5358 +            {
5359 +              const char
5360 +                *magick;
5361 +
5362 +              magick=NULL;
5363 +              if (info && *info->image_info->magick)
5364 +                magick=info->image_info->magick;
5365 +              if (image != (Image *) NULL)
5366 +                magick=image->magick;
5367 +              if (magick)
5368 +                {
5369 +                  char
5370 +                    *mime;
5371 +
5372 +                  mime=MagickToMime(magick);
5373 +                  s=newSVpv(mime,0);
5374 +                  mime=(char *) RelinquishMagickMemory(mime);
5375 +                }
5376 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5377 +              continue;
5378 +            }
5379 +          if (LocaleCompare(attribute,"monochrome") == 0)
5380 +            {
5381 +              if (image == (Image *) NULL)
5382 +                continue;
5383 +              j=info ? info->image_info->monochrome :
5384 +                IsMonochromeImage(image,&image->exception);
5385 +              s=newSViv(j);
5386 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5387 +              continue;
5388 +            }
5389 +          if (LocaleCompare(attribute,"montage") == 0)
5390 +            {
5391 +              if (image && image->montage)
5392 +                s=newSVpv(image->montage,0);
5393 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5394 +              continue;
5395 +            }
5396 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5397 +            attribute);
5398 +          break;
5399 +        }
5400 +        case 'O':
5401 +        case 'o':
5402 +        {
5403 +          if (LocaleCompare(attribute,"orientation") == 0)
5404 +            {
5405 +              j=info ? info->image_info->orientation : image ?
5406 +                image->orientation : UndefinedOrientation;
5407 +              s=newSViv(j);
5408 +              (void) sv_setpv(s,CommandOptionToMnemonic(
5409 +                MagickOrientationOptions,j));
5410 +              SvIOK_on(s);
5411 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5412 +              continue;
5413 +            }
5414 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5415 +            attribute);
5416 +          break;
5417 +        }
5418 +        case 'P':
5419 +        case 'p':
5420 +        {
5421 +          if (LocaleCompare(attribute,"page") == 0)
5422 +            {
5423 +              if (info && info->image_info->page)
5424 +                s=newSVpv(info->image_info->page,0);
5425 +              if (image != (Image *) NULL)
5426 +                {
5427 +                  char
5428 +                    geometry[MaxTextExtent];
5429 +
5430 +                  (void) FormatLocaleString(geometry,MaxTextExtent,
5431 +                    "%.20gx%.20g%+.20g%+.20g",(double) image->page.width,
5432 +                    (double) image->page.height,(double) image->page.x,(double)
5433 +                    image->page.y);
5434 +                  s=newSVpv(geometry,0);
5435 +                }
5436 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5437 +              continue;
5438 +            }
5439 +          if (LocaleCompare(attribute,"page.x") == 0)
5440 +            {
5441 +              if (image != (Image *) NULL)
5442 +                s=newSViv((ssize_t) image->page.x);
5443 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5444 +              continue;
5445 +            }
5446 +          if (LocaleCompare(attribute,"page.y") == 0)
5447 +            {
5448 +              if (image != (Image *) NULL)
5449 +                s=newSViv((ssize_t) image->page.y);
5450 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5451 +              continue;
5452 +            }
5453 +          if (LocaleNCompare(attribute,"pixel",5) == 0)
5454 +            {
5455 +              char
5456 +                tuple[MaxTextExtent];
5457 +
5458 +              int
5459 +                items;
5460 +
5461 +              long
5462 +                x,
5463 +                y;
5464 +
5465 +              register const PixelPacket
5466 +                *p;
5467 +
5468 +              register const IndexPacket
5469 +                *indexes;
5470 +
5471 +              if (image == (Image *) NULL)
5472 +                break;
5473 +              x=0;
5474 +              y=0;
5475 +              items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
5476 +              (void) items;
5477 +              p=GetVirtualPixels(image,x,y,1,1,exception);
5478 +              indexes=GetVirtualIndexQueue(image);
5479 +              if (image->colorspace != CMYKColorspace)
5480 +                (void) FormatLocaleString(tuple,MaxTextExtent,QuantumFormat ","
5481 +                  QuantumFormat "," QuantumFormat "," QuantumFormat,
5482 +                  GetPixelRed(p),GetPixelGreen(p),
5483 +                  GetPixelBlue(p),GetPixelOpacity(p));
5484 +              else
5485 +                (void) FormatLocaleString(tuple,MaxTextExtent,QuantumFormat ","
5486 +                  QuantumFormat "," QuantumFormat "," QuantumFormat ","
5487 +                  QuantumFormat,GetPixelRed(p),
5488 +                  GetPixelGreen(p),GetPixelBlue(p),
5489 +                  GetPixelIndex(indexes),GetPixelOpacity(p));
5490 +              s=newSVpv(tuple,0);
5491 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5492 +              continue;
5493 +            }
5494 +          if (LocaleCompare(attribute,"pointsize") == 0)
5495 +            {
5496 +              if (info)
5497 +                s=newSViv((ssize_t) info->image_info->pointsize);
5498 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5499 +              continue;
5500 +            }
5501 +          if (LocaleCompare(attribute,"preview") == 0)
5502 +            {
5503 +              s=newSViv(info->image_info->preview_type);
5504 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickPreviewOptions,
5505 +                info->image_info->preview_type));
5506 +              SvIOK_on(s);
5507 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5508 +              continue;
5509 +            }
5510 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5511 +            attribute);
5512 +          break;
5513 +        }
5514 +        case 'Q':
5515 +        case 'q':
5516 +        {
5517 +          if (LocaleCompare(attribute,"quality") == 0)
5518 +            {
5519 +              if (info)
5520 +                s=newSViv((ssize_t) info->image_info->quality);
5521 +              if (image != (Image *) NULL)
5522 +                s=newSViv((ssize_t) image->quality);
5523 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5524 +              continue;
5525 +            }
5526 +          if (LocaleCompare(attribute,"quantum") == 0)
5527 +            {
5528 +              if (info)
5529 +                s=newSViv((ssize_t) MAGICKCORE_QUANTUM_DEPTH);
5530 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5531 +              continue;
5532 +            }
5533 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5534 +            attribute);
5535 +          break;
5536 +        }
5537 +        case 'R':
5538 +        case 'r':
5539 +        {
5540 +          if (LocaleCompare(attribute,"rendering-intent") == 0)
5541 +            {
5542 +              s=newSViv(image->rendering_intent);
5543 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickIntentOptions,
5544 +                image->rendering_intent));
5545 +              SvIOK_on(s);
5546 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5547 +              continue;
5548 +            }
5549 +          if (LocaleCompare(attribute,"red-primary") == 0)
5550 +            {
5551 +              if (image == (Image *) NULL)
5552 +                break;
5553 +              (void) FormatLocaleString(color,MaxTextExtent,"%.15g,%.15g",
5554 +                image->chromaticity.red_primary.x,
5555 +                image->chromaticity.red_primary.y);
5556 +              s=newSVpv(color,0);
5557 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5558 +              continue;
5559 +            }
5560 +          if (LocaleCompare(attribute,"rows") == 0)
5561 +            {
5562 +              if (image != (Image *) NULL)
5563 +                s=newSViv((ssize_t) image->rows);
5564 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5565 +              continue;
5566 +            }
5567 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5568 +            attribute);
5569 +          break;
5570 +        }
5571 +        case 'S':
5572 +        case 's':
5573 +        {
5574 +          if (LocaleCompare(attribute,"sampling-factor") == 0)
5575 +            {
5576 +              if (info && info->image_info->sampling_factor)
5577 +                s=newSVpv(info->image_info->sampling_factor,0);
5578 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5579 +              continue;
5580 +            }
5581 +          if (LocaleCompare(attribute,"subimage") == 0)
5582 +            {
5583 +              if (info)
5584 +                s=newSViv((ssize_t) info->image_info->subimage);
5585 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5586 +              continue;
5587 +            }
5588 +          if (LocaleCompare(attribute,"subrange") == 0)
5589 +            {
5590 +              if (info)
5591 +                s=newSViv((ssize_t) info->image_info->subrange);
5592 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5593 +              continue;
5594 +            }
5595 +          if (LocaleCompare(attribute,"server") == 0)  /* same as display */
5596 +            {
5597 +              if (info && info->image_info->server_name)
5598 +                s=newSVpv(info->image_info->server_name,0);
5599 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5600 +              continue;
5601 +            }
5602 +          if (LocaleCompare(attribute,"size") == 0)
5603 +            {
5604 +              if (info && info->image_info->size)
5605 +                s=newSVpv(info->image_info->size,0);
5606 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5607 +              continue;
5608 +            }
5609 +          if (LocaleCompare(attribute,"scene") == 0)
5610 +            {
5611 +              if (image != (Image *) NULL)
5612 +                s=newSViv((ssize_t) image->scene);
5613 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5614 +              continue;
5615 +            }
5616 +          if (LocaleCompare(attribute,"scenes") == 0)
5617 +            {
5618 +              if (image != (Image *) NULL)
5619 +                s=newSViv((ssize_t) info->image_info->number_scenes);
5620 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5621 +              continue;
5622 +            }
5623 +          if (LocaleCompare(attribute,"signature") == 0)
5624 +            {
5625 +              const char
5626 +                *value;
5627 +
5628 +              if (image == (Image *) NULL)
5629 +                break;
5630 +              (void) SignatureImage(image);
5631 +              value=GetImageProperty(image,"Signature");
5632 +              if (value != (const char *) NULL)
5633 +                s=newSVpv(value,0);
5634 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5635 +              continue;
5636 +            }
5637 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5638 +            attribute);
5639 +          break;
5640 +        }
5641 +        case 'T':
5642 +        case 't':
5643 +        {
5644 +          if (LocaleCompare(attribute,"taint") == 0)
5645 +            {
5646 +              if (image != (Image *) NULL)
5647 +                s=newSViv((ssize_t) IsTaintImage(image));
5648 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5649 +              continue;
5650 +            }
5651 +          if (LocaleCompare(attribute,"tile") == 0)
5652 +            {
5653 +              if (info && info->image_info->tile)
5654 +                s=newSVpv(info->image_info->tile,0);
5655 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5656 +              continue;
5657 +            }
5658 +          if (LocaleCompare(attribute,"texture") == 0)
5659 +            {
5660 +              if (info && info->image_info->texture)
5661 +                s=newSVpv(info->image_info->texture,0);
5662 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5663 +              continue;
5664 +            }
5665 +          if (LocaleCompare(attribute,"total-ink-density") == 0)
5666 +            {
5667 +              s=newSViv(MAGICKCORE_QUANTUM_DEPTH);
5668 +              if (image != (Image *) NULL)
5669 +                s=newSVnv(GetImageTotalInkDensity(image));
5670 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5671 +              continue;
5672 +            }
5673 +          if (LocaleCompare(attribute,"transparent-color") == 0)
5674 +            {
5675 +              if (image == (Image *) NULL)
5676 +                break;
5677 +              (void) FormatLocaleString(color,MaxTextExtent,QuantumFormat ","
5678 +                QuantumFormat "," QuantumFormat "," QuantumFormat,
5679 +                image->transparent_color.red,image->transparent_color.green,
5680 +                image->transparent_color.blue,image->transparent_color.opacity);
5681 +              s=newSVpv(color,0);
5682 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5683 +              continue;
5684 +            }
5685 +          if (LocaleCompare(attribute,"type") == 0)
5686 +            {
5687 +              if (image == (Image *) NULL)
5688 +                break;
5689 +              j=(ssize_t) GetImageType(image,&image->exception);
5690 +              s=newSViv(j);
5691 +              (void) sv_setpv(s,CommandOptionToMnemonic(MagickTypeOptions,j));
5692 +              SvIOK_on(s);
5693 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5694 +              continue;
5695 +            }
5696 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5697 +            attribute);
5698 +          break;
5699 +        }
5700 +        case 'U':
5701 +        case 'u':
5702 +        {
5703 +          if (LocaleCompare(attribute,"units") == 0)
5704 +            {
5705 +              j=info ? info->image_info->units : image ? image->units :
5706 +                UndefinedResolution;
5707 +              if (info && (info->image_info->units == UndefinedResolution))
5708 +                if (image)
5709 +                  j=image->units;
5710 +              if (j == UndefinedResolution)
5711 +                s=newSVpv("undefined units",0);
5712 +              else
5713 +                if (j == PixelsPerInchResolution)
5714 +                  s=newSVpv("pixels / inch",0);
5715 +                else
5716 +                  s=newSVpv("pixels / centimeter",0);
5717 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5718 +              continue;
5719 +            }
5720 +          if (LocaleCompare(attribute,"user-time") == 0)
5721 +            {
5722 +              if (image != (Image *) NULL)
5723 +                s=newSVnv(GetUserTime(&image->timer));
5724 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5725 +              continue;
5726 +            }
5727 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5728 +            attribute);
5729 +          break;
5730 +        }
5731 +        case 'V':
5732 +        case 'v':
5733 +        {
5734 +          if (LocaleCompare(attribute,"verbose") == 0)
5735 +            {
5736 +              if (info)
5737 +                s=newSViv((ssize_t) info->image_info->verbose);
5738 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5739 +              continue;
5740 +            }
5741 +          if (LocaleCompare(attribute,"version") == 0)
5742 +            {
5743 +              s=newSVpv(GetMagickVersion((size_t *) NULL),0);
5744 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5745 +              continue;
5746 +            }
5747 +          if (LocaleCompare(attribute,"view") == 0)
5748 +            {
5749 +              if (info && info->image_info->view)
5750 +                s=newSVpv(info->image_info->view,0);
5751 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5752 +              continue;
5753 +            }
5754 +          if (LocaleCompare(attribute,"virtual-pixel") == 0)
5755 +            {
5756 +              if (image == (Image *) NULL)
5757 +                break;
5758 +              j=(ssize_t) GetImageVirtualPixelMethod(image);
5759 +              s=newSViv(j);
5760 +              (void) sv_setpv(s,CommandOptionToMnemonic(
5761 +                MagickVirtualPixelOptions,j));
5762 +              SvIOK_on(s);
5763 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5764 +              continue;
5765 +            }
5766 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5767 +            attribute);
5768 +          break;
5769 +        }
5770 +        case 'W':
5771 +        case 'w':
5772 +        {
5773 +          if (LocaleCompare(attribute,"white-point") == 0)
5774 +            {
5775 +              if (image == (Image *) NULL)
5776 +                break;
5777 +              (void) FormatLocaleString(color,MaxTextExtent,"%.15g,%.15g",
5778 +                image->chromaticity.white_point.x,
5779 +                image->chromaticity.white_point.y);
5780 +              s=newSVpv(color,0);
5781 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5782 +              continue;
5783 +            }
5784 +          if (LocaleCompare(attribute,"width") == 0)
5785 +            {
5786 +              if (image != (Image *) NULL)
5787 +                s=newSViv((ssize_t) image->columns);
5788 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5789 +              continue;
5790 +            }
5791 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5792 +             attribute);
5793 +          break;
5794 +        }
5795 +        case 'X':
5796 +        case 'x':
5797 +        {
5798 +          if (LocaleCompare(attribute,"xmp") == 0)
5799 +            {
5800 +              if (image != (Image *) NULL)
5801 +                {
5802 +                  const StringInfo
5803 +                    *profile;
5804 +
5805 +                  profile=GetImageProfile(image,"xmp");
5806 +                  if (profile != (StringInfo *) NULL)
5807 +                    s=newSVpv((const char *) GetStringInfoDatum(profile),
5808 +                      GetStringInfoLength(profile));
5809 +                }
5810 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5811 +              continue;
5812 +            }
5813 +          if (LocaleCompare(attribute,"x-resolution") == 0)
5814 +            {
5815 +              if (image != (Image *) NULL)
5816 +                s=newSVnv(image->x_resolution);
5817 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5818 +              continue;
5819 +            }
5820 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5821 +            attribute);
5822 +          break;
5823 +        }
5824 +        case 'Y':
5825 +        case 'y':
5826 +        {
5827 +          if (LocaleCompare(attribute,"y-resolution") == 0)
5828 +            {
5829 +              if (image != (Image *) NULL)
5830 +                s=newSVnv(image->y_resolution);
5831 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5832 +              continue;
5833 +            }
5834 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5835 +            attribute);
5836 +          break;
5837 +        }
5838 +        default:
5839 +          break;
5840 +      }
5841 +      if (image == (Image *) NULL)
5842 +        ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5843 +          attribute)
5844 +      else
5845 +        {
5846 +          value=GetImageProperty(image,attribute);
5847 +          if (value != (const char *) NULL)
5848 +            {
5849 +              s=newSVpv(value,0);
5850 +              PUSHs(s ? sv_2mortal(s) : &sv_undef);
5851 +            }
5852 +          else
5853 +            if (*attribute != '%')
5854 +              ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5855 +                attribute)
5856 +            else
5857 +              {
5858 +                 char
5859 +                   *meta;
5860 +
5861 +                 meta=InterpretImageProperties(info ? info->image_info :
5862 +                   (ImageInfo *) NULL,image,attribute);
5863 +                 s=newSVpv(meta,0);
5864 +                 PUSHs(s ? sv_2mortal(s) : &sv_undef);
5865 +                 meta=(char *) RelinquishMagickMemory(meta);
5866 +              }
5867 +        }
5868 +    }
5869 +    exception=DestroyExceptionInfo(exception);
5870 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
5871 +  }
5872 +\f
5873 +#
5874 +###############################################################################
5875 +#                                                                             #
5876 +#                                                                             #
5877 +#                                                                             #
5878 +#   G e t A u t h e n t i c P i x e l s                                       #
5879 +#                                                                             #
5880 +#                                                                             #
5881 +#                                                                             #
5882 +###############################################################################
5883 +#
5884 +#
5885 +void *
5886 +GetAuthenticPixels(ref,...)
5887 +  Image::Magick ref = NO_INIT
5888 +  ALIAS:
5889 +    getauthenticpixels = 1
5890 +    GetImagePixels = 2
5891 +    getimagepixels = 3
5892 +  CODE:
5893 +  {
5894 +    char
5895 +      *attribute;
5896 +
5897 +    ExceptionInfo
5898 +      *exception;
5899 +
5900 +    Image
5901 +      *image;
5902 +
5903 +    RectangleInfo
5904 +      region;
5905 +
5906 +    ssize_t
5907 +      i;
5908 +
5909 +    struct PackageInfo
5910 +      *info;
5911 +
5912 +    SV
5913 +      *perl_exception,
5914 +      *reference;
5915 +
5916 +    void
5917 +      *blob = NULL;
5918 +
5919 +    PERL_UNUSED_VAR(ref);
5920 +    PERL_UNUSED_VAR(ix);
5921 +    exception=AcquireExceptionInfo();
5922 +    perl_exception=newSVpv("",0);
5923 +    if (sv_isobject(ST(0)) == 0)
5924 +      {
5925 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
5926 +          PackageName);
5927 +        goto PerlException;
5928 +      }
5929 +    reference=SvRV(ST(0));
5930 +
5931 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
5932 +    if (image == (Image *) NULL)
5933 +      {
5934 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
5935 +          PackageName);
5936 +        goto PerlException;
5937 +      }
5938 +
5939 +    region.x=0;
5940 +    region.y=0;
5941 +    region.width=image->columns;
5942 +    region.height=1;
5943 +    if (items == 1)
5944 +      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&region);
5945 +    for (i=2; i < items; i+=2)
5946 +    {
5947 +      attribute=(char *) SvPV(ST(i-1),na);
5948 +      switch (*attribute)
5949 +      {
5950 +        case 'g':
5951 +        case 'G':
5952 +        {
5953 +          if (LocaleCompare(attribute,"geometry") == 0)
5954 +            {
5955 +              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&region);
5956 +              break;
5957 +            }
5958 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
5959 +            attribute);
5960 +          break;
5961 +        }
5962 +        case 'H':
5963 +        case 'h':
5964 +        {
5965 +          if (LocaleCompare(attribute,"height") == 0)
5966 +            {
5967 +              region.height=SvIV(ST(i));
5968 +              continue;
5969 +            }
5970 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
5971 +            attribute);
5972 +          break;
5973 +        }
5974 +        case 'X':
5975 +        case 'x':
5976 +        {
5977 +          if (LocaleCompare(attribute,"x") == 0)
5978 +            {
5979 +              region.x=SvIV(ST(i));
5980 +              continue;
5981 +            }
5982 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
5983 +            attribute);
5984 +          break;
5985 +        }
5986 +        case 'Y':
5987 +        case 'y':
5988 +        {
5989 +          if (LocaleCompare(attribute,"y") == 0)
5990 +            {
5991 +              region.y=SvIV(ST(i));
5992 +              continue;
5993 +            }
5994 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
5995 +            attribute);
5996 +          break;
5997 +        }
5998 +        case 'W':
5999 +        case 'w':
6000 +        {
6001 +          if (LocaleCompare(attribute,"width") == 0)
6002 +            {
6003 +              region.width=SvIV(ST(i));
6004 +              continue;
6005 +            }
6006 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
6007 +            attribute);
6008 +          break;
6009 +        }
6010 +      }
6011 +    }
6012 +    blob=(void *) GetAuthenticPixels(image,region.x,region.y,region.width,
6013 +      region.height,exception);
6014 +    if (blob != (void *) NULL)
6015 +      goto PerlEnd;
6016 +
6017 +  PerlException:
6018 +    InheritPerlException(exception,perl_exception);
6019 +    exception=DestroyExceptionInfo(exception);
6020 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
6021 +
6022 +  PerlEnd:
6023 +    RETVAL = blob;
6024 +  }
6025 +  OUTPUT:
6026 +    RETVAL
6027 +\f
6028 +#
6029 +###############################################################################
6030 +#                                                                             #
6031 +#                                                                             #
6032 +#                                                                             #
6033 +#   G e t V i r t u a l P i x e l s                                           #
6034 +#                                                                             #
6035 +#                                                                             #
6036 +#                                                                             #
6037 +###############################################################################
6038 +#
6039 +#
6040 +void *
6041 +GetVirtualPixels(ref,...)
6042 +  Image::Magick ref = NO_INIT
6043 +  ALIAS:
6044 +    getvirtualpixels = 1
6045 +    AcquireImagePixels = 2
6046 +    acquireimagepixels = 3
6047 +  CODE:
6048 +  {
6049 +    char
6050 +      *attribute;
6051 +
6052 +    const void
6053 +      *blob = NULL;
6054 +
6055 +    ExceptionInfo
6056 +      *exception;
6057 +
6058 +    Image
6059 +      *image;
6060 +
6061 +    RectangleInfo
6062 +      region;
6063 +
6064 +    ssize_t
6065 +      i;
6066 +
6067 +    struct PackageInfo
6068 +      *info;
6069 +
6070 +    SV
6071 +      *perl_exception,
6072 +      *reference;
6073 +
6074 +    PERL_UNUSED_VAR(ref);
6075 +    PERL_UNUSED_VAR(ix);
6076 +    exception=AcquireExceptionInfo();
6077 +    perl_exception=newSVpv("",0);
6078 +    if (sv_isobject(ST(0)) == 0)
6079 +      {
6080 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
6081 +          PackageName);
6082 +        goto PerlException;
6083 +      }
6084 +    reference=SvRV(ST(0));
6085 +
6086 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6087 +    if (image == (Image *) NULL)
6088 +      {
6089 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6090 +          PackageName);
6091 +        goto PerlException;
6092 +      }
6093 +
6094 +    region.x=0;
6095 +    region.y=0;
6096 +    region.width=image->columns;
6097 +    region.height=1;
6098 +    if (items == 1)
6099 +      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&region);
6100 +    for (i=2; i < items; i+=2)
6101 +    {
6102 +      attribute=(char *) SvPV(ST(i-1),na);
6103 +      switch (*attribute)
6104 +      {
6105 +        case 'g':
6106 +        case 'G':
6107 +        {
6108 +          if (LocaleCompare(attribute,"geometry") == 0)
6109 +            {
6110 +              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&region);
6111 +              break;
6112 +            }
6113 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6114 +            attribute);
6115 +          break;
6116 +        }
6117 +        case 'H':
6118 +        case 'h':
6119 +        {
6120 +          if (LocaleCompare(attribute,"height") == 0)
6121 +            {
6122 +              region.height=SvIV(ST(i));
6123 +              continue;
6124 +            }
6125 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
6126 +            attribute);
6127 +          break;
6128 +        }
6129 +        case 'X':
6130 +        case 'x':
6131 +        {
6132 +          if (LocaleCompare(attribute,"x") == 0)
6133 +            {
6134 +              region.x=SvIV(ST(i));
6135 +              continue;
6136 +            }
6137 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
6138 +            attribute);
6139 +          break;
6140 +        }
6141 +        case 'Y':
6142 +        case 'y':
6143 +        {
6144 +          if (LocaleCompare(attribute,"y") == 0)
6145 +            {
6146 +              region.y=SvIV(ST(i));
6147 +              continue;
6148 +            }
6149 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
6150 +            attribute);
6151 +          break;
6152 +        }
6153 +        case 'W':
6154 +        case 'w':
6155 +        {
6156 +          if (LocaleCompare(attribute,"width") == 0)
6157 +            {
6158 +              region.width=SvIV(ST(i));
6159 +              continue;
6160 +            }
6161 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
6162 +            attribute);
6163 +          break;
6164 +        }
6165 +      }
6166 +    }
6167 +    blob=(const void *) GetVirtualPixels(image,region.x,region.y,region.width,
6168 +      region.height,exception);
6169 +    if (blob != (void *) NULL)
6170 +      goto PerlEnd;
6171 +
6172 +  PerlException:
6173 +    InheritPerlException(exception,perl_exception);
6174 +    exception=DestroyExceptionInfo(exception);
6175 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
6176 +
6177 +  PerlEnd:
6178 +    RETVAL = (void *) blob;
6179 +  }
6180 +  OUTPUT:
6181 +    RETVAL
6182 +\f
6183 +#
6184 +###############################################################################
6185 +#                                                                             #
6186 +#                                                                             #
6187 +#                                                                             #
6188 +#   G e t A u t h e n t i c I n d e x Q u e u e                               #
6189 +#                                                                             #
6190 +#                                                                             #
6191 +#                                                                             #
6192 +###############################################################################
6193 +#
6194 +#
6195 +void *
6196 +GetAuthenticIndexQueue(ref,...)
6197 +  Image::Magick ref = NO_INIT
6198 +  ALIAS:
6199 +    getauthenticindexqueue = 1
6200 +    GetIndexes = 2
6201 +    getindexes = 3
6202 +  CODE:
6203 +  {
6204 +    ExceptionInfo
6205 +      *exception;
6206 +
6207 +    Image
6208 +      *image;
6209 +
6210 +    struct PackageInfo
6211 +      *info;
6212 +
6213 +    SV
6214 +      *perl_exception,
6215 +      *reference;
6216 +
6217 +    void
6218 +      *blob = NULL;
6219 +
6220 +    PERL_UNUSED_VAR(ref);
6221 +    PERL_UNUSED_VAR(ix);
6222 +    exception=AcquireExceptionInfo();
6223 +    perl_exception=newSVpv("",0);
6224 +    if (sv_isobject(ST(0)) == 0)
6225 +      {
6226 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
6227 +          PackageName);
6228 +        goto PerlException;
6229 +      }
6230 +    reference=SvRV(ST(0));
6231 +
6232 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6233 +    if (image == (Image *) NULL)
6234 +      {
6235 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6236 +          PackageName);
6237 +        goto PerlException;
6238 +      }
6239 +
6240 +    blob=(void *) GetAuthenticIndexQueue(image);
6241 +    if (blob != (void *) NULL)
6242 +      goto PerlEnd;
6243 +
6244 +  PerlException:
6245 +    InheritPerlException(exception,perl_exception);
6246 +    exception=DestroyExceptionInfo(exception);
6247 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
6248 +
6249 +  PerlEnd:
6250 +    RETVAL = blob;
6251 +  }
6252 +  OUTPUT:
6253 +    RETVAL
6254 +\f
6255 +#
6256 +###############################################################################
6257 +#                                                                             #
6258 +#                                                                             #
6259 +#                                                                             #
6260 +#   G e t V i r t u a l I n d e x Q u e u e                                   #
6261 +#                                                                             #
6262 +#                                                                             #
6263 +#                                                                             #
6264 +###############################################################################
6265 +#
6266 +#
6267 +void *
6268 +GetVirtualIndexQueue(ref,...)
6269 +  Image::Magick ref = NO_INIT
6270 +  ALIAS:
6271 +    getvirtualindexqueue = 1
6272 +  CODE:
6273 +  {
6274 +    ExceptionInfo
6275 +      *exception;
6276 +
6277 +    Image
6278 +      *image;
6279 +
6280 +    struct PackageInfo
6281 +      *info;
6282 +
6283 +    SV
6284 +      *perl_exception,
6285 +      *reference;
6286 +
6287 +    void
6288 +      *blob = NULL;
6289 +
6290 +    PERL_UNUSED_VAR(ref);
6291 +    PERL_UNUSED_VAR(ix);
6292 +    exception=AcquireExceptionInfo();
6293 +    perl_exception=newSVpv("",0);
6294 +    if (sv_isobject(ST(0)) == 0)
6295 +      {
6296 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
6297 +          PackageName);
6298 +        goto PerlException;
6299 +      }
6300 +    reference=SvRV(ST(0));
6301 +
6302 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6303 +    if (image == (Image *) NULL)
6304 +      {
6305 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6306 +          PackageName);
6307 +        goto PerlException;
6308 +      }
6309 +
6310 +    blob=(void *) GetVirtualIndexQueue(image);
6311 +    if (blob != (void *) NULL)
6312 +      goto PerlEnd;
6313 +
6314 +  PerlException:
6315 +    InheritPerlException(exception,perl_exception);
6316 +    exception=DestroyExceptionInfo(exception);
6317 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
6318 +
6319 +  PerlEnd:
6320 +    RETVAL = blob;
6321 +  }
6322 +  OUTPUT:
6323 +    RETVAL
6324 +\f
6325 +#
6326 +###############################################################################
6327 +#                                                                             #
6328 +#                                                                             #
6329 +#                                                                             #
6330 +#   H i s t o g r a m                                                         #
6331 +#                                                                             #
6332 +#                                                                             #
6333 +#                                                                             #
6334 +###############################################################################
6335 +#
6336 +#
6337 +void
6338 +Histogram(ref,...)
6339 +  Image::Magick ref = NO_INIT
6340 +  ALIAS:
6341 +    HistogramImage = 1
6342 +    histogram      = 2
6343 +    histogramimage = 3
6344 +  PPCODE:
6345 +  {
6346 +    AV
6347 +      *av;
6348 +
6349 +    char
6350 +      message[MaxTextExtent];
6351 +
6352 +    ColorPacket
6353 +      *histogram;
6354 +
6355 +    ExceptionInfo
6356 +      *exception;
6357 +
6358 +    Image
6359 +      *image;
6360 +
6361 +    register ssize_t
6362 +      i;
6363 +
6364 +    ssize_t
6365 +      count;
6366 +
6367 +    struct PackageInfo
6368 +      *info;
6369 +
6370 +    SV
6371 +      *perl_exception,
6372 +      *reference;
6373 +
6374 +    size_t
6375 +      number_colors;
6376 +
6377 +    PERL_UNUSED_VAR(ref);
6378 +    PERL_UNUSED_VAR(ix);
6379 +    exception=AcquireExceptionInfo();
6380 +    perl_exception=newSVpv("",0);
6381 +    av=NULL;
6382 +    if (sv_isobject(ST(0)) == 0)
6383 +      {
6384 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
6385 +          PackageName);
6386 +        goto PerlException;
6387 +      }
6388 +    reference=SvRV(ST(0));
6389 +    av=newAV();
6390 +    SvREFCNT_dec(av);
6391 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6392 +    if (image == (Image *) NULL)
6393 +      {
6394 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6395 +          PackageName);
6396 +        goto PerlException;
6397 +      }
6398 +    count=0;
6399 +    for ( ; image; image=image->next)
6400 +    {
6401 +      histogram=GetImageHistogram(image,&number_colors,&image->exception);
6402 +      if (histogram == (ColorPacket *) NULL)
6403 +        continue;
6404 +      count+=(ssize_t) number_colors;
6405 +      EXTEND(sp,6*count);
6406 +      for (i=0; i < (ssize_t) number_colors; i++)
6407 +      {
6408 +        (void) FormatLocaleString(message,MaxTextExtent,QuantumFormat,
6409 +          histogram[i].pixel.red);
6410 +        PUSHs(sv_2mortal(newSVpv(message,0)));
6411 +        (void) FormatLocaleString(message,MaxTextExtent,QuantumFormat,
6412 +          histogram[i].pixel.green);
6413 +        PUSHs(sv_2mortal(newSVpv(message,0)));
6414 +        (void) FormatLocaleString(message,MaxTextExtent,QuantumFormat,
6415 +          histogram[i].pixel.blue);
6416 +        PUSHs(sv_2mortal(newSVpv(message,0)));
6417 +        if (image->colorspace == CMYKColorspace)
6418 +          {
6419 +            (void) FormatLocaleString(message,MaxTextExtent,QuantumFormat,
6420 +              histogram[i].index);
6421 +            PUSHs(sv_2mortal(newSVpv(message,0)));
6422 +          }
6423 +        (void) FormatLocaleString(message,MaxTextExtent,QuantumFormat,
6424 +          histogram[i].pixel.opacity);
6425 +        PUSHs(sv_2mortal(newSVpv(message,0)));
6426 +        (void) FormatLocaleString(message,MaxTextExtent,"%.20g",(double)
6427 +          histogram[i].count);
6428 +        PUSHs(sv_2mortal(newSVpv(message,0)));
6429 +      }
6430 +      histogram=(ColorPacket *) RelinquishMagickMemory(histogram);
6431 +    }
6432 +
6433 +  PerlException:
6434 +    InheritPerlException(exception,perl_exception);
6435 +    exception=DestroyExceptionInfo(exception);
6436 +    SvREFCNT_dec(perl_exception);
6437 +  }
6438 +\f
6439 +#
6440 +###############################################################################
6441 +#                                                                             #
6442 +#                                                                             #
6443 +#                                                                             #
6444 +#   G e t P i x e l                                                           #
6445 +#                                                                             #
6446 +#                                                                             #
6447 +#                                                                             #
6448 +###############################################################################
6449 +#
6450 +#
6451 +void
6452 +GetPixel(ref,...)
6453 +  Image::Magick ref = NO_INIT
6454 +  ALIAS:
6455 +    getpixel = 1
6456 +    getPixel = 2
6457 +  PPCODE:
6458 +  {
6459 +    AV
6460 +      *av;
6461 +
6462 +    char
6463 +      *attribute;
6464 +
6465 +    ChannelType
6466 +      channel;
6467 +
6468 +    ExceptionInfo
6469 +      *exception;
6470 +
6471 +    Image
6472 +      *image;
6473 +
6474 +    MagickBooleanType
6475 +      normalize;
6476 +
6477 +    RectangleInfo
6478 +      region;
6479 +
6480 +    register const IndexPacket
6481 +      *indexes;
6482 +
6483 +    register const PixelPacket
6484 +      *p;
6485 +
6486 +    register ssize_t
6487 +      i;
6488 +
6489 +    ssize_t
6490 +      option;
6491 +
6492 +    struct PackageInfo
6493 +      *info;
6494 +
6495 +    SV
6496 +      *perl_exception,
6497 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
6498 +
6499 +    PERL_UNUSED_VAR(ref);
6500 +    PERL_UNUSED_VAR(ix);
6501 +    exception=AcquireExceptionInfo();
6502 +    perl_exception=newSVpv("",0);
6503 +    reference=SvRV(ST(0));
6504 +    av=(AV *) reference;
6505 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
6506 +      exception);
6507 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6508 +    if (image == (Image *) NULL)
6509 +      {
6510 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6511 +          PackageName);
6512 +        goto PerlException;
6513 +      }
6514 +    channel=DefaultChannels;
6515 +    normalize=MagickTrue;
6516 +    region.x=0;
6517 +    region.y=0;
6518 +    region.width=image->columns;
6519 +    region.height=1;
6520 +    if (items == 1)
6521 +      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&region);
6522 +    for (i=2; i < items; i+=2)
6523 +    {
6524 +      attribute=(char *) SvPV(ST(i-1),na);
6525 +      switch (*attribute)
6526 +      {
6527 +        case 'C':
6528 +        case 'c':
6529 +        {
6530 +          if (LocaleCompare(attribute,"channel") == 0)
6531 +            {
6532 +              ssize_t
6533 +                option;
6534 +
6535 +              option=ParseChannelOption(SvPV(ST(i),na));
6536 +              if (option < 0)
6537 +                {
6538 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
6539 +                    SvPV(ST(i),na));
6540 +                  return;
6541 +                }
6542 +               channel=(ChannelType) option;
6543 +              break;
6544 +            }
6545 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6546 +            attribute);
6547 +          break;
6548 +        }
6549 +        case 'g':
6550 +        case 'G':
6551 +        {
6552 +          if (LocaleCompare(attribute,"geometry") == 0)
6553 +            {
6554 +              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&region);
6555 +              break;
6556 +            }
6557 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6558 +            attribute);
6559 +          break;
6560 +        }
6561 +        case 'N':
6562 +        case 'n':
6563 +        {
6564 +          if (LocaleCompare(attribute,"normalize") == 0)
6565 +            {
6566 +              option=ParseCommandOption(MagickBooleanOptions,MagickFalse,
6567 +                SvPV(ST(i),na));
6568 +              if (option < 0)
6569 +                {
6570 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
6571 +                    SvPV(ST(i),na));
6572 +                  break;
6573 +                }
6574 +             normalize=option != 0 ? MagickTrue : MagickFalse;
6575 +             break;
6576 +            }
6577 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6578 +            attribute);
6579 +          break;
6580 +        }
6581 +        case 'x':
6582 +        case 'X':
6583 +        {
6584 +          if (LocaleCompare(attribute,"x") == 0)
6585 +            {
6586 +              region.x=SvIV(ST(i));
6587 +              break;
6588 +            }
6589 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6590 +            attribute);
6591 +          break;
6592 +        }
6593 +        case 'y':
6594 +        case 'Y':
6595 +        {
6596 +          if (LocaleCompare(attribute,"y") == 0)
6597 +            {
6598 +              region.y=SvIV(ST(i));
6599 +              break;
6600 +            }
6601 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6602 +            attribute);
6603 +          break;
6604 +        }
6605 +        default:
6606 +        {
6607 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6608 +            attribute);
6609 +          break;
6610 +        }
6611 +      }
6612 +    }
6613 +    p=GetVirtualPixels(image,region.x,region.y,1,1,exception);
6614 +    if (p == (const PixelPacket *) NULL)
6615 +      PUSHs(&sv_undef);
6616 +    else
6617 +      {
6618 +        double
6619 +          scale;
6620 +
6621 +        indexes=GetVirtualIndexQueue(image);
6622 +        scale=1.0;
6623 +        if (normalize != MagickFalse)
6624 +          scale=1.0/QuantumRange;
6625 +        if ((channel & RedChannel) != 0)
6626 +          PUSHs(sv_2mortal(newSVnv(scale*GetPixelRed(p))));
6627 +        if ((channel & GreenChannel) != 0)
6628 +          PUSHs(sv_2mortal(newSVnv(scale*GetPixelGreen(p))));
6629 +        if ((channel & BlueChannel) != 0)
6630 +          PUSHs(sv_2mortal(newSVnv(scale*GetPixelBlue(p))));
6631 +        if (((channel & IndexChannel) != 0) &&
6632 +            (image->colorspace == CMYKColorspace))
6633 +          PUSHs(sv_2mortal(newSVnv(scale*GetPixelIndex(indexes))));
6634 +        if ((channel & OpacityChannel) != 0)
6635 +          PUSHs(sv_2mortal(newSVnv(scale*GetPixelOpacity(p))));
6636 +      }
6637 +
6638 +  PerlException:
6639 +    InheritPerlException(exception,perl_exception);
6640 +    exception=DestroyExceptionInfo(exception);
6641 +    SvREFCNT_dec(perl_exception);
6642 +  }
6643 +\f
6644 +#
6645 +###############################################################################
6646 +#                                                                             #
6647 +#                                                                             #
6648 +#                                                                             #
6649 +#   G e t P i x e l s                                                         #
6650 +#                                                                             #
6651 +#                                                                             #
6652 +#                                                                             #
6653 +###############################################################################
6654 +#
6655 +#
6656 +void
6657 +GetPixels(ref,...)
6658 +  Image::Magick ref = NO_INIT
6659 +  ALIAS:
6660 +    getpixels = 1
6661 +    getPixels = 2
6662 +  PPCODE:
6663 +  {
6664 +    AV
6665 +      *av;
6666 +
6667 +    char
6668 +      *attribute;
6669 +
6670 +    const char
6671 +      *map;
6672 +
6673 +    ExceptionInfo
6674 +      *exception;
6675 +
6676 +    Image
6677 +      *image;
6678 +
6679 +    MagickBooleanType
6680 +      normalize,
6681 +      status;
6682 +
6683 +    RectangleInfo
6684 +      region;
6685 +
6686 +    register ssize_t
6687 +      i;
6688 +
6689 +    ssize_t
6690 +      option;
6691 +
6692 +    struct PackageInfo
6693 +      *info;
6694 +
6695 +    SV
6696 +      *perl_exception,
6697 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
6698 +
6699 +    PERL_UNUSED_VAR(ref);
6700 +    PERL_UNUSED_VAR(ix);
6701 +    exception=AcquireExceptionInfo();
6702 +    perl_exception=newSVpv("",0);
6703 +    reference=SvRV(ST(0));
6704 +    av=(AV *) reference;
6705 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
6706 +      exception);
6707 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6708 +    if (image == (Image *) NULL)
6709 +      {
6710 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6711 +          PackageName);
6712 +        goto PerlException;
6713 +      }
6714 +    map="RGB";
6715 +    if (image->matte != MagickFalse)
6716 +      map="RGBA";
6717 +    if (image->colorspace == CMYKColorspace)
6718 +      {
6719 +        map="CMYK";
6720 +        if (image->matte != MagickFalse)
6721 +          map="CMYKA";
6722 +      }
6723 +    normalize=MagickFalse;
6724 +    region.x=0;
6725 +    region.y=0;
6726 +    region.width=image->columns;
6727 +    region.height=1;
6728 +    if (items == 1)
6729 +      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&region);
6730 +    for (i=2; i < items; i+=2)
6731 +    {
6732 +      attribute=(char *) SvPV(ST(i-1),na);
6733 +      switch (*attribute)
6734 +      {
6735 +        case 'g':
6736 +        case 'G':
6737 +        {
6738 +          if (LocaleCompare(attribute,"geometry") == 0)
6739 +            {
6740 +              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&region);
6741 +              break;
6742 +            }
6743 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6744 +            attribute);
6745 +          break;
6746 +        }
6747 +        case 'H':
6748 +        case 'h':
6749 +        {
6750 +          if (LocaleCompare(attribute,"height") == 0)
6751 +            {
6752 +              region.height=SvIV(ST(i));
6753 +              break;
6754 +            }
6755 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6756 +            attribute);
6757 +          break;
6758 +        }
6759 +        case 'M':
6760 +        case 'm':
6761 +        {
6762 +          if (LocaleCompare(attribute,"map") == 0)
6763 +            {
6764 +              map=SvPV(ST(i),na);
6765 +              break;
6766 +            }
6767 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6768 +            attribute);
6769 +          break;
6770 +        }
6771 +        case 'N':
6772 +        case 'n':
6773 +        {
6774 +          if (LocaleCompare(attribute,"normalize") == 0)
6775 +            {
6776 +              option=ParseCommandOption(MagickBooleanOptions,MagickFalse,
6777 +                SvPV(ST(i),na));
6778 +              if (option < 0)
6779 +                {
6780 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
6781 +                    SvPV(ST(i),na));
6782 +                  break;
6783 +                }
6784 +             normalize=option != 0 ? MagickTrue : MagickFalse;
6785 +             break;
6786 +            }
6787 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6788 +            attribute);
6789 +          break;
6790 +        }
6791 +        case 'W':
6792 +        case 'w':
6793 +        {
6794 +          if (LocaleCompare(attribute,"width") == 0)
6795 +            {
6796 +              region.width=SvIV(ST(i));
6797 +              break;
6798 +            }
6799 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6800 +            attribute);
6801 +          break;
6802 +        }
6803 +        case 'x':
6804 +        case 'X':
6805 +        {
6806 +          if (LocaleCompare(attribute,"x") == 0)
6807 +            {
6808 +              region.x=SvIV(ST(i));
6809 +              break;
6810 +            }
6811 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6812 +            attribute);
6813 +          break;
6814 +        }
6815 +        case 'y':
6816 +        case 'Y':
6817 +        {
6818 +          if (LocaleCompare(attribute,"y") == 0)
6819 +            {
6820 +              region.y=SvIV(ST(i));
6821 +              break;
6822 +            }
6823 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6824 +            attribute);
6825 +          break;
6826 +        }
6827 +        default:
6828 +        {
6829 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
6830 +            attribute);
6831 +          break;
6832 +        }
6833 +      }
6834 +    }
6835 +    if (normalize != MagickFalse)
6836 +      {
6837 +        float
6838 +          *pixels;
6839 +
6840 +        pixels=(float *) AcquireQuantumMemory(strlen(map)*region.width,
6841 +          region.height*sizeof(*pixels));
6842 +        if (pixels == (float *) NULL)
6843 +          {
6844 +            ThrowPerlException(exception,ResourceLimitError,
6845 +              "MemoryAllocationFailed",PackageName);
6846 +            goto PerlException;
6847 +          }
6848 +        status=ExportImagePixels(image,region.x,region.y,region.width,
6849 +          region.height,map,FloatPixel,pixels,exception);
6850 +        if (status == MagickFalse)
6851 +          PUSHs(&sv_undef);
6852 +        else
6853 +          {
6854 +            EXTEND(sp,strlen(map)*region.width*region.height);
6855 +            for (i=0; i < (ssize_t) (strlen(map)*region.width*region.height); i++)
6856 +              PUSHs(sv_2mortal(newSVnv(pixels[i])));
6857 +          }
6858 +        pixels=(float *) RelinquishMagickMemory(pixels);
6859 +      }
6860 +    else
6861 +      {
6862 +        Quantum
6863 +          *pixels;
6864 +
6865 +        pixels=(Quantum *) AcquireQuantumMemory(strlen(map)*region.width,
6866 +          region.height*sizeof(*pixels));
6867 +        if (pixels == (Quantum *) NULL)
6868 +          {
6869 +            ThrowPerlException(exception,ResourceLimitError,
6870 +              "MemoryAllocationFailed",PackageName);
6871 +            goto PerlException;
6872 +          }
6873 +        status=ExportImagePixels(image,region.x,region.y,region.width,
6874 +          region.height,map,QuantumPixel,pixels,exception);
6875 +        if (status == MagickFalse)
6876 +          PUSHs(&sv_undef);
6877 +        else
6878 +          {
6879 +            EXTEND(sp,strlen(map)*region.width*region.height);
6880 +            for (i=0; i < (ssize_t) (strlen(map)*region.width*region.height); i++)
6881 +              PUSHs(sv_2mortal(newSViv(pixels[i])));
6882 +          }
6883 +        pixels=(Quantum *) RelinquishMagickMemory(pixels);
6884 +      }
6885 +
6886 +  PerlException:
6887 +    InheritPerlException(exception,perl_exception);
6888 +    exception=DestroyExceptionInfo(exception);
6889 +    SvREFCNT_dec(perl_exception);
6890 +  }
6891 +\f
6892 +#
6893 +###############################################################################
6894 +#                                                                             #
6895 +#                                                                             #
6896 +#                                                                             #
6897 +#   I m a g e T o B l o b                                                     #
6898 +#                                                                             #
6899 +#                                                                             #
6900 +#                                                                             #
6901 +###############################################################################
6902 +#
6903 +#
6904 +void
6905 +ImageToBlob(ref,...)
6906 +  Image::Magick ref = NO_INIT
6907 +  ALIAS:
6908 +    ImageToBlob  = 1
6909 +    imagetoblob  = 2
6910 +    toblob       = 3
6911 +    blob         = 4
6912 +  PPCODE:
6913 +  {
6914 +    char
6915 +      filename[MaxTextExtent];
6916 +
6917 +    ExceptionInfo
6918 +      *exception;
6919 +
6920 +    Image
6921 +      *image,
6922 +      *next;
6923 +
6924 +    register ssize_t
6925 +      i;
6926 +
6927 +    struct PackageInfo
6928 +      *info,
6929 +      *package_info;
6930 +
6931 +    size_t
6932 +      length;
6933 +
6934 +    ssize_t
6935 +      scene;
6936 +
6937 +    SV
6938 +      *perl_exception,
6939 +      *reference;
6940 +
6941 +    void
6942 +      *blob;
6943 +
6944 +    PERL_UNUSED_VAR(ref);
6945 +    PERL_UNUSED_VAR(ix);
6946 +    exception=AcquireExceptionInfo();
6947 +    perl_exception=newSVpv("",0);
6948 +    package_info=(struct PackageInfo *) NULL;
6949 +    if (sv_isobject(ST(0)) == 0)
6950 +      {
6951 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
6952 +          PackageName);
6953 +        goto PerlException;
6954 +      }
6955 +    reference=SvRV(ST(0));
6956 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
6957 +    if (image == (Image *) NULL)
6958 +      {
6959 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
6960 +          PackageName);
6961 +        goto PerlException;
6962 +      }
6963 +    package_info=ClonePackageInfo(info,exception);
6964 +    for (i=2; i < items; i+=2)
6965 +      SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),exception);
6966 +    (void) CopyMagickString(filename,package_info->image_info->filename,
6967 +      MaxTextExtent);
6968 +    scene=0;
6969 +    for (next=image; next; next=next->next)
6970 +    {
6971 +      (void) CopyMagickString(next->filename,filename,MaxTextExtent);
6972 +      next->scene=scene++;
6973 +    }
6974 +    SetImageInfo(package_info->image_info,(unsigned int)
6975 +      GetImageListLength(image),&image->exception);
6976 +    EXTEND(sp,(ssize_t) GetImageListLength(image));
6977 +    for ( ; image; image=image->next)
6978 +    {
6979 +      length=0;
6980 +      blob=ImagesToBlob(package_info->image_info,image,&length,exception);
6981 +      if (blob != (char *) NULL)
6982 +        {
6983 +          PUSHs(sv_2mortal(newSVpv((const char *) blob,length)));
6984 +          blob=(unsigned char *) RelinquishMagickMemory(blob);
6985 +        }
6986 +      if (package_info->image_info->adjoin)
6987 +        break;
6988 +    }
6989 +
6990 +  PerlException:
6991 +    if (package_info != (struct PackageInfo *) NULL)
6992 +      DestroyPackageInfo(package_info);
6993 +    InheritPerlException(exception,perl_exception);
6994 +    exception=DestroyExceptionInfo(exception);
6995 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
6996 +  }
6997 +\f
6998 +#
6999 +###############################################################################
7000 +#                                                                             #
7001 +#                                                                             #
7002 +#                                                                             #
7003 +#   L a y e r s                                                               #
7004 +#                                                                             #
7005 +#                                                                             #
7006 +#                                                                             #
7007 +###############################################################################
7008 +#
7009 +#
7010 +void
7011 +Layers(ref,...)
7012 +  Image::Magick ref = NO_INIT
7013 +  ALIAS:
7014 +    Layers                = 1
7015 +    layers           = 2
7016 +    OptimizeImageLayers   = 3
7017 +    optimizelayers        = 4
7018 +    optimizeimagelayers   = 5
7019 +  PPCODE:
7020 +  {
7021 +    AV
7022 +      *av;
7023 +
7024 +    char
7025 +      *attribute;
7026 +
7027 +    CompositeOperator
7028 +      compose;
7029 +
7030 +    ExceptionInfo
7031 +      *exception;
7032 +
7033 +    HV
7034 +      *hv;
7035 +
7036 +    Image
7037 +      *image,
7038 +      *layers;
7039 +
7040 +    ImageLayerMethod
7041 +      method;
7042 +
7043 +    register ssize_t
7044 +      i;
7045 +
7046 +    ssize_t
7047 +      option,
7048 +      sp;
7049 +
7050 +    struct PackageInfo
7051 +      *info;
7052 +
7053 +    SV
7054 +      *av_reference,
7055 +      *perl_exception,
7056 +      *reference,
7057 +      *rv,
7058 +      *sv;
7059 +
7060 +    PERL_UNUSED_VAR(ref);
7061 +    PERL_UNUSED_VAR(ix);
7062 +    exception=AcquireExceptionInfo();
7063 +    perl_exception=newSVpv("",0);
7064 +    sv=NULL;
7065 +    if (sv_isobject(ST(0)) == 0)
7066 +      {
7067 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
7068 +          PackageName);
7069 +        goto PerlException;
7070 +      }
7071 +    reference=SvRV(ST(0));
7072 +    hv=SvSTASH(reference);
7073 +    av=newAV();
7074 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
7075 +    SvREFCNT_dec(av);
7076 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
7077 +    if (image == (Image *) NULL)
7078 +      {
7079 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
7080 +          PackageName);
7081 +        goto PerlException;
7082 +      }
7083 +    compose=image->compose;
7084 +    method=OptimizeLayer;
7085 +    for (i=2; i < items; i+=2)
7086 +    {
7087 +      attribute=(char *) SvPV(ST(i-1),na);
7088 +      switch (*attribute)
7089 +      {
7090 +        case 'C':
7091 +        case 'c':
7092 +        {
7093 +          if (LocaleCompare(attribute,"compose") == 0)
7094 +            {
7095 +              sp=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
7096 +                MagickComposeOptions,MagickFalse,SvPV(ST(i),na));
7097 +              if (sp < 0)
7098 +                {
7099 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
7100 +                    SvPV(ST(i),na));
7101 +                  break;
7102 +                }
7103 +              compose=(CompositeOperator) sp;
7104 +              break;
7105 +            }
7106 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
7107 +            attribute);
7108 +          break;
7109 +        }
7110 +        case 'M':
7111 +        case 'm':
7112 +        {
7113 +          if (LocaleCompare(attribute,"method") == 0)
7114 +            {
7115 +              option=ParseCommandOption(MagickLayerOptions,MagickFalse,
7116 +                SvPV(ST(i),na));
7117 +              if (option < 0)
7118 +                {
7119 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
7120 +                    SvPV(ST(i),na));
7121 +                  break;
7122 +                }
7123 +              method=(ImageLayerMethod) option;
7124 +              break;
7125 +            }
7126 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
7127 +            attribute);
7128 +          break;
7129 +        }
7130 +        default:
7131 +        {
7132 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
7133 +            attribute);
7134 +          break;
7135 +        }
7136 +      }
7137 +    }
7138 +    layers=(Image *) NULL;
7139 +    switch (method)
7140 +    {
7141 +      case CompareAnyLayer:
7142 +      case CompareClearLayer:
7143 +      case CompareOverlayLayer:
7144 +      default:
7145 +      {
7146 +        layers=CompareImageLayers(image,method,exception);
7147 +        break;
7148 +      }
7149 +      case MergeLayer:
7150 +      case FlattenLayer:
7151 +      case MosaicLayer:
7152 +      {
7153 +        layers=MergeImageLayers(image,method,exception);
7154 +        break;
7155 +      }
7156 +      case DisposeLayer:
7157 +      {
7158 +        layers=DisposeImages(image,exception);
7159 +        break;
7160 +      }
7161 +      case OptimizeImageLayer:
7162 +      {
7163 +        layers=OptimizeImageLayers(image,exception);
7164 +        break;
7165 +      }
7166 +      case OptimizePlusLayer:
7167 +      {
7168 +        layers=OptimizePlusImageLayers(image,exception);
7169 +        break;
7170 +      }
7171 +      case OptimizeTransLayer:
7172 +      {
7173 +        OptimizeImageTransparency(image,exception);
7174 +        InheritException(&(image->exception),exception);
7175 +        break;
7176 +      }
7177 +      case RemoveDupsLayer:
7178 +      {
7179 +        RemoveDuplicateLayers(&image,exception);
7180 +        InheritException(&(image->exception),exception);
7181 +        break;
7182 +      }
7183 +      case RemoveZeroLayer:
7184 +      {
7185 +        RemoveZeroDelayLayers(&image,exception);
7186 +        InheritException(&(image->exception),exception);
7187 +        break;
7188 +      }
7189 +      case OptimizeLayer:
7190 +      {
7191 +        QuantizeInfo
7192 +          *quantize_info;
7193 +
7194 +        /*
7195 +          General Purpose, GIF Animation Optimizer.
7196 +        */
7197 +        layers=CoalesceImages(image,exception);
7198 +        if (layers == (Image *) NULL)
7199 +          break;
7200 +        InheritException(&(layers->exception),exception);
7201 +        image=layers;
7202 +        layers=OptimizeImageLayers(image,exception);
7203 +        if (layers == (Image *) NULL)
7204 +          break;
7205 +        InheritException(&(layers->exception),exception);
7206 +        image=DestroyImageList(image);
7207 +        image=layers;
7208 +        layers=(Image *) NULL;
7209 +        OptimizeImageTransparency(image,exception);
7210 +        InheritException(&(image->exception),exception);
7211 +        quantize_info=AcquireQuantizeInfo(info->image_info);
7212 +        (void) RemapImages(quantize_info,image,(Image *) NULL);
7213 +        quantize_info=DestroyQuantizeInfo(quantize_info);
7214 +        break;
7215 +      }
7216 +      case CompositeLayer:
7217 +      {
7218 +        Image
7219 +          *source;
7220 +
7221 +        RectangleInfo
7222 +          geometry;
7223 +
7224 +        /*
7225 +          Split image sequence at the first 'NULL:' image.
7226 +        */
7227 +        source=image;
7228 +        while (source != (Image *) NULL)
7229 +        {
7230 +          source=GetNextImageInList(source);
7231 +          if ((source != (Image *) NULL) &&
7232 +              (LocaleCompare(source->magick,"NULL") == 0))
7233 +            break;
7234 +        }
7235 +        if (source != (Image *) NULL)
7236 +          {
7237 +            if ((GetPreviousImageInList(source) == (Image *) NULL) ||
7238 +                (GetNextImageInList(source) == (Image *) NULL))
7239 +              source=(Image *) NULL;
7240 +            else
7241 +              {
7242 +                /*
7243 +                  Separate the two lists, junk the null: image.
7244 +                */
7245 +                source=SplitImageList(source->previous);
7246 +                DeleteImageFromList(&source);
7247 +              }
7248 +          }
7249 +        if (source == (Image *) NULL)
7250 +          {
7251 +            (void) ThrowMagickException(exception,GetMagickModule(),
7252 +              OptionError,"MissingNullSeparator","layers Composite");
7253 +            break;
7254 +          }
7255 +        /*
7256 +          Adjust offset with gravity and virtual canvas.
7257 +        */
7258 +        SetGeometry(image,&geometry);
7259 +        (void) ParseAbsoluteGeometry(image->geometry,&geometry);
7260 +        geometry.width=source->page.width != 0 ? source->page.width :
7261 +          source->columns;
7262 +        geometry.height=source->page.height != 0 ? source->page.height :
7263 +          source->rows;
7264 +        GravityAdjustGeometry(image->page.width != 0 ? image->page.width :
7265 +          image->columns,image->page.height != 0 ? image->page.height :
7266 +          image->rows,image->gravity,&geometry);
7267 +        CompositeLayers(image,compose,source,geometry.x,geometry.y,exception);
7268 +        source=DestroyImageList(source);
7269 +        InheritException(&(image->exception),exception);
7270 +        break;
7271 +      }
7272 +    }
7273 +    if (layers == (Image *) NULL)
7274 +      image=CloneImage(image,0,0,MagickTrue,exception);
7275 +    else
7276 +      {
7277 +        InheritException(&(layers->exception),exception);
7278 +        image=layers;
7279 +      }
7280 +    if (image == (Image *) NULL)
7281 +      goto PerlException;
7282 +    for ( ; image; image=image->next)
7283 +    {
7284 +      AddImageToRegistry(sv,image);
7285 +      rv=newRV(sv);
7286 +      av_push(av,sv_bless(rv,hv));
7287 +      SvREFCNT_dec(sv);
7288 +    }
7289 +    exception=DestroyExceptionInfo(exception);
7290 +    ST(0)=av_reference;
7291 +    SvREFCNT_dec(perl_exception);
7292 +    XSRETURN(1);
7293 +
7294 +  PerlException:
7295 +    InheritPerlException(exception,perl_exception);
7296 +    exception=DestroyExceptionInfo(exception);
7297 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
7298 +    SvPOK_on(perl_exception);
7299 +    ST(0)=sv_2mortal(perl_exception);
7300 +    XSRETURN(1);
7301 +  }
7302 +\f
7303 +#
7304 +###############################################################################
7305 +#                                                                             #
7306 +#                                                                             #
7307 +#                                                                             #
7308 +#   M a g i c k T o M i m e                                                   #
7309 +#                                                                             #
7310 +#                                                                             #
7311 +#                                                                             #
7312 +###############################################################################
7313 +#
7314 +#
7315 +SV *
7316 +MagickToMime(ref,name)
7317 +  Image::Magick ref = NO_INIT
7318 +  char *name
7319 +  ALIAS:
7320 +    magicktomime = 1
7321 +  CODE:
7322 +  {
7323 +    char
7324 +      *mime;
7325 +
7326 +    PERL_UNUSED_VAR(ref);
7327 +    PERL_UNUSED_VAR(ix);
7328 +    mime=MagickToMime(name);
7329 +    RETVAL=newSVpv(mime,0);
7330 +    mime=(char *) RelinquishMagickMemory(mime);
7331 +  }
7332 +  OUTPUT:
7333 +    RETVAL
7334 +\f
7335 +#
7336 +###############################################################################
7337 +#                                                                             #
7338 +#                                                                             #
7339 +#                                                                             #
7340 +#   M o g r i f y                                                             #
7341 +#                                                                             #
7342 +#                                                                             #
7343 +#                                                                             #
7344 +###############################################################################
7345 +#
7346 +#
7347 +void
7348 +Mogrify(ref,...)
7349 +  Image::Magick ref = NO_INIT
7350 +  ALIAS:
7351 +    Comment            =   1
7352 +    CommentImage       =   2
7353 +    Label              =   3
7354 +    LabelImage         =   4
7355 +    AddNoise           =   5
7356 +    AddNoiseImage      =   6
7357 +    Colorize           =   7
7358 +    ColorizeImage      =   8
7359 +    Border             =   9
7360 +    BorderImage        =  10
7361 +    Blur               =  11
7362 +    BlurImage          =  12
7363 +    Chop               =  13
7364 +    ChopImage          =  14
7365 +    Crop               =  15
7366 +    CropImage          =  16
7367 +    Despeckle          =  17
7368 +    DespeckleImage     =  18
7369 +    Edge               =  19
7370 +    EdgeImage          =  20
7371 +    Emboss             =  21
7372 +    EmbossImage        =  22
7373 +    Enhance            =  23
7374 +    EnhanceImage       =  24
7375 +    Flip               =  25
7376 +    FlipImage          =  26
7377 +    Flop               =  27
7378 +    FlopImage          =  28
7379 +    Frame              =  29
7380 +    FrameImage         =  30
7381 +    Implode            =  31
7382 +    ImplodeImage       =  32
7383 +    Magnify            =  33
7384 +    MagnifyImage       =  34
7385 +    MedianFilter       =  35
7386 +    MedianFilterImage  =  36
7387 +    Minify             =  37
7388 +    MinifyImage        =  38
7389 +    OilPaint           =  39
7390 +    OilPaintImage      =  40
7391 +    ReduceNoise        =  41
7392 +    ReduceNoiseImage   =  42
7393 +    Roll               =  43
7394 +    RollImage          =  44
7395 +    Rotate             =  45
7396 +    RotateImage        =  46
7397 +    Sample             =  47
7398 +    SampleImage        =  48
7399 +    Scale              =  49
7400 +    ScaleImage         =  50
7401 +    Shade              =  51
7402 +    ShadeImage         =  52
7403 +    Sharpen            =  53
7404 +    SharpenImage       =  54
7405 +    Shear              =  55
7406 +    ShearImage         =  56
7407 +    Spread             =  57
7408 +    SpreadImage        =  58
7409 +    Swirl              =  59
7410 +    SwirlImage         =  60
7411 +    Resize             =  61
7412 +    ResizeImage        =  62
7413 +    Zoom               =  63
7414 +    ZoomImage          =  64
7415 +    Annotate           =  65
7416 +    AnnotateImage      =  66
7417 +    ColorFloodfill     =  67
7418 +    ColorFloodfillImage=  68
7419 +    Composite          =  69
7420 +    CompositeImage     =  70
7421 +    Contrast           =  71
7422 +    ContrastImage      =  72
7423 +    CycleColormap      =  73
7424 +    CycleColormapImage =  74
7425 +    Draw               =  75
7426 +    DrawImage          =  76
7427 +    Equalize           =  77
7428 +    EqualizeImage      =  78
7429 +    Gamma              =  79
7430 +    GammaImage         =  80
7431 +    Map                =  81
7432 +    MapImage           =  82
7433 +    MatteFloodfill     =  83
7434 +    MatteFloodfillImage=  84
7435 +    Modulate           =  85
7436 +    ModulateImage      =  86
7437 +    Negate             =  87
7438 +    NegateImage        =  88
7439 +    Normalize          =  89
7440 +    NormalizeImage     =  90
7441 +    NumberColors       =  91
7442 +    NumberColorsImage  =  92
7443 +    Opaque             =  93
7444 +    OpaqueImage        =  94
7445 +    Quantize           =  95
7446 +    QuantizeImage      =  96
7447 +    Raise              =  97
7448 +    RaiseImage         =  98
7449 +    Segment            =  99
7450 +    SegmentImage       = 100
7451 +    Signature          = 101
7452 +    SignatureImage     = 102
7453 +    Solarize           = 103
7454 +    SolarizeImage      = 104
7455 +    Sync               = 105
7456 +    SyncImage          = 106
7457 +    Texture            = 107
7458 +    TextureImage       = 108
7459 +    Evaluate           = 109
7460 +    EvaluateImage      = 110
7461 +    Transparent        = 111
7462 +    TransparentImage   = 112
7463 +    Threshold          = 113
7464 +    ThresholdImage     = 114
7465 +    Charcoal           = 115
7466 +    CharcoalImage      = 116
7467 +    Trim               = 117
7468 +    TrimImage          = 118
7469 +    Wave               = 119
7470 +    WaveImage          = 120
7471 +    Separate           = 121
7472 +    SeparateImage      = 122
7473 +    Stereo             = 125
7474 +    StereoImage        = 126
7475 +    Stegano            = 127
7476 +    SteganoImage       = 128
7477 +    Deconstruct        = 129
7478 +    DeconstructImage   = 130
7479 +    GaussianBlur       = 131
7480 +    GaussianBlurImage  = 132
7481 +    Convolve           = 133
7482 +    ConvolveImage      = 134
7483 +    Profile            = 135
7484 +    ProfileImage       = 136
7485 +    UnsharpMask        = 137
7486 +    UnsharpMaskImage   = 138
7487 +    MotionBlur         = 139
7488 +    MotionBlurImage    = 140
7489 +    OrderedDither      = 141
7490 +    OrderedDitherImage = 142
7491 +    Shave              = 143
7492 +    ShaveImage         = 144
7493 +    Level              = 145
7494 +    LevelImage         = 146
7495 +    Clip               = 147
7496 +    ClipImage          = 148
7497 +    AffineTransform    = 149
7498 +    AffineTransformImage = 150
7499 +    Difference         = 151
7500 +    DifferenceImage    = 152
7501 +    AdaptiveThreshold  = 153
7502 +    AdaptiveThresholdImage = 154
7503 +    Resample           = 155
7504 +    ResampleImage      = 156
7505 +    Describe           = 157
7506 +    DescribeImage      = 158
7507 +    BlackThreshold     = 159
7508 +    BlackThresholdImage= 160
7509 +    WhiteThreshold     = 161
7510 +    WhiteThresholdImage= 162
7511 +    RotationalBlur     = 163
7512 +    RotationalBlurImage= 164
7513 +    Thumbnail          = 165
7514 +    ThumbnailImage     = 166
7515 +    Strip              = 167
7516 +    StripImage         = 168
7517 +    Tint               = 169
7518 +    TintImage          = 170
7519 +    Channel            = 171
7520 +    ChannelImage       = 172
7521 +    Splice             = 173
7522 +    SpliceImage        = 174
7523 +    Posterize          = 175
7524 +    PosterizeImage     = 176
7525 +    Shadow             = 177
7526 +    ShadowImage        = 178
7527 +    Identify           = 179
7528 +    IdentifyImage      = 180
7529 +    SepiaTone          = 181
7530 +    SepiaToneImage     = 182
7531 +    SigmoidalContrast  = 183
7532 +    SigmoidalContrastImage = 184
7533 +    Extent             = 185
7534 +    ExtentImage        = 186
7535 +    Vignette           = 187
7536 +    VignetteImage      = 188
7537 +    ContrastStretch    = 189
7538 +    ContrastStretchImage = 190
7539 +    Sans0              = 191
7540 +    Sans0Image         = 192
7541 +    Sans1              = 193
7542 +    Sans1Image         = 194
7543 +    AdaptiveSharpen    = 195
7544 +    AdaptiveSharpenImage = 196
7545 +    Transpose          = 197
7546 +    TransposeImage     = 198
7547 +    Transverse         = 199
7548 +    TransverseImage    = 200
7549 +    AutoOrient         = 201
7550 +    AutoOrientImage    = 202
7551 +    AdaptiveBlur       = 203
7552 +    AdaptiveBlurImage  = 204
7553 +    Sketch             = 205
7554 +    SketchImage        = 206
7555 +    UniqueColors       = 207
7556 +    UniqueColorsImage  = 208
7557 +    AdaptiveResize     = 209
7558 +    AdaptiveResizeImage= 210
7559 +    ClipMask           = 211
7560 +    ClipMaskImage      = 212
7561 +    LinearStretch      = 213
7562 +    LinearStretchImage = 214
7563 +    RecolorImage       = 215
7564 +    Recolor            = 216
7565 +    Mask               = 217
7566 +    MaskImage          = 218
7567 +    Polaroid           = 219
7568 +    PolaroidImage      = 220
7569 +    FloodfillPaint     = 221
7570 +    FloodfillPaintImage= 222
7571 +    Distort            = 223
7572 +    DistortImage       = 224
7573 +    Clut               = 225
7574 +    ClutImage          = 226
7575 +    LiquidRescale      = 227
7576 +    LiquidRescaleImage = 228
7577 +    Encipher           = 229
7578 +    EncipherImage      = 230
7579 +    Decipher           = 231
7580 +    DecipherImage      = 232
7581 +    Deskew             = 233
7582 +    DeskewImage        = 234
7583 +    Remap              = 235
7584 +    RemapImage         = 236
7585 +    SparseColor        = 237
7586 +    SparseColorImage   = 238
7587 +    Function           = 239
7588 +    FunctionImage      = 240
7589 +    SelectiveBlur      = 241
7590 +    SelectiveBlurImage = 242
7591 +    HaldClut           = 243
7592 +    HaldClutImage      = 244
7593 +    BlueShift          = 245
7594 +    BlueShiftImage     = 246
7595 +    ForwardFourierTransform  = 247
7596 +    ForwardFourierTransformImage = 248
7597 +    InverseFourierTransform = 249
7598 +    InverseFourierTransformImage = 250
7599 +    ColorDecisionList  = 251
7600 +    ColorDecisionListImage = 252
7601 +    AutoGamma          = 253
7602 +    AutoGammaImage     = 254
7603 +    AutoLevel          = 255
7604 +    AutoLevelImage     = 256
7605 +    LevelColors        = 257
7606 +    LevelColorsImage   = 258
7607 +    Clamp              = 259
7608 +    ClampImage         = 260
7609 +    Filter             = 261
7610 +    FilterImage        = 262
7611 +    BrightnessContrast = 263
7612 +    BrightnessContrastImage = 264
7613 +    Morphology         = 265
7614 +    MorphologyImage    = 266
7615 +    ColorMatrix        = 267
7616 +    ColorMatrixImage   = 268
7617 +    Color              = 269
7618 +    ColorImage         = 270
7619 +    Mode               = 271
7620 +    ModeImage          = 272
7621 +    Statistic          = 273
7622 +    StatisticImage     = 274
7623 +    Perceptible        = 275
7624 +    PerceptibleImage   = 276
7625 +    Poly               = 277
7626 +    PolyImage          = 278
7627 +    Grayscale          = 279
7628 +    GrayscaleImage     = 280
7629 +    CannyEdge          = 281
7630 +    CannyEdgeImage     = 282
7631 +    HoughLine          = 283
7632 +    HoughLineImage     = 284
7633 +    MeanShift          = 285
7634 +    MeanShiftImage     = 286
7635 +    Kuwahara           = 287
7636 +    KuwaharaImage      = 288
7637 +    ConnectedComponent = 289
7638 +    ConnectedComponentImage = 290
7639 +    CopyPixels         = 291
7640 +    CopyPixelsImage    = 292
7641 +    WaveletDenoise     = 293
7642 +    WaveletDenoiseImage= 294
7643 +    MogrifyRegion      = 666
7644 +  PPCODE:
7645 +  {
7646 +    AffineMatrix
7647 +      affine,
7648 +      current;
7649 +
7650 +    char
7651 +      attribute_flag[MaxArguments],
7652 +      message[MaxTextExtent];
7653 +
7654 +    ChannelType
7655 +      channel;
7656 +
7657 +    CompositeOperator
7658 +      compose;
7659 +
7660 +    const char
7661 +      *attribute,
7662 +      *value;
7663 +
7664 +    double
7665 +      angle;
7666 +
7667 +    ExceptionInfo
7668 +      *exception;
7669 +
7670 +    GeometryInfo
7671 +      geometry_info;
7672 +
7673 +    Image
7674 +      *image,
7675 +      *next,
7676 +      *region_image;
7677 +
7678 +    MagickBooleanType
7679 +      status;
7680 +
7681 +    MagickStatusType
7682 +      flags;
7683 +
7684 +    PixelPacket
7685 +      fill_color;
7686 +
7687 +    RectangleInfo
7688 +      geometry,
7689 +      region_info;
7690 +
7691 +    register ssize_t
7692 +      i;
7693 +
7694 +    ssize_t
7695 +      base,
7696 +      j,
7697 +      number_images;
7698 +
7699 +    struct Methods
7700 +      *rp;
7701 +
7702 +    struct PackageInfo
7703 +      *info;
7704 +
7705 +    SV
7706 +      *perl_exception,
7707 +      **pv,
7708 +      *reference,
7709 +      **reference_vector;
7710 +
7711 +    struct ArgumentList
7712 +      argument_list[MaxArguments];
7713 +
7714 +    PERL_UNUSED_VAR(ref);
7715 +    PERL_UNUSED_VAR(ix);
7716 +    exception=AcquireExceptionInfo();
7717 +    perl_exception=newSVpv("",0);
7718 +    reference_vector=NULL;
7719 +    region_image=NULL;
7720 +    number_images=0;
7721 +    base=2;
7722 +    if (sv_isobject(ST(0)) == 0)
7723 +      {
7724 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
7725 +          PackageName);
7726 +        goto PerlException;
7727 +      }
7728 +    reference=SvRV(ST(0));
7729 +    region_info.width=0;
7730 +    region_info.height=0;
7731 +    region_info.x=0;
7732 +    region_info.y=0;
7733 +    region_image=(Image *) NULL;
7734 +    image=SetupList(aTHX_ reference,&info,&reference_vector,exception);
7735 +    if (ix && (ix != 666))
7736 +      {
7737 +        /*
7738 +          Called as Method(...)
7739 +        */
7740 +        ix=(ix+1)/2;
7741 +        rp=(&Methods[ix-1]);
7742 +        attribute=rp->name;
7743 +      }
7744 +    else
7745 +      {
7746 +        /*
7747 +          Called as Mogrify("Method",...)
7748 +        */
7749 +        attribute=(char *) SvPV(ST(1),na);
7750 +        if (ix)
7751 +          {
7752 +            flags=ParseGravityGeometry(image,attribute,&region_info,exception);
7753 +            attribute=(char *) SvPV(ST(2),na);
7754 +            base++;
7755 +          }
7756 +        for (rp=Methods; ; rp++)
7757 +        {
7758 +          if (rp >= EndOf(Methods))
7759 +            {
7760 +              ThrowPerlException(exception,OptionError,
7761 +                "UnrecognizedPerlMagickMethod",attribute);
7762 +              goto PerlException;
7763 +            }
7764 +          if (strEQcase(attribute,rp->name))
7765 +            break;
7766 +        }
7767 +        ix=rp-Methods+1;
7768 +        base++;
7769 +      }
7770 +    if (image == (Image *) NULL)
7771 +      {
7772 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",attribute);
7773 +        goto PerlException;
7774 +      }
7775 +    Zero(&argument_list,NumberOf(argument_list),struct ArgumentList);
7776 +    Zero(&attribute_flag,NumberOf(attribute_flag),char);
7777 +    for (i=base; (i < items) || ((i == items) && (base == items)); i+=2)
7778 +    {
7779 +      Arguments
7780 +        *pp,
7781 +        *qq;
7782 +
7783 +      ssize_t
7784 +        ssize_test;
7785 +
7786 +      struct ArgumentList
7787 +        *al;
7788 +
7789 +      SV
7790 +        *sv;
7791 +
7792 +      sv=NULL;
7793 +      ssize_test=0;
7794 +      pp=(Arguments *) NULL;
7795 +      qq=rp->arguments;
7796 +      if (i == items)
7797 +        {
7798 +          pp=rp->arguments,
7799 +          sv=ST(i-1);
7800 +        }
7801 +      else
7802 +        for (sv=ST(i), attribute=(char *) SvPV(ST(i-1),na); ; qq++)
7803 +        {
7804 +          if ((qq >= EndOf(rp->arguments)) || (qq->method == NULL))
7805 +            break;
7806 +          if (strEQcase(attribute,qq->method) > ssize_test)
7807 +            {
7808 +              pp=qq;
7809 +              ssize_test=strEQcase(attribute,qq->method);
7810 +            }
7811 +        }
7812 +      if (pp == (Arguments *) NULL)
7813 +        {
7814 +          ThrowPerlException(exception,OptionError,"UnrecognizedOption",
7815 +            attribute);
7816 +          goto continue_outer_loop;
7817 +        }
7818 +      al=(&argument_list[pp-rp->arguments]);
7819 +      switch (pp->type)
7820 +      {
7821 +        case ArrayReference:
7822 +        {
7823 +          if (SvTYPE(sv) != SVt_RV)
7824 +            {
7825 +              (void) FormatLocaleString(message,MaxTextExtent,
7826 +                "invalid %.60s value",pp->method);
7827 +              ThrowPerlException(exception,OptionError,message,SvPV(sv,na));
7828 +              goto continue_outer_loop;
7829 +            }
7830 +          al->array_reference=SvRV(sv);
7831 +          break;
7832 +        }
7833 +        case RealReference:
7834 +        {
7835 +          al->real_reference=SvNV(sv);
7836 +          break;
7837 +        }
7838 +        case FileReference:
7839 +        {
7840 +          al->file_reference=(FILE *) PerlIO_findFILE(IoIFP(sv_2io(sv)));
7841 +          break;
7842 +        }
7843 +        case ImageReference:
7844 +        {
7845 +          if (!sv_isobject(sv) ||
7846 +              !(al->image_reference=SetupList(aTHX_ SvRV(sv),
7847 +                (struct PackageInfo **) NULL,(SV ***) NULL,exception)))
7848 +            {
7849 +              ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
7850 +                PackageName);
7851 +              goto PerlException;
7852 +            }
7853 +          break;
7854 +        }
7855 +        case IntegerReference:
7856 +        {
7857 +          al->integer_reference=SvIV(sv);
7858 +          break;
7859 +        }
7860 +        case StringReference:
7861 +        {
7862 +          al->string_reference=(char *) SvPV(sv,al->length);
7863 +          if (sv_isobject(sv))
7864 +            al->image_reference=SetupList(aTHX_ SvRV(sv),
7865 +              (struct PackageInfo **) NULL,(SV ***) NULL,exception);
7866 +          break;
7867 +        }
7868 +        default:
7869 +        {
7870 +          /*
7871 +            Is a string; look up name.
7872 +          */
7873 +          if ((al->length > 1) && (*(char *) SvPV(sv,al->length) == '@'))
7874 +            {
7875 +              al->string_reference=(char *) SvPV(sv,al->length);
7876 +              al->integer_reference=(-1);
7877 +              break;
7878 +            }
7879 +          al->integer_reference=ParseCommandOption((CommandOption) pp->type,
7880 +            MagickFalse,SvPV(sv,na));
7881 +          if (pp->type == MagickChannelOptions)
7882 +            al->integer_reference=ParseChannelOption(SvPV(sv,na));
7883 +          if ((al->integer_reference < 0) && ((al->integer_reference=SvIV(sv)) <= 0))
7884 +            {
7885 +              (void) FormatLocaleString(message,MaxTextExtent,
7886 +                "invalid %.60s value",pp->method);
7887 +              ThrowPerlException(exception,OptionError,message,SvPV(sv,na));
7888 +              goto continue_outer_loop;
7889 +            }
7890 +          break;
7891 +        }
7892 +      }
7893 +      attribute_flag[pp-rp->arguments]++;
7894 +      continue_outer_loop: ;
7895 +    }
7896 +    (void) ResetMagickMemory((char *) &fill_color,0,sizeof(fill_color));
7897 +    pv=reference_vector;
7898 +    SetGeometryInfo(&geometry_info);
7899 +    channel=DefaultChannels;
7900 +    for (next=image; next; next=next->next)
7901 +    {
7902 +      image=next;
7903 +      SetGeometry(image,&geometry);
7904 +      if ((region_info.width*region_info.height) != 0)
7905 +        {
7906 +          region_image=image;
7907 +          image=CropImage(image,&region_info,exception);
7908 +        }
7909 +      switch (ix)
7910 +      {
7911 +        default:
7912 +        {
7913 +          (void) FormatLocaleString(message,MaxTextExtent,"%.20g",(double) ix);
7914 +          ThrowPerlException(exception,OptionError,
7915 +            "UnrecognizedPerlMagickMethod",message);
7916 +          goto PerlException;
7917 +        }
7918 +        case 1:  /* Comment */
7919 +        {
7920 +          if (attribute_flag[0] == 0)
7921 +            argument_list[0].string_reference=(char *) NULL;
7922 +          (void) SetImageProperty(image,"comment",InterpretImageProperties(
7923 +            info ? info->image_info : (ImageInfo *) NULL,image,
7924 +            argument_list[0].string_reference));
7925 +          break;
7926 +        }
7927 +        case 2:  /* Label */
7928 +        {
7929 +          if (attribute_flag[0] == 0)
7930 +            argument_list[0].string_reference=(char *) NULL;
7931 +          (void) SetImageProperty(image,"label",InterpretImageProperties(
7932 +            info ? info->image_info : (ImageInfo *) NULL,image,
7933 +            argument_list[0].string_reference));
7934 +          break;
7935 +        }
7936 +        case 3:  /* AddNoise */
7937 +        {
7938 +          if (attribute_flag[0] == 0)
7939 +            argument_list[0].integer_reference=UniformNoise;
7940 +          if (attribute_flag[1] != 0)
7941 +            channel=(ChannelType) argument_list[1].integer_reference;
7942 +          image=AddNoiseImageChannel(image,channel,(NoiseType)
7943 +            argument_list[0].integer_reference,exception);
7944 +          break;
7945 +        }
7946 +        case 4:  /* Colorize */
7947 +        {
7948 +          PixelPacket
7949 +            target;
7950 +
7951 +          (void) GetOneVirtualPixel(image,0,0,&target,exception);
7952 +          if (attribute_flag[0] != 0)
7953 +            (void) QueryColorDatabase(argument_list[0].string_reference,&target,
7954 +              exception);
7955 +          if (attribute_flag[1] == 0)
7956 +            argument_list[1].string_reference="100%";
7957 +          image=ColorizeImage(image,argument_list[1].string_reference,target,
7958 +            exception);
7959 +          break;
7960 +        }
7961 +        case 5:  /* Border */
7962 +        {
7963 +          geometry.width=0;
7964 +          geometry.height=0;
7965 +          if (attribute_flag[0] != 0)
7966 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
7967 +              &geometry,exception);
7968 +          if (attribute_flag[1] != 0)
7969 +            geometry.width=argument_list[1].integer_reference;
7970 +          if (attribute_flag[2] != 0)
7971 +            geometry.height=argument_list[2].integer_reference;
7972 +          if (attribute_flag[3] != 0)
7973 +            QueryColorDatabase(argument_list[3].string_reference,
7974 +              &image->border_color,exception);
7975 +          if (attribute_flag[4] != 0)
7976 +            QueryColorDatabase(argument_list[4].string_reference,
7977 +              &image->border_color,exception);
7978 +          if (attribute_flag[5] != 0)
7979 +            QueryColorDatabase(argument_list[5].string_reference,
7980 +              &image->border_color,exception);
7981 +          if (attribute_flag[6] != 0)
7982 +            image->compose=(CompositeOperator)
7983 +              argument_list[6].integer_reference;
7984 +          image=BorderImage(image,&geometry,exception);
7985 +          break;
7986 +        }
7987 +        case 6:  /* Blur */
7988 +        {
7989 +          if (attribute_flag[0] != 0)
7990 +            {
7991 +              flags=ParseGeometry(argument_list[0].string_reference,
7992 +                &geometry_info);
7993 +              if ((flags & SigmaValue) == 0)
7994 +                geometry_info.sigma=1.0;
7995 +            }
7996 +          if (attribute_flag[1] != 0)
7997 +            geometry_info.rho=argument_list[1].real_reference;
7998 +          if (attribute_flag[2] != 0)
7999 +            geometry_info.sigma=argument_list[2].real_reference;
8000 +          if (attribute_flag[3] != 0)
8001 +            channel=(ChannelType) argument_list[3].integer_reference;
8002 +          image=BlurImageChannel(image,channel,geometry_info.rho,
8003 +            geometry_info.sigma,exception);
8004 +          break;
8005 +        }
8006 +        case 7:  /* Chop */
8007 +        {
8008 +          if (attribute_flag[5] != 0)
8009 +            image->gravity=(GravityType) argument_list[5].integer_reference;
8010 +          if (attribute_flag[0] != 0)
8011 +            flags=ParseGravityGeometry(image,argument_list[0].string_reference,
8012 +              &geometry,exception);
8013 +          if (attribute_flag[1] != 0)
8014 +            geometry.width=argument_list[1].integer_reference;
8015 +          if (attribute_flag[2] != 0)
8016 +            geometry.height=argument_list[2].integer_reference;
8017 +          if (attribute_flag[3] != 0)
8018 +            geometry.x=argument_list[3].integer_reference;
8019 +          if (attribute_flag[4] != 0)
8020 +            geometry.y=argument_list[4].integer_reference;
8021 +          image=ChopImage(image,&geometry,exception);
8022 +          break;
8023 +        }
8024 +        case 8:  /* Crop */
8025 +        {
8026 +          if (attribute_flag[6] != 0)
8027 +            image->gravity=(GravityType) argument_list[6].integer_reference;
8028 +          if (attribute_flag[0] != 0)
8029 +            flags=ParseGravityGeometry(image,argument_list[0].string_reference,
8030 +              &geometry,exception);
8031 +          if (attribute_flag[1] != 0)
8032 +            geometry.width=argument_list[1].integer_reference;
8033 +          if (attribute_flag[2] != 0)
8034 +            geometry.height=argument_list[2].integer_reference;
8035 +          if (attribute_flag[3] != 0)
8036 +            geometry.x=argument_list[3].integer_reference;
8037 +          if (attribute_flag[4] != 0)
8038 +            geometry.y=argument_list[4].integer_reference;
8039 +          if (attribute_flag[5] != 0)
8040 +            image->fuzz=StringToDoubleInterval(
8041 +              argument_list[5].string_reference,(double) QuantumRange+1.0);
8042 +          image=CropImage(image,&geometry,exception);
8043 +          break;
8044 +        }
8045 +        case 9:  /* Despeckle */
8046 +        {
8047 +          image=DespeckleImage(image,exception);
8048 +          break;
8049 +        }
8050 +        case 10:  /* Edge */
8051 +        {
8052 +          if (attribute_flag[0] != 0)
8053 +            geometry_info.rho=argument_list[0].real_reference;
8054 +          image=EdgeImage(image,geometry_info.rho,exception);
8055 +          break;
8056 +        }
8057 +        case 11:  /* Emboss */
8058 +        {
8059 +          if (attribute_flag[0] != 0)
8060 +            {
8061 +              flags=ParseGeometry(argument_list[0].string_reference,
8062 +                &geometry_info);
8063 +              if ((flags & SigmaValue) == 0)
8064 +                geometry_info.sigma=1.0;
8065 +            }
8066 +          if (attribute_flag[1] != 0)
8067 +            geometry_info.rho=argument_list[1].real_reference;
8068 +          if (attribute_flag[2] != 0)
8069 +            geometry_info.sigma=argument_list[2].real_reference;
8070 +          image=EmbossImage(image,geometry_info.rho,geometry_info.sigma,
8071 +            exception);
8072 +          break;
8073 +        }
8074 +        case 12:  /* Enhance */
8075 +        {
8076 +          image=EnhanceImage(image,exception);
8077 +          break;
8078 +        }
8079 +        case 13:  /* Flip */
8080 +        {
8081 +          image=FlipImage(image,exception);
8082 +          break;
8083 +        }
8084 +        case 14:  /* Flop */
8085 +        {
8086 +          image=FlopImage(image,exception);
8087 +          break;
8088 +        }
8089 +        case 15:  /* Frame */
8090 +        {
8091 +          FrameInfo
8092 +            frame_info;
8093 +
8094 +          if (attribute_flag[0] != 0)
8095 +            {
8096 +              flags=ParsePageGeometry(image,argument_list[0].string_reference,
8097 +                &geometry,exception);
8098 +              frame_info.width=geometry.width;
8099 +              frame_info.height=geometry.height;
8100 +              frame_info.outer_bevel=geometry.x;
8101 +              frame_info.inner_bevel=geometry.y;
8102 +            }
8103 +          if (attribute_flag[1] != 0)
8104 +            frame_info.width=argument_list[1].integer_reference;
8105 +          if (attribute_flag[2] != 0)
8106 +            frame_info.height=argument_list[2].integer_reference;
8107 +          if (attribute_flag[3] != 0)
8108 +            frame_info.inner_bevel=argument_list[3].integer_reference;
8109 +          if (attribute_flag[4] != 0)
8110 +            frame_info.outer_bevel=argument_list[4].integer_reference;
8111 +          if (attribute_flag[5] != 0)
8112 +            QueryColorDatabase(argument_list[5].string_reference,&fill_color,
8113 +              exception);
8114 +          if (attribute_flag[6] != 0)
8115 +            QueryColorDatabase(argument_list[6].string_reference,&fill_color,
8116 +              exception);
8117 +          frame_info.x=(ssize_t) frame_info.width;
8118 +          frame_info.y=(ssize_t) frame_info.height;
8119 +          frame_info.width=image->columns+2*frame_info.x;
8120 +          frame_info.height=image->rows+2*frame_info.y;
8121 +          if ((attribute_flag[5] != 0) || (attribute_flag[6] != 0))
8122 +            image->matte_color=fill_color;
8123 +          if (attribute_flag[7] != 0)
8124 +            image->compose=(CompositeOperator)
8125 +              argument_list[7].integer_reference;
8126 +          image=FrameImage(image,&frame_info,exception);
8127 +          break;
8128 +        }
8129 +        case 16:  /* Implode */
8130 +        {
8131 +          if (attribute_flag[0] == 0)
8132 +            argument_list[0].real_reference=0.5;
8133 +          if (attribute_flag[1] != 0)
8134 +            image->interpolate=(InterpolatePixelMethod)
8135 +              argument_list[1].integer_reference;
8136 +          image=ImplodeImage(image,argument_list[0].real_reference,
8137 +            exception);
8138 +          break;
8139 +        }
8140 +        case 17:  /* Magnify */
8141 +        {
8142 +          image=MagnifyImage(image,exception);
8143 +          break;
8144 +        }
8145 +        case 18:  /* MedianFilter */
8146 +        {
8147 +          if (attribute_flag[0] != 0)
8148 +            {
8149 +              flags=ParseGeometry(argument_list[0].string_reference,
8150 +                &geometry_info);
8151 +              if ((flags & SigmaValue) == 0)
8152 +                geometry_info.sigma=1.0;
8153 +            }
8154 +          if (attribute_flag[1] != 0)
8155 +            geometry_info.rho=argument_list[1].real_reference;
8156 +          if (attribute_flag[2] != 0)
8157 +            geometry_info.sigma=argument_list[2].real_reference;
8158 +          if (attribute_flag[3] != 0)
8159 +            channel=(ChannelType) argument_list[3].integer_reference;
8160 +          image=StatisticImageChannel(image,channel,MedianStatistic,
8161 +            (size_t) geometry_info.rho,(size_t) geometry_info.sigma,exception);
8162 +          break;
8163 +        }
8164 +        case 19:  /* Minify */
8165 +        {
8166 +          image=MinifyImage(image,exception);
8167 +          break;
8168 +        }
8169 +        case 20:  /* OilPaint */
8170 +        {
8171 +          if (attribute_flag[0] == 0)
8172 +            argument_list[0].real_reference=0.0;
8173 +          image=OilPaintImage(image,argument_list[0].real_reference,
8174 +            exception);
8175 +          break;
8176 +        }
8177 +        case 21:  /* ReduceNoise */
8178 +        {
8179 +          if (attribute_flag[0] != 0)
8180 +            {
8181 +              flags=ParseGeometry(argument_list[0].string_reference,
8182 +                &geometry_info);
8183 +              if ((flags & SigmaValue) == 0)
8184 +                geometry_info.sigma=1.0;
8185 +            }
8186 +          if (attribute_flag[1] != 0)
8187 +            geometry_info.rho=argument_list[1].real_reference;
8188 +          if (attribute_flag[2] != 0)
8189 +            geometry_info.sigma=argument_list[2].real_reference;
8190 +          if (attribute_flag[3] != 0)
8191 +            channel=(ChannelType) argument_list[3].integer_reference;
8192 +          image=StatisticImageChannel(image,channel,NonpeakStatistic,
8193 +            (size_t) geometry_info.rho,(size_t) geometry_info.sigma,exception);
8194 +          break;
8195 +        }
8196 +        case 22:  /* Roll */
8197 +        {
8198 +          if (attribute_flag[0] != 0)
8199 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
8200 +              &geometry,exception);
8201 +          if (attribute_flag[1] != 0)
8202 +            geometry.x=argument_list[1].integer_reference;
8203 +          if (attribute_flag[2] != 0)
8204 +            geometry.y=argument_list[2].integer_reference;
8205 +          image=RollImage(image,geometry.x,geometry.y,exception);
8206 +          break;
8207 +        }
8208 +        case 23:  /* Rotate */
8209 +        {
8210 +          if (attribute_flag[0] == 0)
8211 +            argument_list[0].real_reference=90.0;
8212 +          if (attribute_flag[1] != 0)
8213 +            QueryColorDatabase(argument_list[1].string_reference,
8214 +              &image->background_color,exception);
8215 +          if (attribute_flag[2] != 0)
8216 +            QueryColorDatabase(argument_list[2].string_reference,
8217 +              &image->background_color,exception);
8218 +          if (attribute_flag[3] != 0)
8219 +            QueryColorDatabase(argument_list[3].string_reference,
8220 +              &image->background_color,exception);
8221 +          image=RotateImage(image,argument_list[0].real_reference,exception);
8222 +          break;
8223 +        }
8224 +        case 24:  /* Sample */
8225 +        {
8226 +          if (attribute_flag[0] != 0)
8227 +            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
8228 +              &geometry,exception);
8229 +          if (attribute_flag[1] != 0)
8230 +            geometry.width=argument_list[1].integer_reference;
8231 +          if (attribute_flag[2] != 0)
8232 +            geometry.height=argument_list[2].integer_reference;
8233 +          image=SampleImage(image,geometry.width,geometry.height,exception);
8234 +          break;
8235 +        }
8236 +        case 25:  /* Scale */
8237 +        {
8238 +          if (attribute_flag[0] != 0)
8239 +            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
8240 +              &geometry,exception);
8241 +          if (attribute_flag[1] != 0)
8242 +            geometry.width=argument_list[1].integer_reference;
8243 +          if (attribute_flag[2] != 0)
8244 +            geometry.height=argument_list[2].integer_reference;
8245 +          image=ScaleImage(image,geometry.width,geometry.height,exception);
8246 +          break;
8247 +        }
8248 +        case 26:  /* Shade */
8249 +        {
8250 +          if (attribute_flag[0] != 0)
8251 +            {
8252 +              flags=ParseGeometry(argument_list[0].string_reference,
8253 +                &geometry_info);
8254 +              if ((flags & SigmaValue) == 0)
8255 +                geometry_info.sigma=0.0;
8256 +            }
8257 +          if (attribute_flag[1] != 0)
8258 +            geometry_info.rho=argument_list[1].real_reference;
8259 +          if (attribute_flag[2] != 0)
8260 +            geometry_info.sigma=argument_list[2].real_reference;
8261 +          image=ShadeImage(image,
8262 +            argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse,
8263 +            geometry_info.rho,geometry_info.sigma,exception);
8264 +          break;
8265 +        }
8266 +        case 27:  /* Sharpen */
8267 +        {
8268 +          if (attribute_flag[0] != 0)
8269 +            {
8270 +              flags=ParseGeometry(argument_list[0].string_reference,
8271 +                &geometry_info);
8272 +              if ((flags & SigmaValue) == 0)
8273 +                geometry_info.sigma=1.0;
8274 +            }
8275 +          if (attribute_flag[1] != 0)
8276 +            geometry_info.rho=argument_list[1].real_reference;
8277 +          if (attribute_flag[2] != 0)
8278 +            geometry_info.sigma=argument_list[2].real_reference;
8279 +          if (attribute_flag[3] != 0)
8280 +            channel=(ChannelType) argument_list[3].integer_reference;
8281 +          image=SharpenImageChannel(image,channel,geometry_info.rho,
8282 +            geometry_info.sigma,exception);
8283 +          break;
8284 +        }
8285 +        case 28:  /* Shear */
8286 +        {
8287 +          if (attribute_flag[0] != 0)
8288 +            {
8289 +              flags=ParseGeometry(argument_list[0].string_reference,
8290 +                &geometry_info);
8291 +              if ((flags & SigmaValue) == 0)
8292 +                geometry_info.sigma=geometry_info.rho;
8293 +            }
8294 +          if (attribute_flag[1] != 0)
8295 +            geometry_info.rho=argument_list[1].real_reference;
8296 +          if (attribute_flag[2] != 0)
8297 +            geometry_info.sigma=argument_list[2].real_reference;
8298 +          if (attribute_flag[3] != 0)
8299 +            QueryColorDatabase(argument_list[3].string_reference,
8300 +              &image->background_color,exception);
8301 +          if (attribute_flag[4] != 0)
8302 +            QueryColorDatabase(argument_list[4].string_reference,
8303 +              &image->background_color,exception);
8304 +          image=ShearImage(image,geometry_info.rho,geometry_info.sigma,
8305 +            exception);
8306 +          break;
8307 +        }
8308 +        case 29:  /* Spread */
8309 +        {
8310 +          if (attribute_flag[0] == 0)
8311 +            argument_list[0].real_reference=1.0;
8312 +          image=SpreadImage(image,argument_list[0].real_reference,exception);
8313 +          break;
8314 +        }
8315 +        case 30:  /* Swirl */
8316 +        {
8317 +          if (attribute_flag[0] == 0)
8318 +            argument_list[0].real_reference=50.0;
8319 +          if (attribute_flag[1] != 0)
8320 +            image->interpolate=(InterpolatePixelMethod)
8321 +              argument_list[1].integer_reference;
8322 +          image=SwirlImage(image,argument_list[0].real_reference,exception);
8323 +          break;
8324 +        }
8325 +        case 31:  /* Resize */
8326 +        case 32:  /* Zoom */
8327 +        {
8328 +          if (attribute_flag[0] != 0)
8329 +            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
8330 +              &geometry,exception);
8331 +          if (attribute_flag[1] != 0)
8332 +            geometry.width=argument_list[1].integer_reference;
8333 +          if (attribute_flag[2] != 0)
8334 +            geometry.height=argument_list[2].integer_reference;
8335 +          if (attribute_flag[3] == 0)
8336 +            argument_list[3].integer_reference=(ssize_t) UndefinedFilter;
8337 +          if (attribute_flag[4] != 0)
8338 +            SetImageArtifact(image,"filter:support",
8339 +              argument_list[4].string_reference);
8340 +          if (attribute_flag[5] == 0)
8341 +            argument_list[5].real_reference=1.0;
8342 +          image=ResizeImage(image,geometry.width,geometry.height,
8343 +            (FilterTypes) argument_list[3].integer_reference,
8344 +            argument_list[5].real_reference,exception);
8345 +          break;
8346 +        }
8347 +        case 33:  /* Annotate */
8348 +        {
8349 +          DrawInfo
8350 +            *draw_info;
8351 +
8352 +          draw_info=CloneDrawInfo(info ? info->image_info : (ImageInfo *) NULL,
8353 +            (DrawInfo *) NULL);
8354 +          if (attribute_flag[0] != 0)
8355 +            {
8356 +              char
8357 +                *text;
8358 +
8359 +              text=InterpretImageProperties(info ? info->image_info :
8360 +                (ImageInfo *) NULL,image,argument_list[0].string_reference);
8361 +              (void) CloneString(&draw_info->text,text);
8362 +              text=DestroyString(text);
8363 +            }
8364 +          if (attribute_flag[1] != 0)
8365 +            (void) CloneString(&draw_info->font,
8366 +              argument_list[1].string_reference);
8367 +          if (attribute_flag[2] != 0)
8368 +            draw_info->pointsize=argument_list[2].real_reference;
8369 +          if (attribute_flag[3] != 0)
8370 +            (void) CloneString(&draw_info->density,
8371 +              argument_list[3].string_reference);
8372 +          if (attribute_flag[4] != 0)
8373 +            (void) QueryColorDatabase(argument_list[4].string_reference,
8374 +              &draw_info->undercolor,exception);
8375 +          if (attribute_flag[5] != 0)
8376 +            {
8377 +              (void) QueryColorDatabase(argument_list[5].string_reference,
8378 +                &draw_info->stroke,exception);
8379 +              if (argument_list[5].image_reference != (Image *) NULL)
8380 +                draw_info->stroke_pattern=CloneImage(
8381 +                  argument_list[5].image_reference,0,0,MagickTrue,exception);
8382 +            }
8383 +          if (attribute_flag[6] != 0)
8384 +            {
8385 +              (void) QueryColorDatabase(argument_list[6].string_reference,
8386 +                &draw_info->fill,exception);
8387 +              if (argument_list[6].image_reference != (Image *) NULL)
8388 +                draw_info->fill_pattern=CloneImage(
8389 +                  argument_list[6].image_reference,0,0,MagickTrue,exception);
8390 +            }
8391 +          if (attribute_flag[7] != 0)
8392 +            {
8393 +              (void) CloneString(&draw_info->geometry,
8394 +                argument_list[7].string_reference);
8395 +              flags=ParsePageGeometry(image,argument_list[7].string_reference,
8396 +                &geometry,exception);
8397 +              if (((flags & SigmaValue) == 0) && ((flags & XiValue) != 0))
8398 +                geometry_info.sigma=geometry_info.xi;
8399 +            }
8400 +          if (attribute_flag[8] != 0)
8401 +            (void) QueryColorDatabase(argument_list[8].string_reference,
8402 +              &draw_info->fill,exception);
8403 +          if (attribute_flag[11] != 0)
8404 +            draw_info->gravity=(GravityType) argument_list[11].integer_reference;
8405 +          if (attribute_flag[25] != 0)
8406 +            {
8407 +              AV
8408 +                *av;
8409 +
8410 +              av=(AV *) argument_list[25].array_reference;
8411 +              if ((av_len(av) != 3) && (av_len(av) != 5))
8412 +                {
8413 +                  ThrowPerlException(exception,OptionError,
8414 +                    "affine matrix must have 4 or 6 elements",PackageName);
8415 +                  goto PerlException;
8416 +                }
8417 +              draw_info->affine.sx=(double) SvNV(*(av_fetch(av,0,0)));
8418 +              draw_info->affine.rx=(double) SvNV(*(av_fetch(av,1,0)));
8419 +              draw_info->affine.ry=(double) SvNV(*(av_fetch(av,2,0)));
8420 +              draw_info->affine.sy=(double) SvNV(*(av_fetch(av,3,0)));
8421 +              if (fabs(draw_info->affine.sx*draw_info->affine.sy-
8422 +                  draw_info->affine.rx*draw_info->affine.ry) < MagickEpsilon)
8423 +                {
8424 +                  ThrowPerlException(exception,OptionError,
8425 +                    "affine matrix is singular",PackageName);
8426 +                   goto PerlException;
8427 +                }
8428 +              if (av_len(av) == 5)
8429 +                {
8430 +                  draw_info->affine.tx=(double) SvNV(*(av_fetch(av,4,0)));
8431 +                  draw_info->affine.ty=(double) SvNV(*(av_fetch(av,5,0)));
8432 +                }
8433 +            }
8434 +          for (j=12; j < 17; j++)
8435 +          {
8436 +            if (attribute_flag[j] == 0)
8437 +              continue;
8438 +            value=argument_list[j].string_reference;
8439 +            angle=argument_list[j].real_reference;
8440 +            current=draw_info->affine;
8441 +            GetAffineMatrix(&affine);
8442 +            switch (j)
8443 +            {
8444 +              case 12:
8445 +              {
8446 +                /*
8447 +                  Translate.
8448 +                */
8449 +                flags=ParseGeometry(value,&geometry_info);
8450 +                affine.tx=geometry_info.xi;
8451 +                affine.ty=geometry_info.psi;
8452 +                if ((flags & PsiValue) == 0)
8453 +                  affine.ty=affine.tx;
8454 +                break;
8455 +              }
8456 +              case 13:
8457 +              {
8458 +                /*
8459 +                  Scale.
8460 +                */
8461 +                flags=ParseGeometry(value,&geometry_info);
8462 +                affine.sx=geometry_info.rho;
8463 +                affine.sy=geometry_info.sigma;
8464 +                if ((flags & SigmaValue) == 0)
8465 +                  affine.sy=affine.sx;
8466 +                break;
8467 +              }
8468 +              case 14:
8469 +              {
8470 +                /*
8471 +                  Rotate.
8472 +                */
8473 +                if (angle == 0.0)
8474 +                  break;
8475 +                affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));
8476 +                affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));
8477 +                affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));
8478 +                affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));
8479 +                break;
8480 +              }
8481 +              case 15:
8482 +              {
8483 +                /*
8484 +                  SkewX.
8485 +                */
8486 +                affine.ry=tan(DegreesToRadians(fmod(angle,360.0)));
8487 +                break;
8488 +              }
8489 +              case 16:
8490 +              {
8491 +                /*
8492 +                  SkewY.
8493 +                */
8494 +                affine.rx=tan(DegreesToRadians(fmod(angle,360.0)));
8495 +                break;
8496 +              }
8497 +            }
8498 +            draw_info->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
8499 +            draw_info->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
8500 +            draw_info->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
8501 +            draw_info->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
8502 +            draw_info->affine.tx=current.sx*affine.tx+current.ry*affine.ty+
8503 +              current.tx;
8504 +            draw_info->affine.ty=current.rx*affine.tx+current.sy*affine.ty+
8505 +              current.ty;
8506 +          }
8507 +          if (attribute_flag[9] == 0)
8508 +            argument_list[9].real_reference=0.0;
8509 +          if (attribute_flag[10] == 0)
8510 +            argument_list[10].real_reference=0.0;
8511 +          if ((attribute_flag[9] != 0) || (attribute_flag[10] != 0))
8512 +            {
8513 +              char
8514 +                geometry[MaxTextExtent];
8515 +
8516 +              (void) FormatLocaleString(geometry,MaxTextExtent,"%+f%+f",
8517 +                (double) argument_list[9].real_reference+draw_info->affine.tx,
8518 +                (double) argument_list[10].real_reference+draw_info->affine.ty);
8519 +              (void) CloneString(&draw_info->geometry,geometry);
8520 +            }
8521 +          if (attribute_flag[17] != 0)
8522 +            draw_info->stroke_width=argument_list[17].real_reference;
8523 +          if (attribute_flag[18] != 0)
8524 +            {
8525 +              draw_info->text_antialias=argument_list[18].integer_reference != 0 ?
8526 +                MagickTrue : MagickFalse;
8527 +              draw_info->stroke_antialias=draw_info->text_antialias;
8528 +            }
8529 +          if (attribute_flag[19] != 0)
8530 +            (void) CloneString(&draw_info->family,
8531 +              argument_list[19].string_reference);
8532 +          if (attribute_flag[20] != 0)
8533 +            draw_info->style=(StyleType) argument_list[20].integer_reference;
8534 +          if (attribute_flag[21] != 0)
8535 +            draw_info->stretch=(StretchType) argument_list[21].integer_reference;
8536 +          if (attribute_flag[22] != 0)
8537 +            draw_info->weight=argument_list[22].integer_reference;
8538 +          if (attribute_flag[23] != 0)
8539 +            draw_info->align=(AlignType) argument_list[23].integer_reference;
8540 +          if (attribute_flag[24] != 0)
8541 +            (void) CloneString(&draw_info->encoding,
8542 +              argument_list[24].string_reference);
8543 +          if (attribute_flag[25] != 0)
8544 +            draw_info->fill_pattern=CloneImage(
8545 +              argument_list[25].image_reference,0,0,MagickTrue,exception);
8546 +          if (attribute_flag[26] != 0)
8547 +            draw_info->fill_pattern=CloneImage(
8548 +              argument_list[26].image_reference,0,0,MagickTrue,exception);
8549 +          if (attribute_flag[27] != 0)
8550 +            draw_info->stroke_pattern=CloneImage(
8551 +              argument_list[27].image_reference,0,0,MagickTrue,exception);
8552 +          if (attribute_flag[29] != 0)
8553 +            draw_info->kerning=argument_list[29].real_reference;
8554 +          if (attribute_flag[30] != 0)
8555 +            draw_info->interline_spacing=argument_list[30].real_reference;
8556 +          if (attribute_flag[31] != 0)
8557 +            draw_info->interword_spacing=argument_list[31].real_reference;
8558 +          if (attribute_flag[32] != 0)
8559 +            draw_info->direction=(DirectionType)
8560 +              argument_list[32].integer_reference;
8561 +          (void) AnnotateImage(image,draw_info);
8562 +          draw_info=DestroyDrawInfo(draw_info);
8563 +          break;
8564 +        }
8565 +        case 34:  /* ColorFloodfill */
8566 +        {
8567 +          DrawInfo
8568 +            *draw_info;
8569 +
8570 +          MagickBooleanType
8571 +            invert;
8572 +
8573 +          MagickPixelPacket
8574 +            target;
8575 +
8576 +          draw_info=CloneDrawInfo(info ? info->image_info :
8577 +            (ImageInfo *) NULL,(DrawInfo *) NULL);
8578 +          if (attribute_flag[0] != 0)
8579 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
8580 +              &geometry,exception);
8581 +          if (attribute_flag[1] != 0)
8582 +            geometry.x=argument_list[1].integer_reference;
8583 +          if (attribute_flag[2] != 0)
8584 +            geometry.y=argument_list[2].integer_reference;
8585 +          if (attribute_flag[3] != 0)
8586 +            (void) QueryColorDatabase(argument_list[3].string_reference,
8587 +              &draw_info->fill,exception);
8588 +          (void) GetOneVirtualMagickPixel(image,geometry.x,geometry.y,&target,
8589 +            exception);
8590 +          invert=MagickFalse;
8591 +          if (attribute_flag[4] != 0)
8592 +            {
8593 +              QueryMagickColor(argument_list[4].string_reference,&target,
8594 +                exception);
8595 +              invert=MagickTrue;
8596 +            }
8597 +          if (attribute_flag[5] != 0)
8598 +            image->fuzz=StringToDoubleInterval(
8599 +              argument_list[5].string_reference,(double) QuantumRange+1.0);
8600 +          if (attribute_flag[6] != 0)
8601 +            invert=(MagickBooleanType) argument_list[6].integer_reference;
8602 +          (void) FloodfillPaintImage(image,DefaultChannels,draw_info,&target,
8603 +            geometry.x,geometry.y,invert);
8604 +          draw_info=DestroyDrawInfo(draw_info);
8605 +          break;
8606 +        }
8607 +        case 35:  /* Composite */
8608 +        {
8609 +          char
8610 +            composite_geometry[MaxTextExtent];
8611 +
8612 +          Image
8613 +            *composite_image,
8614 +            *rotate_image;
8615 +
8616 +          compose=OverCompositeOp;
8617 +          if (attribute_flag[0] != 0)
8618 +            composite_image=argument_list[0].image_reference;
8619 +          else
8620 +            {
8621 +              ThrowPerlException(exception,OptionError,
8622 +                "CompositeImageRequired",PackageName);
8623 +              goto PerlException;
8624 +            }
8625 +          /*
8626 +            Parameter Handling used for BOTH normal and tiled composition.
8627 +          */
8628 +          if (attribute_flag[1] != 0) /* compose */
8629 +            compose=(CompositeOperator) argument_list[1].integer_reference;
8630 +          if (attribute_flag[6] != 0) /* opacity  */
8631 +            {
8632 +              if (compose != DissolveCompositeOp)
8633 +                (void) SetImageOpacity(composite_image,(Quantum) (QuantumRange-
8634 +                  StringToDoubleInterval(argument_list[6].string_reference,
8635 +                  (double) QuantumRange+1.0)));
8636 +              else
8637 +                {
8638 +                  CacheView
8639 +                    *composite_view;
8640 +
8641 +                  double
8642 +                    opacity;
8643 +
8644 +                  MagickBooleanType
8645 +                    sync;
8646 +
8647 +                  register ssize_t
8648 +                    x;
8649 +
8650 +                  register PixelPacket
8651 +                    *q;
8652 +
8653 +                  ssize_t
8654 +                    y;
8655 +
8656 +                  /*
8657 +                    Handle dissolve composite operator.
8658 +                  */
8659 +                  (void) CloneString(&image->geometry,
8660 +                    argument_list[6].string_reference);
8661 +                  opacity=(Quantum) (QuantumRange-StringToDoubleInterval(
8662 +                    argument_list[6].string_reference,(double) QuantumRange+
8663 +                    1.0));
8664 +                  if (composite_image->matte != MagickTrue)
8665 +                    (void) SetImageOpacity(composite_image,OpaqueOpacity);
8666 +                  composite_view=AcquireAuthenticCacheView(composite_image,
8667 +                    exception);
8668 +                  for (y=0; y < (ssize_t) composite_image->rows ; y++)
8669 +                  {
8670 +                    q=GetCacheViewAuthenticPixels(composite_view,0,y,(ssize_t)
8671 +                      composite_image->columns,1,exception);
8672 +                    for (x=0; x < (ssize_t) composite_image->columns; x++)
8673 +                    {
8674 +                      if (q->opacity == OpaqueOpacity)
8675 +                        q->opacity=ClampToQuantum(opacity);
8676 +                      q++;
8677 +                    }
8678 +                    sync=SyncCacheViewAuthenticPixels(composite_view,exception);
8679 +                    if (sync == MagickFalse)
8680 +                      break;
8681 +                  }
8682 +                  composite_view=DestroyCacheView(composite_view);
8683 +                }
8684 +            }
8685 +          if (attribute_flag[9] != 0)    /* "color=>" */
8686 +            QueryColorDatabase(argument_list[9].string_reference,
8687 +              &composite_image->background_color,exception);
8688 +          if (attribute_flag[12] != 0) /* "interpolate=>" */
8689 +            image->interpolate=(InterpolatePixelMethod)
8690 +              argument_list[12].integer_reference;
8691 +          if (attribute_flag[13] != 0)   /* "args=>" */
8692 +            (void) SetImageArtifact(composite_image,"compose:args",
8693 +              argument_list[13].string_reference);
8694 +          if (attribute_flag[14] != 0)   /* "blend=>"  depreciated */
8695 +            (void) SetImageArtifact(composite_image,"compose:args",
8696 +              argument_list[14].string_reference);
8697 +          /*
8698 +            Tiling Composition (with orthogonal rotate).
8699 +          */
8700 +          rotate_image=(Image *) NULL;
8701 +          if (attribute_flag[8] != 0)   /* "rotate=>" */
8702 +            {
8703 +               /*
8704 +                 Rotate image.
8705 +               */
8706 +               rotate_image=RotateImage(composite_image,
8707 +                 argument_list[8].real_reference,exception);
8708 +               if (rotate_image == (Image *) NULL)
8709 +                 break;
8710 +            }
8711 +          if ((attribute_flag[7] != 0) &&
8712 +              (argument_list[7].integer_reference != 0)) /* tile */
8713 +            {
8714 +              ssize_t
8715 +                x,
8716 +                y;
8717 +
8718 +              /*
8719 +                Tile the composite image.
8720 +              */
8721 +             if (attribute_flag[8] != 0)   /* "tile=>" */
8722 +               (void) SetImageArtifact(rotate_image,"compose:outside-overlay",
8723 +                 "false");
8724 +             else
8725 +               (void) SetImageArtifact(composite_image,
8726 +                 "compose:outside-overlay","false");
8727 +             for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) composite_image->rows)
8728 +                for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) composite_image->columns)
8729 +                {
8730 +                  if (attribute_flag[8] != 0) /* rotate */
8731 +                    (void) CompositeImage(image,compose,rotate_image,x,y);
8732 +                  else
8733 +                    (void) CompositeImage(image,compose,composite_image,x,y);
8734 +                }
8735 +              if (attribute_flag[8] != 0) /* rotate */
8736 +                rotate_image=DestroyImage(rotate_image);
8737 +              break;
8738 +            }
8739 +          /*
8740 +            Parameter Handling used used ONLY for normal composition.
8741 +          */
8742 +          if (attribute_flag[5] != 0) /* gravity */
8743 +            image->gravity=(GravityType) argument_list[5].integer_reference;
8744 +          if (attribute_flag[2] != 0) /* geometry offset */
8745 +            {
8746 +              SetGeometry(image,&geometry);
8747 +              (void) ParseAbsoluteGeometry(argument_list[2].string_reference,
8748 +                &geometry);
8749 +              GravityAdjustGeometry(image->columns,image->rows,image->gravity,
8750 +                &geometry);
8751 +            }
8752 +          if (attribute_flag[3] != 0) /* x offset */
8753 +            geometry.x=argument_list[3].integer_reference;
8754 +          if (attribute_flag[4] != 0) /* y offset */
8755 +            geometry.y=argument_list[4].integer_reference;
8756 +          if (attribute_flag[10] != 0) /* mask */
8757 +            {
8758 +              if ((image->compose == DisplaceCompositeOp) ||
8759 +                  (image->compose == DistortCompositeOp))
8760 +                {
8761 +                  /*
8762 +                    Merge Y displacement into X displacement image.
8763 +                  */
8764 +                  composite_image=CloneImage(composite_image,0,0,MagickTrue,
8765 +                    &image->exception);
8766 +                  (void) CompositeImage(composite_image,CopyGreenCompositeOp,
8767 +                    argument_list[10].image_reference,0,0);
8768 +                }
8769 +              else
8770 +                {
8771 +                  /*
8772 +                    Set a blending mask for the composition.
8773 +                  */
8774 +                  image->mask=CloneImage(argument_list[10].image_reference,0,0,
8775 +                    MagickTrue,&image->exception);
8776 +                  (void) NegateImage(image->mask,MagickFalse);
8777 +                }
8778 +            }
8779 +          if (attribute_flag[11] != 0) /* channel */
8780 +            channel=(ChannelType) argument_list[11].integer_reference;
8781 +          /*
8782 +            Composite two images (normal composition).
8783 +          */
8784 +          (void) FormatLocaleString(composite_geometry,MaxTextExtent,
8785 +            "%.20gx%.20g%+.20g%+.20g",(double) composite_image->columns,
8786 +            (double) composite_image->rows,(double) geometry.x,(double)
8787 +            geometry.y);
8788 +          flags=ParseGravityGeometry(image,composite_geometry,&geometry,
8789 +            exception);
8790 +          if (attribute_flag[8] == 0) /* no rotate */
8791 +            CompositeImageChannel(image,channel,compose,composite_image,
8792 +              geometry.x,geometry.y);
8793 +          else
8794 +            {
8795 +              /*
8796 +                Position adjust rotated image then composite.
8797 +              */
8798 +              geometry.x-=(ssize_t) (rotate_image->columns-
8799 +                composite_image->columns)/2;
8800 +              geometry.y-=(ssize_t) (rotate_image->rows-
8801 +                composite_image->rows)/2;
8802 +              CompositeImageChannel(image,channel,compose,rotate_image,
8803 +                geometry.x,geometry.y);
8804 +              rotate_image=DestroyImage(rotate_image);
8805 +            }
8806 +          if (attribute_flag[10] != 0) /* mask */
8807 +            {
8808 +              if ((image->compose == DisplaceCompositeOp) ||
8809 +                  (image->compose == DistortCompositeOp))
8810 +                composite_image=DestroyImage(composite_image);
8811 +              else
8812 +                image->mask=DestroyImage(image->mask);
8813 +            }
8814 +          break;
8815 +        }
8816 +        case 36:  /* Contrast */
8817 +        {
8818 +          if (attribute_flag[0] == 0)
8819 +            argument_list[0].integer_reference=0;
8820 +          (void) ContrastImage(image,argument_list[0].integer_reference != 0 ?
8821 +            MagickTrue : MagickFalse);
8822 +          break;
8823 +        }
8824 +        case 37:  /* CycleColormap */
8825 +        {
8826 +          if (attribute_flag[0] == 0)
8827 +            argument_list[0].integer_reference=6;
8828 +          (void) CycleColormapImage(image,argument_list[0].integer_reference);
8829 +          break;
8830 +        }
8831 +        case 38:  /* Draw */
8832 +        {
8833 +          DrawInfo
8834 +            *draw_info;
8835 +
8836 +          draw_info=CloneDrawInfo(info ? info->image_info : (ImageInfo *) NULL,
8837 +            (DrawInfo *) NULL);
8838 +          (void) CloneString(&draw_info->primitive,"point");
8839 +          if (attribute_flag[0] != 0)
8840 +            {
8841 +              if (argument_list[0].integer_reference < 0)
8842 +                (void) CloneString(&draw_info->primitive,
8843 +                  argument_list[0].string_reference);
8844 +              else
8845 +                (void) CloneString(&draw_info->primitive,CommandOptionToMnemonic(
8846 +                  MagickPrimitiveOptions,argument_list[0].integer_reference));
8847 +            }
8848 +          if (attribute_flag[1] != 0)
8849 +            {
8850 +              if (LocaleCompare(draw_info->primitive,"path") == 0)
8851 +                {
8852 +                  (void) ConcatenateString(&draw_info->primitive," '");
8853 +                  ConcatenateString(&draw_info->primitive,
8854 +                    argument_list[1].string_reference);
8855 +                  (void) ConcatenateString(&draw_info->primitive,"'");
8856 +                }
8857 +              else
8858 +                {
8859 +                  (void) ConcatenateString(&draw_info->primitive," ");
8860 +                  ConcatenateString(&draw_info->primitive,
8861 +                    argument_list[1].string_reference);
8862 +                }
8863 +            }
8864 +          if (attribute_flag[2] != 0)
8865 +            {
8866 +              (void) ConcatenateString(&draw_info->primitive," ");
8867 +              (void) ConcatenateString(&draw_info->primitive,
8868 +                CommandOptionToMnemonic(MagickMethodOptions,
8869 +                argument_list[2].integer_reference));
8870 +            }
8871 +          if (attribute_flag[3] != 0)
8872 +            {
8873 +              (void) QueryColorDatabase(argument_list[3].string_reference,
8874 +                &draw_info->stroke,exception);
8875 +              if (argument_list[3].image_reference != (Image *) NULL)
8876 +                draw_info->stroke_pattern=CloneImage(
8877 +                  argument_list[3].image_reference,0,0,MagickTrue,exception);
8878 +            }
8879 +          if (attribute_flag[4] != 0)
8880 +            {
8881 +              (void) QueryColorDatabase(argument_list[4].string_reference,
8882 +                &draw_info->fill,exception);
8883 +              if (argument_list[4].image_reference != (Image *) NULL)
8884 +                draw_info->fill_pattern=CloneImage(
8885 +                  argument_list[4].image_reference,0,0,MagickTrue,exception);
8886 +            }
8887 +          if (attribute_flag[5] != 0)
8888 +            draw_info->stroke_width=argument_list[5].real_reference;
8889 +          if (attribute_flag[6] != 0)
8890 +            (void) CloneString(&draw_info->font,
8891 +              argument_list[6].string_reference);
8892 +          if (attribute_flag[7] != 0)
8893 +            (void) QueryColorDatabase(argument_list[7].string_reference,
8894 +              &draw_info->border_color,exception);
8895 +          if (attribute_flag[8] != 0)
8896 +            draw_info->affine.tx=argument_list[8].real_reference;
8897 +          if (attribute_flag[9] != 0)
8898 +            draw_info->affine.ty=argument_list[9].real_reference;
8899 +          if (attribute_flag[20] != 0)
8900 +            {
8901 +              AV
8902 +                *av;
8903 +
8904 +              av=(AV *) argument_list[20].array_reference;
8905 +              if ((av_len(av) != 3) && (av_len(av) != 5))
8906 +                {
8907 +                  ThrowPerlException(exception,OptionError,
8908 +                    "affine matrix must have 4 or 6 elements",PackageName);
8909 +                  goto PerlException;
8910 +                }
8911 +              draw_info->affine.sx=(double) SvNV(*(av_fetch(av,0,0)));
8912 +              draw_info->affine.rx=(double) SvNV(*(av_fetch(av,1,0)));
8913 +              draw_info->affine.ry=(double) SvNV(*(av_fetch(av,2,0)));
8914 +              draw_info->affine.sy=(double) SvNV(*(av_fetch(av,3,0)));
8915 +              if (fabs(draw_info->affine.sx*draw_info->affine.sy-
8916 +                  draw_info->affine.rx*draw_info->affine.ry) < MagickEpsilon)
8917 +                {
8918 +                  ThrowPerlException(exception,OptionError,
8919 +                    "affine matrix is singular",PackageName);
8920 +                   goto PerlException;
8921 +                }
8922 +              if (av_len(av) == 5)
8923 +                {
8924 +                  draw_info->affine.tx=(double) SvNV(*(av_fetch(av,4,0)));
8925 +                  draw_info->affine.ty=(double) SvNV(*(av_fetch(av,5,0)));
8926 +                }
8927 +            }
8928 +          for (j=10; j < 15; j++)
8929 +          {
8930 +            if (attribute_flag[j] == 0)
8931 +              continue;
8932 +            value=argument_list[j].string_reference;
8933 +            angle=argument_list[j].real_reference;
8934 +            current=draw_info->affine;
8935 +            GetAffineMatrix(&affine);
8936 +            switch (j)
8937 +            {
8938 +              case 10:
8939 +              {
8940 +                /*
8941 +                  Translate.
8942 +                */
8943 +                flags=ParseGeometry(value,&geometry_info);
8944 +                affine.tx=geometry_info.xi;
8945 +                affine.ty=geometry_info.psi;
8946 +                if ((flags & PsiValue) == 0)
8947 +                  affine.ty=affine.tx;
8948 +                break;
8949 +              }
8950 +              case 11:
8951 +              {
8952 +                /*
8953 +                  Scale.
8954 +                */
8955 +                flags=ParseGeometry(value,&geometry_info);
8956 +                affine.sx=geometry_info.rho;
8957 +                affine.sy=geometry_info.sigma;
8958 +                if ((flags & SigmaValue) == 0)
8959 +                  affine.sy=affine.sx;
8960 +                break;
8961 +              }
8962 +              case 12:
8963 +              {
8964 +                /*
8965 +                  Rotate.
8966 +                */
8967 +                if (angle == 0.0)
8968 +                  break;
8969 +                affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));
8970 +                affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));
8971 +                affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));
8972 +                affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));
8973 +                break;
8974 +              }
8975 +              case 13:
8976 +              {
8977 +                /*
8978 +                  SkewX.
8979 +                */
8980 +                affine.ry=tan(DegreesToRadians(fmod(angle,360.0)));
8981 +                break;
8982 +              }
8983 +              case 14:
8984 +              {
8985 +                /*
8986 +                  SkewY.
8987 +                */
8988 +                affine.rx=tan(DegreesToRadians(fmod(angle,360.0)));
8989 +                break;
8990 +              }
8991 +            }
8992 +            draw_info->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
8993 +            draw_info->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
8994 +            draw_info->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
8995 +            draw_info->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
8996 +            draw_info->affine.tx=
8997 +              current.sx*affine.tx+current.ry*affine.ty+current.tx;
8998 +            draw_info->affine.ty=
8999 +              current.rx*affine.tx+current.sy*affine.ty+current.ty;
9000 +          }
9001 +          if (attribute_flag[15] != 0)
9002 +            draw_info->fill_pattern=CloneImage(
9003 +              argument_list[15].image_reference,0,0,MagickTrue,exception);
9004 +          if (attribute_flag[16] != 0)
9005 +            draw_info->pointsize=argument_list[16].real_reference;
9006 +          if (attribute_flag[17] != 0)
9007 +            {
9008 +              draw_info->stroke_antialias=argument_list[17].integer_reference != 0
9009 +                ? MagickTrue : MagickFalse;
9010 +              draw_info->text_antialias=draw_info->stroke_antialias;
9011 +            }
9012 +          if (attribute_flag[18] != 0)
9013 +            (void) CloneString(&draw_info->density,
9014 +              argument_list[18].string_reference);
9015 +          if (attribute_flag[19] != 0)
9016 +            draw_info->stroke_width=argument_list[19].real_reference;
9017 +          if (attribute_flag[21] != 0)
9018 +            draw_info->dash_offset=argument_list[21].real_reference;
9019 +          if (attribute_flag[22] != 0)
9020 +            {
9021 +              AV
9022 +                *av;
9023 +
9024 +              av=(AV *) argument_list[22].array_reference;
9025 +              draw_info->dash_pattern=(double *) AcquireQuantumMemory(
9026 +                av_len(av)+2UL,sizeof(*draw_info->dash_pattern));
9027 +              if (draw_info->dash_pattern != (double *) NULL)
9028 +                {
9029 +                  for (i=0; i <= av_len(av); i++)
9030 +                    draw_info->dash_pattern[i]=(double)
9031 +                      SvNV(*(av_fetch(av,i,0)));
9032 +                  draw_info->dash_pattern[i]=0.0;
9033 +                }
9034 +            }
9035 +          if (attribute_flag[23] != 0)
9036 +            image->interpolate=(InterpolatePixelMethod)
9037 +              argument_list[23].integer_reference;
9038 +          if ((attribute_flag[24] != 0) &&
9039 +              (draw_info->fill_pattern != (Image *) NULL))
9040 +            flags=ParsePageGeometry(draw_info->fill_pattern,
9041 +              argument_list[24].string_reference,
9042 +              &draw_info->fill_pattern->tile_offset,exception);
9043 +          if (attribute_flag[25] != 0)
9044 +            {
9045 +              (void) ConcatenateString(&draw_info->primitive," '");
9046 +              (void) ConcatenateString(&draw_info->primitive,
9047 +                argument_list[25].string_reference);
9048 +              (void) ConcatenateString(&draw_info->primitive,"'");
9049 +            }
9050 +          if (attribute_flag[26] != 0)
9051 +            draw_info->fill_pattern=CloneImage(
9052 +              argument_list[26].image_reference,0,0,MagickTrue,exception);
9053 +          if (attribute_flag[27] != 0)
9054 +            draw_info->stroke_pattern=CloneImage(
9055 +              argument_list[27].image_reference,0,0,MagickTrue,exception);
9056 +          if (attribute_flag[28] != 0)
9057 +            (void) CloneString(&draw_info->primitive,
9058 +              argument_list[28].string_reference);
9059 +          if (attribute_flag[29] != 0)
9060 +            draw_info->kerning=argument_list[29].real_reference;
9061 +          if (attribute_flag[30] != 0)
9062 +            draw_info->interline_spacing=argument_list[30].real_reference;
9063 +          if (attribute_flag[31] != 0)
9064 +            draw_info->interword_spacing=argument_list[31].real_reference;
9065 +          if (attribute_flag[32] != 0)
9066 +            draw_info->direction=(DirectionType)
9067 +              argument_list[32].integer_reference;
9068 +          DrawImage(image,draw_info);
9069 +          draw_info=DestroyDrawInfo(draw_info);
9070 +          break;
9071 +        }
9072 +        case 39:  /* Equalize */
9073 +        {
9074 +          if (attribute_flag[0] != 0)
9075 +            channel=(ChannelType) argument_list[0].integer_reference;
9076 +          EqualizeImageChannel(image,channel);
9077 +          break;
9078 +        }
9079 +        case 40:  /* Gamma */
9080 +        {
9081 +          if (attribute_flag[1] != 0)
9082 +            channel=(ChannelType) argument_list[1].integer_reference;
9083 +          if (attribute_flag[2] == 0)
9084 +            argument_list[2].real_reference=1.0;
9085 +          if (attribute_flag[3] == 0)
9086 +            argument_list[3].real_reference=1.0;
9087 +          if (attribute_flag[4] == 0)
9088 +            argument_list[4].real_reference=1.0;
9089 +          if (attribute_flag[0] == 0)
9090 +            {
9091 +              (void) FormatLocaleString(message,MaxTextExtent,
9092 +                "%.15g,%.15g,%.15g",(double) argument_list[2].real_reference,
9093 +                (double) argument_list[3].real_reference,
9094 +                (double) argument_list[4].real_reference);
9095 +              argument_list[0].string_reference=message;
9096 +            }
9097 +          if (strchr(argument_list[0].string_reference,',') != (char *) NULL)
9098 +            (void) GammaImage(image,argument_list[0].string_reference);
9099 +          else
9100 +            (void) GammaImageChannel(image,channel,StringToDouble(
9101 +              argument_list[0].string_reference,(char **) NULL));
9102 +          break;
9103 +        }
9104 +        case 41:  /* Map */
9105 +        {
9106 +          QuantizeInfo
9107 +            *quantize_info;
9108 +
9109 +          if (attribute_flag[0] == 0)
9110 +            {
9111 +              ThrowPerlException(exception,OptionError,"MapImageRequired",
9112 +                PackageName);
9113 +              goto PerlException;
9114 +            }
9115 +          quantize_info=AcquireQuantizeInfo(info->image_info);
9116 +          if (attribute_flag[1] != 0)
9117 +            quantize_info->dither=(MagickBooleanType)
9118 +              argument_list[1].integer_reference;
9119 +          if (attribute_flag[2] != 0)
9120 +            quantize_info->dither_method=(DitherMethod)
9121 +              argument_list[2].integer_reference;
9122 +          (void) RemapImages(quantize_info,image,
9123 +            argument_list[0].image_reference);
9124 +          quantize_info=DestroyQuantizeInfo(quantize_info);
9125 +          break;
9126 +        }
9127 +        case 42:  /* MatteFloodfill */
9128 +        {
9129 +          DrawInfo
9130 +            *draw_info;
9131 +
9132 +          MagickBooleanType
9133 +            invert;
9134 +
9135 +          MagickPixelPacket
9136 +            target;
9137 +
9138 +          draw_info=CloneDrawInfo(info ? info->image_info : (ImageInfo *) NULL,
9139 +            (DrawInfo *) NULL);
9140 +          if (attribute_flag[0] != 0)
9141 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
9142 +              &geometry,exception);
9143 +          if (attribute_flag[1] != 0)
9144 +            geometry.x=argument_list[1].integer_reference;
9145 +          if (attribute_flag[2] != 0)
9146 +            geometry.y=argument_list[2].integer_reference;
9147 +          if (image->matte == MagickFalse)
9148 +            (void) SetImageOpacity(image,OpaqueOpacity);
9149 +          (void) GetOneVirtualMagickPixel(image,geometry.x,geometry.y,&target,
9150 +            exception);
9151 +          if (attribute_flag[4] != 0)
9152 +            QueryMagickColor(argument_list[4].string_reference,&target,
9153 +              exception);
9154 +          if (attribute_flag[3] != 0)
9155 +            target.opacity=StringToDoubleInterval(
9156 +              argument_list[3].string_reference,(double) QuantumRange+1.0);
9157 +          if (attribute_flag[5] != 0)
9158 +            image->fuzz=StringToDoubleInterval(
9159 +              argument_list[5].string_reference,(double) QuantumRange+1.0);
9160 +          invert=MagickFalse;
9161 +          if (attribute_flag[6] != 0)
9162 +            invert=(MagickBooleanType) argument_list[6].integer_reference;
9163 +          (void) FloodfillPaintImage(image,OpacityChannel,draw_info,&target,
9164 +            geometry.x,geometry.y,invert);
9165 +          draw_info=DestroyDrawInfo(draw_info);
9166 +          break;
9167 +        }
9168 +        case 43:  /* Modulate */
9169 +        {
9170 +          char
9171 +            modulate[MaxTextExtent];
9172 +
9173 +          geometry_info.rho=100.0;
9174 +          geometry_info.sigma=100.0;
9175 +          geometry_info.xi=100.0;
9176 +          if (attribute_flag[0] != 0)
9177 +            (void)ParseGeometry(argument_list[0].string_reference,
9178 +              &geometry_info);
9179 +          if (attribute_flag[1] != 0)
9180 +            geometry_info.xi=argument_list[1].real_reference;
9181 +          if (attribute_flag[2] != 0)
9182 +            geometry_info.sigma=argument_list[2].real_reference;
9183 +          if (attribute_flag[3] != 0)
9184 +            {
9185 +              geometry_info.sigma=argument_list[3].real_reference;
9186 +              SetImageArtifact(image,"modulate:colorspace","HWB");
9187 +            }
9188 +          if (attribute_flag[4] != 0)
9189 +            {
9190 +              geometry_info.rho=argument_list[4].real_reference;
9191 +              SetImageArtifact(image,"modulate:colorspace","HSB");
9192 +            }
9193 +          if (attribute_flag[5] != 0)
9194 +            {
9195 +              geometry_info.sigma=argument_list[5].real_reference;
9196 +              SetImageArtifact(image,"modulate:colorspace","HSL");
9197 +            }
9198 +          if (attribute_flag[6] != 0)
9199 +            {
9200 +              geometry_info.rho=argument_list[6].real_reference;
9201 +              SetImageArtifact(image,"modulate:colorspace","HWB");
9202 +            }
9203 +          (void) FormatLocaleString(modulate,MaxTextExtent,"%.15g,%.15g,%.15g",
9204 +            geometry_info.rho,geometry_info.sigma,geometry_info.xi);
9205 +          (void) ModulateImage(image,modulate);
9206 +          break;
9207 +        }
9208 +        case 44:  /* Negate */
9209 +        {
9210 +          if (attribute_flag[0] == 0)
9211 +            argument_list[0].integer_reference=0;
9212 +          if (attribute_flag[1] != 0)
9213 +            channel=(ChannelType) argument_list[1].integer_reference;
9214 +          (void) NegateImageChannel(image,channel,
9215 +            argument_list[0].integer_reference != 0 ? MagickTrue : MagickFalse);
9216 +          break;
9217 +        }
9218 +        case 45:  /* Normalize */
9219 +        {
9220 +          if (attribute_flag[0] != 0)
9221 +            channel=(ChannelType) argument_list[0].integer_reference;
9222 +          NormalizeImageChannel(image,channel);
9223 +          break;
9224 +        }
9225 +        case 46:  /* NumberColors */
9226 +          break;
9227 +        case 47:  /* Opaque */
9228 +        {
9229 +          MagickBooleanType
9230 +            invert;
9231 +
9232 +          MagickPixelPacket
9233 +            fill_color,
9234 +            target;
9235 +
9236 +          (void) QueryMagickColor("none",&target,exception);
9237 +          (void) QueryMagickColor("none",&fill_color,exception);
9238 +          if (attribute_flag[0] != 0)
9239 +            (void) QueryMagickColor(argument_list[0].string_reference,
9240 +              &target,exception);
9241 +          if (attribute_flag[1] != 0)
9242 +            (void) QueryMagickColor(argument_list[1].string_reference,
9243 +              &fill_color,exception);
9244 +          if (attribute_flag[2] != 0)
9245 +            image->fuzz=StringToDoubleInterval(
9246 +              argument_list[2].string_reference,(double) QuantumRange+1.0);
9247 +          if (attribute_flag[3] != 0)
9248 +            channel=(ChannelType) argument_list[3].integer_reference;
9249 +          invert=MagickFalse;
9250 +          if (attribute_flag[4] != 0)
9251 +            invert=(MagickBooleanType) argument_list[4].integer_reference;
9252 +          (void) OpaquePaintImageChannel(image,channel,&target,&fill_color,
9253 +            invert);
9254 +          break;
9255 +        }
9256 +        case 48:  /* Quantize */
9257 +        {
9258 +          QuantizeInfo
9259 +            *quantize_info;
9260 +
9261 +          quantize_info=AcquireQuantizeInfo(info->image_info);
9262 +          if (attribute_flag[0] != 0)
9263 +            quantize_info->number_colors=(size_t)
9264 +              argument_list[0].integer_reference;
9265 +          if (attribute_flag[1] != 0)
9266 +            quantize_info->tree_depth=(size_t)
9267 +              argument_list[1].integer_reference;
9268 +          if (attribute_flag[2] != 0)
9269 +            quantize_info->colorspace=(ColorspaceType)
9270 +              argument_list[2].integer_reference;
9271 +          if (attribute_flag[3] != 0)
9272 +            quantize_info->dither=argument_list[3].integer_reference != 0 ?
9273 +              MagickTrue : MagickFalse;
9274 +          if (attribute_flag[4] != 0)
9275 +            quantize_info->measure_error=
9276 +              argument_list[4].integer_reference != 0 ? MagickTrue : MagickFalse;
9277 +          if (attribute_flag[6] != 0)
9278 +            (void) QueryColorDatabase(argument_list[6].string_reference,
9279 +              &image->transparent_color,exception);
9280 +          if (attribute_flag[7] != 0)
9281 +            quantize_info->dither_method=(DitherMethod)
9282 +              argument_list[7].integer_reference;
9283 +          if (attribute_flag[5] && argument_list[5].integer_reference)
9284 +              (void) QuantizeImages(quantize_info,image);
9285 +          else if ((image->storage_class == DirectClass) ||
9286 +              (image->colors > quantize_info->number_colors) ||
9287 +              (quantize_info->colorspace == GRAYColorspace))
9288 +            (void) QuantizeImage(quantize_info,image);
9289 +          else
9290 +            CompressImageColormap(image);
9291 +          quantize_info=DestroyQuantizeInfo(quantize_info);
9292 +          break;
9293 +        }
9294 +        case 49:  /* Raise */
9295 +        {
9296 +          if (attribute_flag[0] != 0)
9297 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
9298 +              &geometry,exception);
9299 +          if (attribute_flag[1] != 0)
9300 +            geometry.width=argument_list[1].integer_reference;
9301 +          if (attribute_flag[2] != 0)
9302 +            geometry.height=argument_list[2].integer_reference;
9303 +          if (attribute_flag[3] == 0)
9304 +            argument_list[3].integer_reference=1;
9305 +          (void) RaiseImage(image,&geometry,argument_list[3].integer_reference
9306 +            != 0 ? MagickTrue : MagickFalse);
9307 +          break;
9308 +        }
9309 +        case 50:  /* Segment */
9310 +        {
9311 +          ColorspaceType
9312 +            colorspace;
9313 +
9314 +          double
9315 +            cluster_threshold,
9316 +            smoothing_threshold;
9317 +
9318 +          MagickBooleanType
9319 +            verbose;
9320 +
9321 +          cluster_threshold=1.0;
9322 +          smoothing_threshold=1.5;
9323 +          colorspace=sRGBColorspace;
9324 +          verbose=MagickFalse;
9325 +          if (attribute_flag[0] != 0)
9326 +            {
9327 +              flags=ParseGeometry(argument_list[0].string_reference,
9328 +                &geometry_info);
9329 +              cluster_threshold=geometry_info.rho;
9330 +              if (flags & SigmaValue)
9331 +                smoothing_threshold=geometry_info.sigma;
9332 +            }
9333 +          if (attribute_flag[1] != 0)
9334 +            cluster_threshold=argument_list[1].real_reference;
9335 +          if (attribute_flag[2] != 0)
9336 +            smoothing_threshold=argument_list[2].real_reference;
9337 +          if (attribute_flag[3] != 0)
9338 +            colorspace=(ColorspaceType) argument_list[3].integer_reference;
9339 +          if (attribute_flag[4] != 0)
9340 +            verbose=argument_list[4].integer_reference != 0 ?
9341 +              MagickTrue : MagickFalse;
9342 +          (void) SegmentImage(image,colorspace,verbose,cluster_threshold,
9343 +            smoothing_threshold);
9344 +          break;
9345 +        }
9346 +        case 51:  /* Signature */
9347 +        {
9348 +          (void) SignatureImage(image);
9349 +          break;
9350 +        }
9351 +        case 52:  /* Solarize */
9352 +        {
9353 +          geometry_info.rho=QuantumRange/2.0;
9354 +          if (attribute_flag[0] != 0)
9355 +            flags=ParseGeometry(argument_list[0].string_reference,
9356 +              &geometry_info);
9357 +          if (attribute_flag[1] != 0)
9358 +            geometry_info.rho=StringToDoubleInterval(
9359 +             argument_list[1].string_reference,(double) QuantumRange+1.0);
9360 +          if (attribute_flag[2] != 0)
9361 +            channel=(ChannelType) argument_list[2].integer_reference;
9362 +          (void) SolarizeImageChannel(image,channel,geometry_info.rho,
9363 +            exception);
9364 +          break;
9365 +        }
9366 +        case 53:  /* Sync */
9367 +        {
9368 +          (void) SyncImage(image);
9369 +          break;
9370 +        }
9371 +        case 54:  /* Texture */
9372 +        {
9373 +          if (attribute_flag[0] == 0)
9374 +            break;
9375 +          TextureImage(image,argument_list[0].image_reference);
9376 +          break;
9377 +        }
9378 +        case 55:  /* Evalute */
9379 +        {
9380 +          MagickEvaluateOperator
9381 +            op;
9382 +
9383 +          op=SetEvaluateOperator;
9384 +          if (attribute_flag[0] == MagickFalse)
9385 +            argument_list[0].real_reference=0.0;
9386 +          if (attribute_flag[1] != MagickFalse)
9387 +            op=(MagickEvaluateOperator) argument_list[1].integer_reference;
9388 +          if (attribute_flag[2] != MagickFalse)
9389 +            channel=(ChannelType) argument_list[2].integer_reference;
9390 +          (void) EvaluateImageChannel(image,channel,op,
9391 +            argument_list[0].real_reference,exception);
9392 +          break;
9393 +        }
9394 +        case 56:  /* Transparent */
9395 +        {
9396 +          double
9397 +            opacity;
9398 +
9399 +          MagickBooleanType
9400 +            invert;
9401 +
9402 +          MagickPixelPacket
9403 +            target;
9404 +
9405 +          (void) QueryMagickColor("none",&target,exception);
9406 +          if (attribute_flag[0] != 0)
9407 +            (void) QueryMagickColor(argument_list[0].string_reference,&target,
9408 +              exception);
9409 +          opacity=TransparentOpacity;
9410 +          if (attribute_flag[1] != 0)
9411 +            opacity=StringToDoubleInterval(argument_list[1].string_reference,
9412 +              (double) QuantumRange+1.0);
9413 +          if (attribute_flag[2] != 0)
9414 +            image->fuzz=StringToDoubleInterval(
9415 +              argument_list[2].string_reference,(double) QuantumRange+1.0);
9416 +          if (attribute_flag[3] == 0)
9417 +            argument_list[3].integer_reference=0;
9418 +          invert=MagickFalse;
9419 +          if (attribute_flag[3] != 0)
9420 +            invert=(MagickBooleanType) argument_list[3].integer_reference;
9421 +          (void) TransparentPaintImage(image,&target,ClampToQuantum(opacity),
9422 +            invert);
9423 +          break;
9424 +        }
9425 +        case 57:  /* Threshold */
9426 +        {
9427 +          double
9428 +            threshold;
9429 +
9430 +          if (attribute_flag[0] == 0)
9431 +            argument_list[0].string_reference="50%";
9432 +          if (attribute_flag[1] != 0)
9433 +            channel=(ChannelType) argument_list[1].integer_reference;
9434 +          threshold=StringToDoubleInterval(argument_list[0].string_reference,
9435 +            (double) QuantumRange+1.0);
9436 +          (void) BilevelImageChannel(image,channel,threshold);
9437 +          break;
9438 +        }
9439 +        case 58:  /* Charcoal */
9440 +        {
9441 +          if (attribute_flag[0] != 0)
9442 +            {
9443 +              flags=ParseGeometry(argument_list[0].string_reference,
9444 +                &geometry_info);
9445 +              if ((flags & SigmaValue) == 0)
9446 +                geometry_info.sigma=1.0;
9447 +            }
9448 +          if (attribute_flag[1] != 0)
9449 +            geometry_info.rho=argument_list[1].real_reference;
9450 +          if (attribute_flag[2] != 0)
9451 +            geometry_info.sigma=argument_list[2].real_reference;
9452 +          image=CharcoalImage(image,geometry_info.rho,geometry_info.sigma,
9453 +            exception);
9454 +          break;
9455 +        }
9456 +        case 59:  /* Trim */
9457 +        {
9458 +          if (attribute_flag[0] != 0)
9459 +            image->fuzz=StringToDoubleInterval(
9460 +              argument_list[0].string_reference,(double) QuantumRange+1.0);
9461 +          image=TrimImage(image,exception);
9462 +          break;
9463 +        }
9464 +        case 60:  /* Wave */
9465 +        {
9466 +          if (attribute_flag[0] != 0)
9467 +            {
9468 +              flags=ParseGeometry(argument_list[0].string_reference,
9469 +                &geometry_info);
9470 +              if ((flags & SigmaValue) == 0)
9471 +                geometry_info.sigma=1.0;
9472 +            }
9473 +          if (attribute_flag[1] != 0)
9474 +            geometry_info.rho=argument_list[1].real_reference;
9475 +          if (attribute_flag[2] != 0)
9476 +            geometry_info.sigma=argument_list[2].real_reference;
9477 +          if (attribute_flag[3] != 0)
9478 +            image->interpolate=(InterpolatePixelMethod)
9479 +              argument_list[3].integer_reference;
9480 +          image=WaveImage(image,geometry_info.rho,geometry_info.sigma,
9481 +            exception);
9482 +          break;
9483 +        }
9484 +        case 61:  /* Separate */
9485 +        {
9486 +          if (attribute_flag[0] != 0)
9487 +            channel=(ChannelType) argument_list[0].integer_reference;
9488 +          (void) SeparateImageChannel(image,channel);
9489 +          break;
9490 +        }
9491 +        case 63:  /* Stereo */
9492 +        {
9493 +          if (attribute_flag[0] == 0)
9494 +            {
9495 +              ThrowPerlException(exception,OptionError,"StereoImageRequired",
9496 +                PackageName);
9497 +              goto PerlException;
9498 +            }
9499 +          if (attribute_flag[1] != 0)
9500 +            geometry.x=argument_list[1].integer_reference;
9501 +          if (attribute_flag[2] != 0)
9502 +            geometry.y=argument_list[2].integer_reference;
9503 +          image=StereoAnaglyphImage(image,argument_list[0].image_reference,
9504 +            geometry.x,geometry.y,exception);
9505 +          break;
9506 +        }
9507 +        case 64:  /* Stegano */
9508 +        {
9509 +          if (attribute_flag[0] == 0)
9510 +            {
9511 +              ThrowPerlException(exception,OptionError,"SteganoImageRequired",
9512 +                PackageName);
9513 +              goto PerlException;
9514 +            }
9515 +          if (attribute_flag[1] == 0)
9516 +            argument_list[1].integer_reference=0;
9517 +          image->offset=argument_list[1].integer_reference;
9518 +          image=SteganoImage(image,argument_list[0].image_reference,exception);
9519 +          break;
9520 +        }
9521 +        case 65:  /* Deconstruct */
9522 +        {
9523 +          image=DeconstructImages(image,exception);
9524 +          break;
9525 +        }
9526 +        case 66:  /* GaussianBlur */
9527 +        {
9528 +          if (attribute_flag[0] != 0)
9529 +            {
9530 +              flags=ParseGeometry(argument_list[0].string_reference,
9531 +                &geometry_info);
9532 +              if ((flags & SigmaValue) == 0)
9533 +                geometry_info.sigma=1.0;
9534 +            }
9535 +          if (attribute_flag[1] != 0)
9536 +            geometry_info.rho=argument_list[1].real_reference;
9537 +          if (attribute_flag[2] != 0)
9538 +            geometry_info.sigma=argument_list[2].real_reference;
9539 +          if (attribute_flag[3] != 0)
9540 +            channel=(ChannelType) argument_list[3].integer_reference;
9541 +          image=GaussianBlurImageChannel(image,channel,geometry_info.rho,
9542 +            geometry_info.sigma,exception);
9543 +          break;
9544 +        }
9545 +        case 67:  /* Convolve */
9546 +        {
9547 +          AV
9548 +            *av;
9549 +
9550 +          double
9551 +            *kernel;
9552 +
9553 +          size_t
9554 +            order;
9555 +
9556 +          if (attribute_flag[0] == 0)
9557 +            break;
9558 +          if (attribute_flag[1] != 0)
9559 +            channel=(ChannelType) argument_list[1].integer_reference;
9560 +          if (attribute_flag[2] != 0)
9561 +            image->bias=StringToDoubleInterval(
9562 +              argument_list[2].string_reference,(double) QuantumRange+1.0);
9563 +          av=(AV *) argument_list[0].array_reference;
9564 +          order=(size_t) sqrt(av_len(av)+1);
9565 +          kernel=(double *) AcquireQuantumMemory(order,order*sizeof(*kernel));
9566 +          if (kernel == (double *) NULL)
9567 +            {
9568 +              ThrowPerlException(exception,ResourceLimitFatalError,
9569 +                "MemoryAllocationFailed",PackageName);
9570 +              goto PerlException;
9571 +            }
9572 +          for (j=0; (j < (ssize_t) (order*order)) && (j < (av_len(av)+1)); j++)
9573 +            kernel[j]=(double) SvNV(*(av_fetch(av,j,0)));
9574 +          for ( ; j < (ssize_t) (order*order); j++)
9575 +            kernel[j]=0.0;
9576 +          image=ConvolveImageChannel(image,channel,order,kernel,exception);
9577 +          kernel=(double *) RelinquishMagickMemory(kernel);
9578 +          break;
9579 +        }
9580 +        case 68:  /* Profile */
9581 +        {
9582 +          const char
9583 +            *name;
9584 +
9585 +          Image
9586 +            *profile_image;
9587 +
9588 +          ImageInfo
9589 +            *profile_info;
9590 +
9591 +          StringInfo
9592 +            *profile;
9593 +
9594 +          name="*";
9595 +          if (attribute_flag[0] != 0)
9596 +            name=argument_list[0].string_reference;
9597 +          if (attribute_flag[2] != 0)
9598 +            image->rendering_intent=(RenderingIntent)
9599 +              argument_list[2].integer_reference;
9600 +          if (attribute_flag[3] != 0)
9601 +            image->black_point_compensation=
9602 +              argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse;
9603 +          if (attribute_flag[1] != 0)
9604 +            {
9605 +              if (argument_list[1].length == 0)
9606 +                {
9607 +                  /*
9608 +                    Remove a profile from the image.
9609 +                  */
9610 +                  (void) ProfileImage(image,name,(const unsigned char *) NULL,0,
9611 +                    MagickTrue);
9612 +                  break;
9613 +                }
9614 +              /*
9615 +                Associate user supplied profile with the image.
9616 +              */
9617 +              profile=AcquireStringInfo(argument_list[1].length);
9618 +              SetStringInfoDatum(profile,(const unsigned char *)
9619 +                argument_list[1].string_reference);
9620 +              (void) ProfileImage(image,name,GetStringInfoDatum(profile),
9621 +                (size_t) GetStringInfoLength(profile),MagickFalse);
9622 +              profile=DestroyStringInfo(profile);
9623 +              break;
9624 +            }
9625 +          /*
9626 +            Associate a profile with the image.
9627 +          */
9628 +          profile_info=
9629 +            CloneImageInfo(info ? info->image_info : (ImageInfo *) NULL);
9630 +          (void) CopyMagickString(profile_info->filename,name,MaxTextExtent);
9631 +          profile_image=ReadImages(profile_info,&image->exception);
9632 +          if (profile_image == (Image *) NULL)
9633 +            break;
9634 +          ResetImageProfileIterator(profile_image);
9635 +          name=GetNextImageProfile(profile_image);
9636 +          while (name != (const char *) NULL)
9637 +          {
9638 +            const StringInfo
9639 +              *profile;
9640 +
9641 +            profile=GetImageProfile(profile_image,name);
9642 +            if (profile != (const StringInfo *) NULL)
9643 +              (void) ProfileImage(image,name,GetStringInfoDatum(profile),
9644 +                (size_t) GetStringInfoLength(profile),MagickFalse);
9645 +            name=GetNextImageProfile(profile_image);
9646 +          }
9647 +          profile_image=DestroyImage(profile_image);
9648 +          profile_info=DestroyImageInfo(profile_info);
9649 +          break;
9650 +        }
9651 +        case 69:  /* UnsharpMask */
9652 +        {
9653 +          if (attribute_flag[0] != 0)
9654 +            {
9655 +              flags=ParseGeometry(argument_list[0].string_reference,
9656 +                &geometry_info);
9657 +              if ((flags & SigmaValue) == 0)
9658 +                geometry_info.sigma=1.0;
9659 +              if ((flags & XiValue) == 0)
9660 +                geometry_info.xi=1.0;
9661 +              if ((flags & PsiValue) == 0)
9662 +                geometry_info.psi=0.5;
9663 +            }
9664 +          if (attribute_flag[1] != 0)
9665 +            geometry_info.rho=argument_list[1].real_reference;
9666 +          if (attribute_flag[2] != 0)
9667 +            geometry_info.sigma=argument_list[2].real_reference;
9668 +          if (attribute_flag[3] != 0)
9669 +            geometry_info.xi=argument_list[3].real_reference;
9670 +          if (attribute_flag[4] != 0)
9671 +            geometry_info.psi=argument_list[4].real_reference;
9672 +          if (attribute_flag[5] != 0)
9673 +            channel=(ChannelType) argument_list[5].integer_reference;
9674 +          image=UnsharpMaskImageChannel(image,channel,geometry_info.rho,
9675 +            geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
9676 +          break;
9677 +        }
9678 +        case 70:  /* MotionBlur */
9679 +        {
9680 +          if (attribute_flag[0] != 0)
9681 +            {
9682 +              flags=ParseGeometry(argument_list[0].string_reference,
9683 +                &geometry_info);
9684 +              if ((flags & SigmaValue) == 0)
9685 +                geometry_info.sigma=1.0;
9686 +              if ((flags & XiValue) == 0)
9687 +                geometry_info.xi=1.0;
9688 +            }
9689 +          if (attribute_flag[1] != 0)
9690 +            geometry_info.rho=argument_list[1].real_reference;
9691 +          if (attribute_flag[2] != 0)
9692 +            geometry_info.sigma=argument_list[2].real_reference;
9693 +          if (attribute_flag[3] != 0)
9694 +            geometry_info.xi=argument_list[3].real_reference;
9695 +          if (attribute_flag[4] != 0)
9696 +            channel=(ChannelType) argument_list[4].integer_reference;
9697 +          image=MotionBlurImageChannel(image,channel,geometry_info.rho,
9698 +            geometry_info.sigma,geometry_info.xi,exception);
9699 +          break;
9700 +        }
9701 +        case 71:  /* OrderedDither */
9702 +        {
9703 +          if (attribute_flag[0] == 0)
9704 +            argument_list[0].string_reference="o8x8";
9705 +          if (attribute_flag[1] != 0)
9706 +            channel=(ChannelType) argument_list[1].integer_reference;
9707 +          (void) OrderedPosterizeImageChannel(image,channel,
9708 +            argument_list[0].string_reference,exception);
9709 +          break;
9710 +        }
9711 +        case 72:  /* Shave */
9712 +        {
9713 +          if (attribute_flag[0] != 0)
9714 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
9715 +              &geometry,exception);
9716 +          if (attribute_flag[1] != 0)
9717 +            geometry.width=argument_list[1].integer_reference;
9718 +          if (attribute_flag[2] != 0)
9719 +            geometry.height=argument_list[2].integer_reference;
9720 +          image=ShaveImage(image,&geometry,exception);
9721 +          break;
9722 +        }
9723 +        case 73:  /* Level */
9724 +        {
9725 +          double
9726 +            black_point,
9727 +            gamma,
9728 +            white_point;
9729 +
9730 +          black_point=0.0;
9731 +          white_point=(MagickRealType) image->columns*image->rows;
9732 +          gamma=1.0;
9733 +          if (attribute_flag[0] != 0)
9734 +            {
9735 +              flags=ParseGeometry(argument_list[0].string_reference,
9736 +                &geometry_info);
9737 +              black_point=geometry_info.rho;
9738 +              if ((flags & SigmaValue) != 0)
9739 +                white_point=geometry_info.sigma;
9740 +              if ((flags & XiValue) != 0)
9741 +                gamma=geometry_info.xi;
9742 +              if ((flags & PercentValue) != 0)
9743 +                {
9744 +                  black_point*=(double) (QuantumRange/100.0);
9745 +                  white_point*=(double) (QuantumRange/100.0);
9746 +                }
9747 +              if ((flags & SigmaValue) == 0)
9748 +                white_point=(double) QuantumRange-black_point;
9749 +            }
9750 +          if (attribute_flag[1] != 0)
9751 +            black_point=argument_list[1].real_reference;
9752 +          if (attribute_flag[2] != 0)
9753 +            white_point=argument_list[2].real_reference;
9754 +          if (attribute_flag[3] != 0)
9755 +            gamma=argument_list[3].real_reference;
9756 +          if (attribute_flag[4] != 0)
9757 +            channel=(ChannelType) argument_list[4].integer_reference;
9758 +          if (attribute_flag[5] != 0)
9759 +            {
9760 +              argument_list[0].real_reference=argument_list[5].real_reference;
9761 +              attribute_flag[0]=attribute_flag[5];
9762 +            }
9763 +          (void) LevelImageChannel(image,channel,black_point,white_point,gamma);
9764 +          break;
9765 +        }
9766 +        case 74:  /* Clip */
9767 +        {
9768 +          if (attribute_flag[0] == 0)
9769 +            argument_list[0].string_reference="#1";
9770 +          if (attribute_flag[1] == 0)
9771 +            argument_list[1].integer_reference=MagickTrue;
9772 +          (void) ClipImagePath(image,argument_list[0].string_reference,
9773 +            argument_list[1].integer_reference != 0 ? MagickTrue : MagickFalse);
9774 +          break;
9775 +        }
9776 +        case 75:  /* AffineTransform */
9777 +        {
9778 +          DrawInfo
9779 +            *draw_info;
9780 +
9781 +          draw_info=CloneDrawInfo(info ? info->image_info : (ImageInfo *) NULL,
9782 +            (DrawInfo *) NULL);
9783 +          if (attribute_flag[0] != 0)
9784 +            {
9785 +              AV
9786 +                *av;
9787 +
9788 +              av=(AV *) argument_list[0].array_reference;
9789 +              if ((av_len(av) != 3) && (av_len(av) != 5))
9790 +                {
9791 +                  ThrowPerlException(exception,OptionError,
9792 +                    "affine matrix must have 4 or 6 elements",PackageName);
9793 +                  goto PerlException;
9794 +                }
9795 +              draw_info->affine.sx=(double) SvNV(*(av_fetch(av,0,0)));
9796 +              draw_info->affine.rx=(double) SvNV(*(av_fetch(av,1,0)));
9797 +              draw_info->affine.ry=(double) SvNV(*(av_fetch(av,2,0)));
9798 +              draw_info->affine.sy=(double) SvNV(*(av_fetch(av,3,0)));
9799 +              if (fabs(draw_info->affine.sx*draw_info->affine.sy-
9800 +                  draw_info->affine.rx*draw_info->affine.ry) < MagickEpsilon)
9801 +                {
9802 +                  ThrowPerlException(exception,OptionError,
9803 +                    "affine matrix is singular",PackageName);
9804 +                   goto PerlException;
9805 +                }
9806 +              if (av_len(av) == 5)
9807 +                {
9808 +                  draw_info->affine.tx=(double) SvNV(*(av_fetch(av,4,0)));
9809 +                  draw_info->affine.ty=(double) SvNV(*(av_fetch(av,5,0)));
9810 +                }
9811 +            }
9812 +          for (j=1; j < 6; j++)
9813 +          {
9814 +            if (attribute_flag[j] == 0)
9815 +              continue;
9816 +            value=argument_list[j].string_reference;
9817 +            angle=argument_list[j].real_reference;
9818 +            current=draw_info->affine;
9819 +            GetAffineMatrix(&affine);
9820 +            switch (j)
9821 +            {
9822 +              case 1:
9823 +              {
9824 +                /*
9825 +                  Translate.
9826 +                */
9827 +                flags=ParseGeometry(value,&geometry_info);
9828 +                affine.tx=geometry_info.xi;
9829 +                affine.ty=geometry_info.psi;
9830 +                if ((flags & PsiValue) == 0)
9831 +                  affine.ty=affine.tx;
9832 +                break;
9833 +              }
9834 +              case 2:
9835 +              {
9836 +                /*
9837 +                  Scale.
9838 +                */
9839 +                flags=ParseGeometry(value,&geometry_info);
9840 +                affine.sx=geometry_info.rho;
9841 +                affine.sy=geometry_info.sigma;
9842 +                if ((flags & SigmaValue) == 0)
9843 +                  affine.sy=affine.sx;
9844 +                break;
9845 +              }
9846 +              case 3:
9847 +              {
9848 +                /*
9849 +                  Rotate.
9850 +                */
9851 +                if (angle == 0.0)
9852 +                  break;
9853 +                affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));
9854 +                affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));
9855 +                affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));
9856 +                affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));
9857 +                break;
9858 +              }
9859 +              case 4:
9860 +              {
9861 +                /*
9862 +                  SkewX.
9863 +                */
9864 +                affine.ry=tan(DegreesToRadians(fmod(angle,360.0)));
9865 +                break;
9866 +              }
9867 +              case 5:
9868 +              {
9869 +                /*
9870 +                  SkewY.
9871 +                */
9872 +                affine.rx=tan(DegreesToRadians(fmod(angle,360.0)));
9873 +                break;
9874 +              }
9875 +            }
9876 +            draw_info->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
9877 +            draw_info->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
9878 +            draw_info->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
9879 +            draw_info->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
9880 +            draw_info->affine.tx=
9881 +              current.sx*affine.tx+current.ry*affine.ty+current.tx;
9882 +            draw_info->affine.ty=
9883 +              current.rx*affine.tx+current.sy*affine.ty+current.ty;
9884 +          }
9885 +          if (attribute_flag[6] != 0)
9886 +            image->interpolate=(InterpolatePixelMethod)
9887 +              argument_list[6].integer_reference;
9888 +          if (attribute_flag[7] != 0)
9889 +            QueryColorDatabase(argument_list[7].string_reference,
9890 +              &image->background_color,exception);
9891 +          image=AffineTransformImage(image,&draw_info->affine,exception);
9892 +          draw_info=DestroyDrawInfo(draw_info);
9893 +          break;
9894 +        }
9895 +        case 76:  /* Difference */
9896 +        {
9897 +          if (attribute_flag[0] == 0)
9898 +            {
9899 +              ThrowPerlException(exception,OptionError,
9900 +                "ReferenceImageRequired",PackageName);
9901 +              goto PerlException;
9902 +            }
9903 +          if (attribute_flag[1] != 0)
9904 +            image->fuzz=StringToDoubleInterval(
9905 +              argument_list[1].string_reference,(double) QuantumRange+1.0);
9906 +          (void) IsImagesEqual(image,argument_list[0].image_reference);
9907 +          break;
9908 +        }
9909 +        case 77:  /* AdaptiveThreshold */
9910 +        {
9911 +          if (attribute_flag[0] != 0)
9912 +            {
9913 +              flags=ParseGeometry(argument_list[0].string_reference,
9914 +                &geometry_info);
9915 +              if ((flags & PercentValue) != 0)
9916 +                geometry_info.xi=QuantumRange*geometry_info.xi/100.0;
9917 +            }
9918 +          if (attribute_flag[1] != 0)
9919 +            geometry_info.rho=argument_list[1].integer_reference;
9920 +          if (attribute_flag[2] != 0)
9921 +            geometry_info.sigma=argument_list[2].integer_reference;
9922 +          if (attribute_flag[3] != 0)
9923 +            geometry_info.xi=argument_list[3].integer_reference;;
9924 +          image=AdaptiveThresholdImage(image,(size_t) geometry_info.rho,
9925 +            (size_t) geometry_info.sigma,(ssize_t) geometry_info.xi,
9926 +            exception);
9927 +          break;
9928 +        }
9929 +        case 78:  /* Resample */
9930 +        {
9931 +          size_t
9932 +            height,
9933 +            width;
9934 +
9935 +          if (attribute_flag[0] != 0)
9936 +            {
9937 +              flags=ParseGeometry(argument_list[0].string_reference,
9938 +                &geometry_info);
9939 +              if ((flags & SigmaValue) == 0)
9940 +                geometry_info.sigma=geometry_info.rho;
9941 +            }
9942 +          if (attribute_flag[1] != 0)
9943 +            geometry_info.rho=argument_list[1].real_reference;
9944 +          if (attribute_flag[2] != 0)
9945 +            geometry_info.sigma=argument_list[2].real_reference;
9946 +          if (attribute_flag[3] == 0)
9947 +            argument_list[3].integer_reference=(ssize_t) UndefinedFilter;
9948 +          if (attribute_flag[4] == 0)
9949 +            SetImageArtifact(image,"filter:support",
9950 +              argument_list[4].string_reference);
9951 +          if (attribute_flag[5] != 0)
9952 +            argument_list[5].real_reference=1.0;
9953 +          width=(size_t) (geometry_info.rho*image->columns/
9954 +            (image->x_resolution == 0.0 ? 72.0 : image->x_resolution)+0.5);
9955 +          height=(size_t) (geometry_info.sigma*image->rows/
9956 +            (image->y_resolution == 0.0 ? 72.0 : image->y_resolution)+0.5);
9957 +          image=ResizeImage(image,width,height,(FilterTypes)
9958 +            argument_list[3].integer_reference,argument_list[5].real_reference,
9959 +            exception);
9960 +          if (image != (Image *) NULL)
9961 +            {
9962 +              image->x_resolution=geometry_info.rho;
9963 +              image->y_resolution=geometry_info.sigma;
9964 +            }
9965 +          break;
9966 +        }
9967 +        case 79:  /* Describe */
9968 +        {
9969 +          if (attribute_flag[0] == 0)
9970 +            argument_list[0].file_reference=(FILE *) NULL;
9971 +          if (attribute_flag[1] != 0)
9972 +            (void) SetImageArtifact(image,"identify:features",
9973 +              argument_list[1].string_reference);
9974 +          (void) IdentifyImage(image,argument_list[0].file_reference,
9975 +            MagickTrue);
9976 +          break;
9977 +        }
9978 +        case 80:  /* BlackThreshold */
9979 +        {
9980 +          if (attribute_flag[0] == 0)
9981 +            argument_list[0].string_reference="50%";
9982 +          if (attribute_flag[2] != 0)
9983 +            channel=(ChannelType) argument_list[2].integer_reference;
9984 +          BlackThresholdImageChannel(image,channel,
9985 +            argument_list[0].string_reference,exception);
9986 +          break;
9987 +        }
9988 +        case 81:  /* WhiteThreshold */
9989 +        {
9990 +          if (attribute_flag[0] == 0)
9991 +            argument_list[0].string_reference="50%";
9992 +          if (attribute_flag[2] != 0)
9993 +            channel=(ChannelType) argument_list[2].integer_reference;
9994 +          WhiteThresholdImageChannel(image,channel,
9995 +            argument_list[0].string_reference,exception);
9996 +          break;
9997 +        }
9998 +        case 82:  /* RotationalBlur */
9999 +        {
10000 +          if (attribute_flag[0] != 0)
10001 +            {
10002 +              flags=ParseGeometry(argument_list[0].string_reference,
10003 +                &geometry_info);
10004 +              if ((flags & SigmaValue) == 0)
10005 +                geometry_info.sigma=1.0;
10006 +            }
10007 +          if (attribute_flag[1] != 0)
10008 +            geometry_info.rho=argument_list[1].real_reference;
10009 +          if (attribute_flag[2] != 0)
10010 +            channel=(ChannelType) argument_list[2].integer_reference;
10011 +          image=RotationalBlurImageChannel(image,channel,geometry_info.rho,
10012 +            exception);
10013 +          break;
10014 +        }
10015 +        case 83:  /* Thumbnail */
10016 +        {
10017 +          if (attribute_flag[0] != 0)
10018 +            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
10019 +              &geometry,exception);
10020 +          if (attribute_flag[1] != 0)
10021 +            geometry.width=argument_list[1].integer_reference;
10022 +          if (attribute_flag[2] != 0)
10023 +            geometry.height=argument_list[2].integer_reference;
10024 +          image=ThumbnailImage(image,geometry.width,geometry.height,exception);
10025 +          break;
10026 +        }
10027 +        case 84:  /* Strip */
10028 +        {
10029 +          (void) StripImage(image);
10030 +          break;
10031 +        }
10032 +        case 85:  /* Tint */
10033 +        {
10034 +          PixelPacket
10035 +            target;
10036 +
10037 +          (void) GetOneVirtualPixel(image,0,0,&target,exception);
10038 +          if (attribute_flag[0] != 0)
10039 +            (void) QueryColorDatabase(argument_list[0].string_reference,&target,
10040 +              exception);
10041 +          if (attribute_flag[1] == 0)
10042 +            argument_list[1].string_reference="100";
10043 +          image=TintImage(image,argument_list[1].string_reference,target,
10044 +            exception);
10045 +          break;
10046 +        }
10047 +        case 86:  /* Channel */
10048 +        {
10049 +          if (attribute_flag[0] != 0)
10050 +            channel=(ChannelType) argument_list[0].integer_reference;
10051 +          (void) SeparateImageChannel(image,channel);
10052 +          break;
10053 +        }
10054 +        case 87:  /* Splice */
10055 +        {
10056 +          if (attribute_flag[7] != 0)
10057 +            image->gravity=(GravityType) argument_list[7].integer_reference;
10058 +          if (attribute_flag[0] != 0)
10059 +            flags=ParseGravityGeometry(image,argument_list[0].string_reference,
10060 +              &geometry,exception);
10061 +          if (attribute_flag[1] != 0)
10062 +            geometry.width=argument_list[1].integer_reference;
10063 +          if (attribute_flag[2] != 0)
10064 +            geometry.height=argument_list[2].integer_reference;
10065 +          if (attribute_flag[3] != 0)
10066 +            geometry.x=argument_list[3].integer_reference;
10067 +          if (attribute_flag[4] != 0)
10068 +            geometry.y=argument_list[4].integer_reference;
10069 +          if (attribute_flag[5] != 0)
10070 +            image->fuzz=StringToDoubleInterval(
10071 +              argument_list[5].string_reference,(double) QuantumRange+1.0);
10072 +          if (attribute_flag[6] != 0)
10073 +            (void) QueryColorDatabase(argument_list[6].string_reference,
10074 +              &image->background_color,exception);
10075 +          image=SpliceImage(image,&geometry,exception);
10076 +          break;
10077 +        }
10078 +        case 88:  /* Posterize */
10079 +        {
10080 +          if (attribute_flag[0] == 0)
10081 +            argument_list[0].integer_reference=3;
10082 +          if (attribute_flag[1] == 0)
10083 +            argument_list[1].integer_reference=0;
10084 +          (void) PosterizeImage(image,argument_list[0].integer_reference,
10085 +            argument_list[1].integer_reference ? MagickTrue : MagickFalse);
10086 +          break;
10087 +        }
10088 +        case 89:  /* Shadow */
10089 +        {
10090 +          if (attribute_flag[0] != 0)
10091 +            {
10092 +              flags=ParseGeometry(argument_list[0].string_reference,
10093 +                &geometry_info);
10094 +              if ((flags & SigmaValue) == 0)
10095 +                geometry_info.sigma=1.0;
10096 +              if ((flags & XiValue) == 0)
10097 +                geometry_info.xi=4.0;
10098 +              if ((flags & PsiValue) == 0)
10099 +                geometry_info.psi=4.0;
10100 +            }
10101 +          if (attribute_flag[1] != 0)
10102 +            geometry_info.rho=argument_list[1].real_reference;
10103 +          if (attribute_flag[2] != 0)
10104 +            geometry_info.sigma=argument_list[2].real_reference;
10105 +          if (attribute_flag[3] != 0)
10106 +            geometry_info.xi=argument_list[3].integer_reference;
10107 +          if (attribute_flag[4] != 0)
10108 +            geometry_info.psi=argument_list[4].integer_reference;
10109 +          image=ShadowImage(image,geometry_info.rho,geometry_info.sigma,
10110 +            (ssize_t) ceil(geometry_info.xi-0.5),(ssize_t) ceil(geometry_info.psi-
10111 +            0.5),exception);
10112 +          break;
10113 +        }
10114 +        case 90:  /* Identify */
10115 +        {
10116 +          if (attribute_flag[0] == 0)
10117 +            argument_list[0].file_reference=(FILE *) NULL;
10118 +          if (attribute_flag[1] != 0)
10119 +            (void) SetImageArtifact(image,"identify:features",
10120 +              argument_list[1].string_reference);
10121 +          if ((attribute_flag[2] != 0) &&
10122 +              (argument_list[2].integer_reference != 0))
10123 +            (void) SetImageArtifact(image,"identify:unique","true");
10124 +          (void) IdentifyImage(image,argument_list[0].file_reference,
10125 +            MagickTrue);
10126 +          break;
10127 +        }
10128 +        case 91:  /* SepiaTone */
10129 +        {
10130 +          if (attribute_flag[0] == 0)
10131 +            argument_list[0].real_reference=80.0*QuantumRange/100.0;
10132 +          image=SepiaToneImage(image,argument_list[0].real_reference,
10133 +            exception);
10134 +          break;
10135 +        }
10136 +        case 92:  /* SigmoidalContrast */
10137 +        {
10138 +          MagickBooleanType
10139 +            sharpen;
10140 +
10141 +          if (attribute_flag[0] != 0)
10142 +            {
10143 +              flags=ParseGeometry(argument_list[0].string_reference,
10144 +                &geometry_info);
10145 +              if ((flags & SigmaValue) == 0)
10146 +                geometry_info.sigma=QuantumRange/2.0;
10147 +              if ((flags & PercentValue) != 0)
10148 +                geometry_info.sigma=QuantumRange*geometry_info.sigma/100.0;
10149 +            }
10150 +          if (attribute_flag[1] != 0)
10151 +            geometry_info.rho=argument_list[1].real_reference;
10152 +          if (attribute_flag[2] != 0)
10153 +            geometry_info.sigma=argument_list[2].real_reference;
10154 +          if (attribute_flag[3] != 0)
10155 +            channel=(ChannelType) argument_list[3].integer_reference;
10156 +          sharpen=MagickTrue;
10157 +          if (attribute_flag[4] != 0)
10158 +            sharpen=argument_list[4].integer_reference != 0 ? MagickTrue :
10159 +              MagickFalse;
10160 +          (void) SigmoidalContrastImageChannel(image,channel,sharpen,
10161 +            geometry_info.rho,geometry_info.sigma);
10162 +          break;
10163 +        }
10164 +        case 93:  /* Extent */
10165 +        {
10166 +          if (attribute_flag[7] != 0)
10167 +            image->gravity=(GravityType) argument_list[7].integer_reference;
10168 +          if (attribute_flag[0] != 0)
10169 +            {
10170 +              int
10171 +                flags;
10172 +
10173 +              flags=ParseGravityGeometry(image,
10174 +                argument_list[0].string_reference,&geometry,exception);
10175 +              (void) flags;
10176 +              if (geometry.width == 0)
10177 +                geometry.width=image->columns;
10178 +              if (geometry.height == 0)
10179 +                geometry.height=image->rows;
10180 +            }
10181 +          if (attribute_flag[1] != 0)
10182 +            geometry.width=argument_list[1].integer_reference;
10183 +          if (attribute_flag[2] != 0)
10184 +            geometry.height=argument_list[2].integer_reference;
10185 +          if (attribute_flag[3] != 0)
10186 +            geometry.x=argument_list[3].integer_reference;
10187 +          if (attribute_flag[4] != 0)
10188 +            geometry.y=argument_list[4].integer_reference;
10189 +          if (attribute_flag[5] != 0)
10190 +            image->fuzz=StringToDoubleInterval(
10191 +              argument_list[5].string_reference,(double) QuantumRange+1.0);
10192 +          if (attribute_flag[6] != 0)
10193 +            (void) QueryColorDatabase(argument_list[6].string_reference,
10194 +              &image->background_color,exception);
10195 +          image=ExtentImage(image,&geometry,exception);
10196 +          break;
10197 +        }
10198 +        case 94:  /* Vignette */
10199 +        {
10200 +          if (attribute_flag[0] != 0)
10201 +            {
10202 +              flags=ParseGeometry(argument_list[0].string_reference,
10203 +                &geometry_info);
10204 +              if ((flags & SigmaValue) == 0)
10205 +                geometry_info.sigma=1.0;
10206 +              if ((flags & XiValue) == 0)
10207 +                geometry_info.xi=0.1*image->columns;
10208 +              if ((flags & PsiValue) == 0)
10209 +                geometry_info.psi=0.1*image->rows;
10210 +            }
10211 +          if (attribute_flag[1] != 0)
10212 +            geometry_info.rho=argument_list[1].real_reference;
10213 +          if (attribute_flag[2] != 0)
10214 +            geometry_info.sigma=argument_list[2].real_reference;
10215 +          if (attribute_flag[3] != 0)
10216 +            geometry_info.xi=argument_list[3].integer_reference;
10217 +          if (attribute_flag[4] != 0)
10218 +            geometry_info.psi=argument_list[4].integer_reference;
10219 +          if (attribute_flag[5] != 0)
10220 +            (void) QueryColorDatabase(argument_list[5].string_reference,
10221 +              &image->background_color,exception);
10222 +          image=VignetteImage(image,geometry_info.rho,geometry_info.sigma,
10223 +            (ssize_t) ceil(geometry_info.xi-0.5),(ssize_t) ceil(geometry_info.psi-
10224 +            0.5),exception);
10225 +          break;
10226 +        }
10227 +        case 95:  /* ContrastStretch */
10228 +        {
10229 +          double
10230 +            black_point,
10231 +            white_point;
10232 +
10233 +          black_point=0.0;
10234 +          white_point=(MagickRealType) image->columns*image->rows;
10235 +          if (attribute_flag[0] != 0)
10236 +            {
10237 +              flags=ParseGeometry(argument_list[0].string_reference,
10238 +                &geometry_info);
10239 +              black_point=geometry_info.rho;
10240 +              white_point=(flags & SigmaValue) != 0 ? geometry_info.sigma :
10241 +                black_point;
10242 +              if ((flags & PercentValue) != 0)
10243 +                {
10244 +                  black_point*=(double) image->columns*image->rows/100.0;
10245 +                  white_point*=(double) image->columns*image->rows/100.0;
10246 +                }
10247 +              white_point=(MagickRealType) image->columns*image->rows-
10248 +                white_point;
10249 +            }
10250 +          if (attribute_flag[1] != 0)
10251 +            black_point=argument_list[1].real_reference;
10252 +          if (attribute_flag[2] != 0)
10253 +            white_point=argument_list[2].real_reference;
10254 +          if (attribute_flag[4] != 0)
10255 +            channel=(ChannelType) argument_list[4].integer_reference;
10256 +          (void) ContrastStretchImageChannel(image,channel,black_point,
10257 +            white_point);
10258 +          break;
10259 +        }
10260 +        case 96:  /* Sans0 */
10261 +        {
10262 +          break;
10263 +        }
10264 +        case 97:  /* Sans1 */
10265 +        {
10266 +          break;
10267 +        }
10268 +        case 98:  /* AdaptiveSharpen */
10269 +        {
10270 +          if (attribute_flag[0] != 0)
10271 +            {
10272 +              flags=ParseGeometry(argument_list[0].string_reference,
10273 +                &geometry_info);
10274 +              if ((flags & SigmaValue) == 0)
10275 +                geometry_info.sigma=1.0;
10276 +            }
10277 +          if (attribute_flag[1] != 0)
10278 +            geometry_info.rho=argument_list[1].real_reference;
10279 +          if (attribute_flag[2] != 0)
10280 +            geometry_info.sigma=argument_list[2].real_reference;
10281 +          if (attribute_flag[3] != 0)
10282 +            channel=(ChannelType) argument_list[3].integer_reference;
10283 +          image=AdaptiveSharpenImageChannel(image,channel,geometry_info.rho,
10284 +            geometry_info.sigma,exception);
10285 +          break;
10286 +        }
10287 +        case 99:  /* Transpose */
10288 +        {
10289 +          image=TransposeImage(image,exception);
10290 +          break;
10291 +        }
10292 +        case 100:  /* Tranverse */
10293 +        {
10294 +          image=TransverseImage(image,exception);
10295 +          break;
10296 +        }
10297 +        case 101:  /* AutoOrient */
10298 +        {
10299 +          image=AutoOrientImage(image,image->orientation,exception);
10300 +          break;
10301 +        }
10302 +        case 102:  /* AdaptiveBlur */
10303 +        {
10304 +          if (attribute_flag[0] != 0)
10305 +            {
10306 +              flags=ParseGeometry(argument_list[0].string_reference,
10307 +                &geometry_info);
10308 +              if ((flags & SigmaValue) == 0)
10309 +                geometry_info.sigma=1.0;
10310 +            }
10311 +          if (attribute_flag[1] != 0)
10312 +            geometry_info.rho=argument_list[1].real_reference;
10313 +          if (attribute_flag[2] != 0)
10314 +            geometry_info.sigma=argument_list[2].real_reference;
10315 +          if (attribute_flag[3] != 0)
10316 +            channel=(ChannelType) argument_list[3].integer_reference;
10317 +          image=AdaptiveBlurImageChannel(image,channel,geometry_info.rho,
10318 +            geometry_info.sigma,exception);
10319 +          break;
10320 +        }
10321 +        case 103:  /* Sketch */
10322 +        {
10323 +          if (attribute_flag[0] != 0)
10324 +            {
10325 +              flags=ParseGeometry(argument_list[0].string_reference,
10326 +                &geometry_info);
10327 +              if ((flags & SigmaValue) == 0)
10328 +                geometry_info.sigma=1.0;
10329 +              if ((flags & XiValue) == 0)
10330 +                geometry_info.xi=1.0;
10331 +            }
10332 +          if (attribute_flag[1] != 0)
10333 +            geometry_info.rho=argument_list[1].real_reference;
10334 +          if (attribute_flag[2] != 0)
10335 +            geometry_info.sigma=argument_list[2].real_reference;
10336 +          if (attribute_flag[3] != 0)
10337 +            geometry_info.xi=argument_list[3].real_reference;
10338 +          image=SketchImage(image,geometry_info.rho,geometry_info.sigma,
10339 +            geometry_info.xi,exception);
10340 +          break;
10341 +        }
10342 +        case 104:  /* UniqueColors */
10343 +        {
10344 +          image=UniqueImageColors(image,exception);
10345 +          break;
10346 +        }
10347 +        case 105:  /* AdaptiveResize */
10348 +        {
10349 +          if (attribute_flag[0] != 0)
10350 +            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
10351 +              &geometry,exception);
10352 +          if (attribute_flag[1] != 0)
10353 +            geometry.width=argument_list[1].integer_reference;
10354 +          if (attribute_flag[2] != 0)
10355 +            geometry.height=argument_list[2].integer_reference;
10356 +          if (attribute_flag[3] != 0)
10357 +            image->filter=(FilterTypes) argument_list[4].integer_reference;
10358 +          if (attribute_flag[4] != 0)
10359 +            SetImageArtifact(image,"filter:support",
10360 +              argument_list[4].string_reference);
10361 +          if (attribute_flag[5] != 0)
10362 +            image->blur=argument_list[5].real_reference;
10363 +          image=AdaptiveResizeImage(image,geometry.width,geometry.height,
10364 +            exception);
10365 +          break;
10366 +        }
10367 +        case 106:  /* ClipMask */
10368 +        {
10369 +          if (attribute_flag[0] == 0)
10370 +            {
10371 +              ThrowPerlException(exception,OptionError,"MaskImageRequired",
10372 +                PackageName);
10373 +              goto PerlException;
10374 +            }
10375 +          image->clip_mask=CloneImage(argument_list[0].image_reference,0,0,
10376 +            MagickTrue,exception);
10377 +          (void) NegateImage(image->clip_mask,MagickFalse);
10378 +          break;
10379 +        }
10380 +        case 107:  /* LinearStretch */
10381 +        {
10382 +           double
10383 +             black_point,
10384 +             white_point;
10385 +
10386 +           black_point=0.0;
10387 +           white_point=(MagickRealType) image->columns*image->rows;
10388 +           if (attribute_flag[0] != 0)
10389 +             {
10390 +               flags=ParseGeometry(argument_list[0].string_reference,
10391 +                 &geometry_info);
10392 +               if ((flags & SigmaValue) != 0)
10393 +                  white_point=geometry_info.sigma;
10394 +               if ((flags & PercentValue) != 0)
10395 +                 {
10396 +                   black_point*=(double) image->columns*image->rows/100.0;
10397 +                   white_point*=(double) image->columns*image->rows/100.0;
10398 +                 }
10399 +               if ((flags & SigmaValue) == 0)
10400 +                 white_point=(double) image->columns*image->rows-black_point;
10401 +             }
10402 +          if (attribute_flag[1] != 0)
10403 +            black_point=argument_list[1].real_reference;
10404 +          if (attribute_flag[2] != 0)
10405 +            white_point=argument_list[2].real_reference;
10406 +          (void) LinearStretchImage(image,black_point,white_point);
10407 +          break;
10408 +        }
10409 +        case 109:  /* Mask */
10410 +        {
10411 +          if (attribute_flag[0] == 0)
10412 +            {
10413 +              ThrowPerlException(exception,OptionError,"MaskImageRequired",
10414 +                PackageName);
10415 +              goto PerlException;
10416 +            }
10417 +          image->mask=CloneImage(argument_list[0].image_reference,0,0,
10418 +            MagickTrue,exception);
10419 +          (void) NegateImage(image->mask,MagickFalse);
10420 +          break;
10421 +        }
10422 +        case 110:  /* Polaroid */
10423 +        {
10424 +          DrawInfo
10425 +            *draw_info;
10426 +
10427 +          double
10428 +            angle;
10429 +
10430 +          draw_info=CloneDrawInfo(info ? info->image_info : (ImageInfo *) NULL,
10431 +            (DrawInfo *) NULL);
10432 +          if (attribute_flag[0] != 0)
10433 +            (void) SetImageProperty(image,"caption",InterpretImageProperties(
10434 +              info ? info->image_info : (ImageInfo *) NULL,image,
10435 +              argument_list[0].string_reference));
10436 +          angle=0.0;
10437 +          if (attribute_flag[1] != 0)
10438 +            angle=argument_list[1].real_reference;
10439 +          if (attribute_flag[2] != 0)
10440 +            (void) CloneString(&draw_info->font,
10441 +              argument_list[2].string_reference);
10442 +          if (attribute_flag[3] != 0)
10443 +            (void) QueryColorDatabase(argument_list[3].string_reference,
10444 +              &draw_info->stroke,exception);
10445 +          if (attribute_flag[4] != 0)
10446 +            (void) QueryColorDatabase(argument_list[4].string_reference,
10447 +              &draw_info->fill,exception);
10448 +          if (attribute_flag[5] != 0)
10449 +            draw_info->stroke_width=argument_list[5].real_reference;
10450 +          if (attribute_flag[6] != 0)
10451 +            draw_info->pointsize=argument_list[6].real_reference;
10452 +          if (attribute_flag[7] != 0)
10453 +            draw_info->gravity=(GravityType) argument_list[7].integer_reference;
10454 +          if (attribute_flag[8] != 0)
10455 +            (void) QueryColorDatabase(argument_list[8].string_reference,
10456 +              &image->background_color,exception);
10457 +          image=PolaroidImage(image,draw_info,angle,exception);
10458 +          draw_info=DestroyDrawInfo(draw_info);
10459 +          break;
10460 +        }
10461 +        case 111:  /* FloodfillPaint */
10462 +        {
10463 +          DrawInfo
10464 +            *draw_info;
10465 +
10466 +          MagickBooleanType
10467 +            invert;
10468 +
10469 +          MagickPixelPacket
10470 +            target;
10471 +
10472 +          draw_info=CloneDrawInfo(info ? info->image_info :
10473 +            (ImageInfo *) NULL,(DrawInfo *) NULL);
10474 +          if (attribute_flag[0] != 0)
10475 +            flags=ParsePageGeometry(image,argument_list[0].string_reference,
10476 +              &geometry,exception);
10477 +          if (attribute_flag[1] != 0)
10478 +            geometry.x=argument_list[1].integer_reference;
10479 +          if (attribute_flag[2] != 0)
10480 +            geometry.y=argument_list[2].integer_reference;
10481 +          if (attribute_flag[3] != 0)
10482 +            (void) QueryColorDatabase(argument_list[3].string_reference,
10483 +              &draw_info->fill,exception);
10484 +          (void) GetOneVirtualMagickPixel(image,geometry.x,geometry.y,&target,
10485 +            exception);
10486 +          if (attribute_flag[4] != 0)
10487 +            QueryMagickColor(argument_list[4].string_reference,&target,
10488 +              exception);
10489 +          if (attribute_flag[5] != 0)
10490 +            image->fuzz=StringToDoubleInterval(
10491 +              argument_list[5].string_reference,(double) QuantumRange+1.0);
10492 +          if (attribute_flag[6] != 0)
10493 +            channel=(ChannelType) argument_list[6].integer_reference;
10494 +          invert=MagickFalse;
10495 +          if (attribute_flag[7] != 0)
10496 +            invert=(MagickBooleanType) argument_list[7].integer_reference;
10497 +          (void) FloodfillPaintImage(image,channel,draw_info,&target,geometry.x,
10498 +            geometry.y,invert);
10499 +          draw_info=DestroyDrawInfo(draw_info);
10500 +          break;
10501 +        }
10502 +        case 112:  /* Distort */
10503 +        {
10504 +          AV
10505 +            *av;
10506 +
10507 +          double
10508 +            *coordinates;
10509 +
10510 +          DistortImageMethod
10511 +            method;
10512 +
10513 +          size_t
10514 +            number_coordinates;
10515 +
10516 +          VirtualPixelMethod
10517 +            virtual_pixel;
10518 +
10519 +          if (attribute_flag[0] == 0)
10520 +            break;
10521 +          method=UndefinedDistortion;
10522 +          if (attribute_flag[1] != 0)
10523 +            method=(DistortImageMethod) argument_list[1].integer_reference;
10524 +          av=(AV *) argument_list[0].array_reference;
10525 +          number_coordinates=(size_t) av_len(av)+1;
10526 +          coordinates=(double *) AcquireQuantumMemory(number_coordinates,
10527 +            sizeof(*coordinates));
10528 +          if (coordinates == (double *) NULL)
10529 +            {
10530 +              ThrowPerlException(exception,ResourceLimitFatalError,
10531 +                "MemoryAllocationFailed",PackageName);
10532 +              goto PerlException;
10533 +            }
10534 +          for (j=0; j < (ssize_t) number_coordinates; j++)
10535 +            coordinates[j]=(double) SvNV(*(av_fetch(av,j,0)));
10536 +          virtual_pixel=UndefinedVirtualPixelMethod;
10537 +          if (attribute_flag[2] != 0)
10538 +            virtual_pixel=SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
10539 +              argument_list[2].integer_reference);
10540 +          image=DistortImage(image,method,number_coordinates,coordinates,
10541 +            argument_list[3].integer_reference != 0 ? MagickTrue : MagickFalse,
10542 +            exception);
10543 +          if ((attribute_flag[2] != 0) && (image != (Image *) NULL))
10544 +            virtual_pixel=SetImageVirtualPixelMethod(image,virtual_pixel);
10545 +          coordinates=(double *) RelinquishMagickMemory(coordinates);
10546 +          break;
10547 +        }
10548 +        case 113:  /* Clut */
10549 +        {
10550 +          if (attribute_flag[0] == 0)
10551 +            {
10552 +              ThrowPerlException(exception,OptionError,"ClutImageRequired",
10553 +                PackageName);
10554 +              goto PerlException;
10555 +            }
10556 +          if (attribute_flag[1] != 0)
10557 +            channel=(ChannelType) argument_list[1].integer_reference;
10558 +          (void) ClutImageChannel(image,channel,
10559 +            argument_list[0].image_reference);
10560 +          break;
10561 +        }
10562 +        case 114:  /* LiquidRescale */
10563 +        {
10564 +          if (attribute_flag[0] != 0)
10565 +            flags=ParseRegionGeometry(image,argument_list[0].string_reference,
10566 +              &geometry,exception);
10567 +          if (attribute_flag[1] != 0)
10568 +            geometry.width=argument_list[1].integer_reference;
10569 +          if (attribute_flag[2] != 0)
10570 +            geometry.height=argument_list[2].integer_reference;
10571 +          if (attribute_flag[3] == 0)
10572 +            argument_list[3].real_reference=1.0;
10573 +          if (attribute_flag[4] == 0)
10574 +            argument_list[4].real_reference=0.0;
10575 +          image=LiquidRescaleImage(image,geometry.width,geometry.height,
10576 +            argument_list[3].real_reference,argument_list[4].real_reference,
10577 +            exception);
10578 +          break;
10579 +        }
10580 +        case 115:  /* EncipherImage */
10581 +        {
10582 +          (void) EncipherImage(image,argument_list[0].string_reference,
10583 +            exception);
10584 +          break;
10585 +        }
10586 +        case 116:  /* DecipherImage */
10587 +        {
10588 +          (void) DecipherImage(image,argument_list[0].string_reference,
10589 +            exception);
10590 +          break;
10591 +        }
10592 +        case 117:  /* Deskew */
10593 +        {
10594 +          geometry_info.rho=QuantumRange/2.0;
10595 +          if (attribute_flag[0] != 0)
10596 +            flags=ParseGeometry(argument_list[0].string_reference,
10597 +              &geometry_info);
10598 +          if (attribute_flag[1] != 0)
10599 +            geometry_info.rho=StringToDoubleInterval(
10600 +              argument_list[1].string_reference,(double) QuantumRange+1.0);
10601 +          image=DeskewImage(image,geometry_info.rho,exception);
10602 +          break;
10603 +        }
10604 +        case 118:  /* Remap */
10605 +        {
10606 +          QuantizeInfo
10607 +            *quantize_info;
10608 +
10609 +          if (attribute_flag[0] == 0)
10610 +            {
10611 +              ThrowPerlException(exception,OptionError,"RemapImageRequired",
10612 +                PackageName);
10613 +              goto PerlException;
10614 +            }
10615 +          quantize_info=AcquireQuantizeInfo(info->image_info);
10616 +          if (attribute_flag[1] != 0)
10617 +            quantize_info->dither=(MagickBooleanType)
10618 +              argument_list[1].integer_reference;
10619 +          if (attribute_flag[2] != 0)
10620 +            quantize_info->dither_method=(DitherMethod)
10621 +              argument_list[2].integer_reference;
10622 +          (void) RemapImages(quantize_info,image,
10623 +            argument_list[0].image_reference);
10624 +          quantize_info=DestroyQuantizeInfo(quantize_info);
10625 +          break;
10626 +        }
10627 +        case 119:  /* SparseColor */
10628 +        {
10629 +          AV
10630 +            *av;
10631 +
10632 +          double
10633 +            *coordinates;
10634 +
10635 +          SparseColorMethod
10636 +            method;
10637 +
10638 +          size_t
10639 +            number_coordinates;
10640 +
10641 +          VirtualPixelMethod
10642 +            virtual_pixel;
10643 +
10644 +          if (attribute_flag[0] == 0)
10645 +            break;
10646 +          method=UndefinedColorInterpolate;
10647 +          if (attribute_flag[1] != 0)
10648 +            method=(SparseColorMethod) argument_list[1].integer_reference;
10649 +          av=(AV *) argument_list[0].array_reference;
10650 +          number_coordinates=(size_t) av_len(av)+1;
10651 +          coordinates=(double *) AcquireQuantumMemory(number_coordinates,
10652 +            sizeof(*coordinates));
10653 +          if (coordinates == (double *) NULL)
10654 +            {
10655 +              ThrowPerlException(exception,ResourceLimitFatalError,
10656 +                "MemoryAllocationFailed",PackageName);
10657 +              goto PerlException;
10658 +            }
10659 +          for (j=0; j < (ssize_t) number_coordinates; j++)
10660 +            coordinates[j]=(double) SvNV(*(av_fetch(av,j,0)));
10661 +          virtual_pixel=UndefinedVirtualPixelMethod;
10662 +          if (attribute_flag[2] != 0)
10663 +            virtual_pixel=SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
10664 +              argument_list[2].integer_reference);
10665 +          if (attribute_flag[3] != 0)
10666 +            channel=(ChannelType) argument_list[3].integer_reference;
10667 +          image=SparseColorImage(image,channel,method,number_coordinates,
10668 +            coordinates,exception);
10669 +          if ((attribute_flag[2] != 0) && (image != (Image *) NULL))
10670 +            virtual_pixel=SetImageVirtualPixelMethod(image,virtual_pixel);
10671 +          coordinates=(double *) RelinquishMagickMemory(coordinates);
10672 +          break;
10673 +        }
10674 +        case 120:  /* Function */
10675 +        {
10676 +          AV
10677 +            *av;
10678 +
10679 +          double
10680 +            *parameters;
10681 +
10682 +          MagickFunction
10683 +            function;
10684 +
10685 +          size_t
10686 +            number_parameters;
10687 +
10688 +          VirtualPixelMethod
10689 +            virtual_pixel;
10690 +
10691 +          if (attribute_flag[0] == 0)
10692 +            break;
10693 +          function=UndefinedFunction;
10694 +          if (attribute_flag[1] != 0)
10695 +            function=(MagickFunction) argument_list[1].integer_reference;
10696 +          av=(AV *) argument_list[0].array_reference;
10697 +          number_parameters=(size_t) av_len(av)+1;
10698 +          parameters=(double *) AcquireQuantumMemory(number_parameters,
10699 +            sizeof(*parameters));
10700 +          if (parameters == (double *) NULL)
10701 +            {
10702 +              ThrowPerlException(exception,ResourceLimitFatalError,
10703 +                "MemoryAllocationFailed",PackageName);
10704 +              goto PerlException;
10705 +            }
10706 +          for (j=0; j < (ssize_t) number_parameters; j++)
10707 +            parameters[j]=(double) SvNV(*(av_fetch(av,j,0)));
10708 +          virtual_pixel=UndefinedVirtualPixelMethod;
10709 +          if (attribute_flag[2] != 0)
10710 +            virtual_pixel=SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
10711 +              argument_list[2].integer_reference);
10712 +          (void) FunctionImage(image,function,number_parameters,parameters,
10713 +            exception);
10714 +          if ((attribute_flag[2] != 0) && (image != (Image *) NULL))
10715 +            virtual_pixel=SetImageVirtualPixelMethod(image,virtual_pixel);
10716 +          parameters=(double *) RelinquishMagickMemory(parameters);
10717 +          break;
10718 +        }
10719 +        case 121:  /* SelectiveBlur */
10720 +        {
10721 +          if (attribute_flag[0] != 0)
10722 +            {
10723 +              flags=ParseGeometry(argument_list[0].string_reference,
10724 +                &geometry_info);
10725 +              if ((flags & SigmaValue) == 0)
10726 +                geometry_info.sigma=1.0;
10727 +              if ((flags & PercentValue) != 0)
10728 +                geometry_info.xi=QuantumRange*geometry_info.xi/100.0;
10729 +            }
10730 +          if (attribute_flag[1] != 0)
10731 +            geometry_info.rho=argument_list[1].real_reference;
10732 +          if (attribute_flag[2] != 0)
10733 +            geometry_info.sigma=argument_list[2].real_reference;
10734 +          if (attribute_flag[3] != 0)
10735 +            geometry_info.xi=argument_list[3].integer_reference;;
10736 +          if (attribute_flag[4] != 0)
10737 +            channel=(ChannelType) argument_list[4].integer_reference;
10738 +          image=SelectiveBlurImageChannel(image,channel,geometry_info.rho,
10739 +            geometry_info.sigma,geometry_info.xi,exception);
10740 +          break;
10741 +        }
10742 +        case 122:  /* HaldClut */
10743 +        {
10744 +          if (attribute_flag[0] == 0)
10745 +            {
10746 +              ThrowPerlException(exception,OptionError,"ClutImageRequired",
10747 +                PackageName);
10748 +              goto PerlException;
10749 +            }
10750 +          if (attribute_flag[1] != 0)
10751 +            channel=(ChannelType) argument_list[1].integer_reference;
10752 +          (void) HaldClutImageChannel(image,channel,
10753 +            argument_list[0].image_reference);
10754 +          break;
10755 +        }
10756 +        case 123:  /* BlueShift */
10757 +        {
10758 +          if (attribute_flag[0] != 0)
10759 +            (void) ParseGeometry(argument_list[0].string_reference,
10760 +              &geometry_info);
10761 +          image=BlueShiftImage(image,geometry_info.rho,exception);
10762 +          break;
10763 +        }
10764 +        case 124:  /* ForwardFourierTransformImage */
10765 +        {
10766 +          image=ForwardFourierTransformImage(image,
10767 +            argument_list[0].integer_reference != 0 ? MagickTrue : MagickFalse,
10768 +            exception);
10769 +          break;
10770 +        }
10771 +        case 125:  /* InverseFourierTransformImage */
10772 +        {
10773 +          image=InverseFourierTransformImage(image,image->next,
10774 +            argument_list[0].integer_reference != 0 ? MagickTrue : MagickFalse,
10775 +            exception);
10776 +          break;
10777 +        }
10778 +        case 126:  /* ColorDecisionList */
10779 +        {
10780 +          if (attribute_flag[0] == 0)
10781 +            argument_list[0].string_reference=(char *) NULL;
10782 +          (void) ColorDecisionListImage(image,
10783 +            argument_list[0].string_reference);
10784 +          break;
10785 +        }
10786 +        case 127:  /* AutoGamma */
10787 +        {
10788 +          if (attribute_flag[0] != 0)
10789 +            channel=(ChannelType) argument_list[0].integer_reference;
10790 +          (void) AutoGammaImageChannel(image,channel);
10791 +          break;
10792 +        }
10793 +        case 128:  /* AutoLevel */
10794 +        {
10795 +          if (attribute_flag[0] != 0)
10796 +            channel=(ChannelType) argument_list[0].integer_reference;
10797 +          (void) AutoLevelImageChannel(image,channel);
10798 +          break;
10799 +        }
10800 +        case 129:  /* LevelColors */
10801 +        {
10802 +          MagickPixelPacket
10803 +            black_point,
10804 +            white_point;
10805 +
10806 +          (void) QueryMagickColor("#000000",&black_point,exception);
10807 +          (void) QueryMagickColor("#ffffff",&white_point,exception);
10808 +          if (attribute_flag[1] != 0)
10809 +             (void) QueryMagickColor(argument_list[1].string_reference,
10810 +               &black_point,exception);
10811 +          if (attribute_flag[2] != 0)
10812 +             (void) QueryMagickColor(argument_list[2].string_reference,
10813 +               &white_point,exception);
10814 +          if (attribute_flag[3] != 0)
10815 +            channel=(ChannelType) argument_list[3].integer_reference;
10816 +          (void) LevelColorsImageChannel(image,channel,&black_point,
10817 +            &white_point,argument_list[0].integer_reference != 0 ? MagickTrue :
10818 +            MagickFalse);
10819 +          break;
10820 +        }
10821 +        case 130:  /* Clamp */
10822 +        {
10823 +          if (attribute_flag[0] != 0)
10824 +            channel=(ChannelType) argument_list[0].integer_reference;
10825 +          (void) ClampImageChannel(image,channel);
10826 +          break;
10827 +        }
10828 +        case 131:  /* Filter */
10829 +        {
10830 +          KernelInfo
10831 +            *kernel;
10832 +
10833 +          if (attribute_flag[0] == 0)
10834 +            break;
10835 +          kernel=AcquireKernelInfo(argument_list[0].string_reference);
10836 +          if (kernel == (KernelInfo *) NULL)
10837 +            break;
10838 +          if (attribute_flag[1] != 0)
10839 +            channel=(ChannelType) argument_list[1].integer_reference;
10840 +          if (attribute_flag[2] != 0)
10841 +            image->bias=StringToDoubleInterval(
10842 +              argument_list[2].string_reference,(double) QuantumRange+1.0);
10843 +          image=FilterImageChannel(image,channel,kernel,exception);
10844 +          kernel=DestroyKernelInfo(kernel);
10845 +          break;
10846 +        }
10847 +        case 132:  /* BrightnessContrast */
10848 +        {
10849 +          double
10850 +            brightness,
10851 +            contrast;
10852 +
10853 +          brightness=0.0;
10854 +          contrast=0.0;
10855 +          if (attribute_flag[0] != 0)
10856 +            {
10857 +              flags=ParseGeometry(argument_list[0].string_reference,
10858 +                &geometry_info);
10859 +              brightness=geometry_info.rho;
10860 +              if ((flags & SigmaValue) == 0)
10861 +                contrast=geometry_info.sigma;
10862 +            }
10863 +          if (attribute_flag[1] != 0)
10864 +            brightness=argument_list[1].real_reference;
10865 +          if (attribute_flag[2] != 0)
10866 +            contrast=argument_list[2].real_reference;
10867 +          if (attribute_flag[4] != 0)
10868 +            channel=(ChannelType) argument_list[4].integer_reference;
10869 +          (void) BrightnessContrastImageChannel(image,channel,brightness,
10870 +            contrast);
10871 +          break;
10872 +        }
10873 +        case 133:  /* Morphology */
10874 +        {
10875 +          KernelInfo
10876 +            *kernel;
10877 +
10878 +          MorphologyMethod
10879 +            method;
10880 +
10881 +          ssize_t
10882 +            iterations;
10883 +
10884 +          if (attribute_flag[0] == 0)
10885 +            break;
10886 +          kernel=AcquireKernelInfo(argument_list[0].string_reference);
10887 +          if (kernel == (KernelInfo *) NULL)
10888 +            break;
10889 +          if (attribute_flag[1] != 0)
10890 +            channel=(ChannelType) argument_list[1].integer_reference;
10891 +          method=UndefinedMorphology;
10892 +          if (attribute_flag[2] != 0)
10893 +            method=argument_list[2].integer_reference;
10894 +          iterations=1;
10895 +          if (attribute_flag[3] != 0)
10896 +            iterations=argument_list[3].integer_reference;
10897 +          image=MorphologyImageChannel(image,channel,method,iterations,kernel,
10898 +            exception);
10899 +          kernel=DestroyKernelInfo(kernel);
10900 +          break;
10901 +        }
10902 +        case 108:  /* Recolor */
10903 +        case 134:  /* ColorMatrix */
10904 +        {
10905 +          AV
10906 +            *av;
10907 +
10908 +          double
10909 +            *color_matrix;
10910 +
10911 +          KernelInfo
10912 +            *kernel_info;
10913 +
10914 +          size_t
10915 +            order;
10916 +
10917 +          if (attribute_flag[0] == 0)
10918 +            break;
10919 +          av=(AV *) argument_list[0].array_reference;
10920 +          order=(size_t) sqrt(av_len(av)+1);
10921 +          color_matrix=(double *) AcquireQuantumMemory(order,order*
10922 +            sizeof(*color_matrix));
10923 +          if (color_matrix == (double *) NULL)
10924 +            {
10925 +              ThrowPerlException(exception,ResourceLimitFatalError,
10926 +                "MemoryAllocationFailed",PackageName);
10927 +              goto PerlException;
10928 +           }
10929 +          for (j=0; (j < (ssize_t) (order*order)) && (j < (av_len(av)+1)); j++)
10930 +            color_matrix[j]=(double) SvNV(*(av_fetch(av,j,0)));
10931 +          for ( ; j < (ssize_t) (order*order); j++)
10932 +            color_matrix[j]=0.0;
10933 +          kernel_info=AcquireKernelInfo("1");
10934 +          if (kernel_info == (KernelInfo *) NULL)
10935 +            break;
10936 +          kernel_info->width=order;
10937 +          kernel_info->height=order;
10938 +          kernel_info->values=color_matrix;
10939 +          image=ColorMatrixImage(image,kernel_info,exception);
10940 +          kernel_info->values=(double *) NULL;
10941 +          kernel_info=DestroyKernelInfo(kernel_info);
10942 +          color_matrix=(double *) RelinquishMagickMemory(color_matrix);
10943 +          break;
10944 +        }
10945 +        case 135:  /* Color */
10946 +        {
10947 +          MagickPixelPacket
10948 +            color;
10949 +
10950 +          (void) QueryMagickColor("none",&color,exception);
10951 +          if (attribute_flag[0] != 0)
10952 +            (void) QueryMagickColor(argument_list[0].string_reference,
10953 +              &color,exception);
10954 +          (void) SetImageColor(image,&color);
10955 +          break;
10956 +        }
10957 +        case 136:  /* Mode */
10958 +        {
10959 +          if (attribute_flag[0] != 0)
10960 +            {
10961 +              flags=ParseGeometry(argument_list[0].string_reference,
10962 +                &geometry_info);
10963 +              if ((flags & SigmaValue) == 0)
10964 +                geometry_info.sigma=1.0;
10965 +            }
10966 +          if (attribute_flag[1] != 0)
10967 +            geometry_info.rho=argument_list[1].real_reference;
10968 +          if (attribute_flag[2] != 0)
10969 +            geometry_info.sigma=argument_list[2].real_reference;
10970 +          if (attribute_flag[3] != 0)
10971 +            channel=(ChannelType) argument_list[3].integer_reference;
10972 +          image=StatisticImageChannel(image,channel,ModeStatistic,
10973 +            (size_t) geometry_info.rho,(size_t) geometry_info.sigma,exception);
10974 +          break;
10975 +        }
10976 +        case 137:  /* Statistic */
10977 +        {
10978 +          StatisticType
10979 +            statistic;
10980 +
10981 +          statistic=UndefinedStatistic;
10982 +          if (attribute_flag[0] != 0)
10983 +            {
10984 +              flags=ParseGeometry(argument_list[0].string_reference,
10985 +                &geometry_info);
10986 +              if ((flags & SigmaValue) == 0)
10987 +                geometry_info.sigma=1.0;
10988 +            }
10989 +          if (attribute_flag[1] != 0)
10990 +            geometry_info.rho=argument_list[1].real_reference;
10991 +          if (attribute_flag[2] != 0)
10992 +            geometry_info.sigma=argument_list[2].real_reference;
10993 +          if (attribute_flag[3] != 0)
10994 +            channel=(ChannelType) argument_list[3].integer_reference;
10995 +          if (attribute_flag[4] != 0)
10996 +            statistic=(StatisticType) argument_list[4].integer_reference;
10997 +          image=StatisticImageChannel(image,channel,statistic,
10998 +            (size_t) geometry_info.rho,(size_t) geometry_info.sigma,exception);
10999 +          break;
11000 +        }
11001 +        case 138:  /* Perceptible */
11002 +        {
11003 +          double
11004 +            epsilon;
11005 +
11006 +          epsilon=MagickEpsilon;
11007 +          if (attribute_flag[0] != 0)
11008 +            epsilon=argument_list[0].real_reference;
11009 +          if (attribute_flag[1] != 0)
11010 +            channel=(ChannelType) argument_list[1].integer_reference;
11011 +          (void) PerceptibleImageChannel(image,channel,epsilon);
11012 +          break;
11013 +        }
11014 +        case 139:  /* Poly */
11015 +        {
11016 +          AV
11017 +            *av;
11018 +
11019 +          double
11020 +            *terms;
11021 +
11022 +          size_t
11023 +            number_terms;
11024 +
11025 +          if (attribute_flag[0] == 0)
11026 +            break;
11027 +          if (attribute_flag[1] != 0)
11028 +            channel=(ChannelType) argument_list[1].integer_reference;
11029 +          av=(AV *) argument_list[0].array_reference;
11030 +          number_terms=(size_t) av_len(av);
11031 +          terms=(double *) AcquireQuantumMemory(number_terms,sizeof(*terms));
11032 +          if (terms == (double *) NULL)
11033 +            {
11034 +              ThrowPerlException(exception,ResourceLimitFatalError,
11035 +                "MemoryAllocationFailed",PackageName);
11036 +              goto PerlException;
11037 +            }
11038 +          for (j=0; j < av_len(av); j++)
11039 +            terms[j]=(double) SvNV(*(av_fetch(av,j,0)));
11040 +          image=PolynomialImageChannel(image,channel,number_terms >> 1,terms,
11041 +            exception);
11042 +          terms=(double *) RelinquishMagickMemory(terms);
11043 +          break;
11044 +        }
11045 +        case 140:  /* Grayscale */
11046 +        {
11047 +          PixelIntensityMethod
11048 +            method;
11049 +
11050 +          method=UndefinedPixelIntensityMethod;
11051 +          if (attribute_flag[0] != 0)
11052 +            method=(PixelIntensityMethod) argument_list[0].integer_reference;
11053 +          (void) GrayscaleImage(image,method);
11054 +          break;
11055 +        }
11056 +        case 141:  /* CannyEdge */
11057 +        {
11058 +          if (attribute_flag[0] != 0)
11059 +            {
11060 +              flags=ParseGeometry(argument_list[0].string_reference,
11061 +                &geometry_info);
11062 +              if ((flags & SigmaValue) == 0)
11063 +                geometry_info.sigma=1.0;
11064 +              if ((flags & XiValue) == 0)
11065 +                geometry_info.xi=0.10;
11066 +              if ((flags & PsiValue) == 0)
11067 +                geometry_info.psi=0.30;
11068 +              if ((flags & PercentValue) != 0)
11069 +                {
11070 +                  geometry_info.xi/=100.0;
11071 +                  geometry_info.psi/=100.0;
11072 +                }
11073 +            }
11074 +          if (attribute_flag[1] != 0)
11075 +            geometry_info.rho=argument_list[1].real_reference;
11076 +          if (attribute_flag[2] != 0)
11077 +            geometry_info.sigma=argument_list[2].real_reference;
11078 +          if (attribute_flag[3] != 0)
11079 +            geometry_info.xi=argument_list[3].real_reference;
11080 +          if (attribute_flag[4] != 0)
11081 +            geometry_info.psi=argument_list[4].real_reference;
11082 +          image=CannyEdgeImage(image,geometry_info.rho,geometry_info.sigma,
11083 +            geometry_info.xi,geometry_info.psi,exception);
11084 +          break;
11085 +        }
11086 +        case 142:  /* HoughLine */
11087 +        {
11088 +          if (attribute_flag[0] != 0)
11089 +            {
11090 +              flags=ParseGeometry(argument_list[0].string_reference,
11091 +                &geometry_info);
11092 +              if ((flags & SigmaValue) == 0)
11093 +                geometry_info.sigma=geometry_info.rho;
11094 +              if ((flags & XiValue) == 0)
11095 +                geometry_info.xi=40;
11096 +            }
11097 +          if (attribute_flag[1] != 0)
11098 +            geometry_info.rho=(double) argument_list[1].integer_reference;
11099 +          if (attribute_flag[2] != 0)
11100 +            geometry_info.sigma=(double) argument_list[2].integer_reference;
11101 +          if (attribute_flag[3] != 0)
11102 +            geometry_info.xi=(double) argument_list[3].integer_reference;
11103 +          image=HoughLineImage(image,(size_t) geometry_info.rho,(size_t)
11104 +            geometry_info.sigma,(size_t) geometry_info.xi,exception);
11105 +          break;
11106 +        }
11107 +        case 143:  /* MeanShift */
11108 +        {
11109 +          if (attribute_flag[0] != 0)
11110 +            {
11111 +              flags=ParseGeometry(argument_list[0].string_reference,
11112 +                &geometry_info);
11113 +              if ((flags & SigmaValue) == 0)
11114 +                geometry_info.sigma=geometry_info.rho;
11115 +              if ((flags & XiValue) == 0)
11116 +                geometry_info.xi=0.10*QuantumRange;
11117 +              if ((flags & PercentValue) != 0)
11118 +                geometry_info.xi=QuantumRange*geometry_info.xi/100.0;
11119 +            }
11120 +          if (attribute_flag[1] != 0)
11121 +            geometry_info.rho=(double) argument_list[1].integer_reference;
11122 +          if (attribute_flag[2] != 0)
11123 +            geometry_info.sigma=(double) argument_list[2].integer_reference;
11124 +          if (attribute_flag[3] != 0)
11125 +            geometry_info.xi=(double) argument_list[3].real_reference;
11126 +          image=MeanShiftImage(image,(size_t) geometry_info.rho,(size_t)
11127 +            geometry_info.sigma,geometry_info.xi,exception);
11128 +          break;
11129 +        }
11130 +        case 144:  /* Kuwahara */
11131 +        {
11132 +          if (attribute_flag[0] != 0)
11133 +            {
11134 +              flags=ParseGeometry(argument_list[0].string_reference,
11135 +                &geometry_info);
11136 +              if ((flags & SigmaValue) == 0)
11137 +                geometry_info.sigma=geometry_info.rho-0.5;
11138 +            }
11139 +          if (attribute_flag[1] != 0)
11140 +            geometry_info.rho=argument_list[1].real_reference;
11141 +          if (attribute_flag[2] != 0)
11142 +            geometry_info.sigma=argument_list[2].real_reference;
11143 +          if (attribute_flag[3] != 0)
11144 +            channel=(ChannelType) argument_list[3].integer_reference;
11145 +          image=KuwaharaImageChannel(image,channel,geometry_info.rho,
11146 +            geometry_info.sigma,exception);
11147 +          break;
11148 +        }
11149 +        case 145:  /* ConnectedComponent */
11150 +        {
11151 +          size_t
11152 +            connectivity;
11153 +
11154 +          connectivity=4;
11155 +          if (attribute_flag[0] != 0)
11156 +            connectivity=argument_list[0].integer_reference;
11157 +          image=ConnectedComponentsImage(image,connectivity,exception);
11158 +          break;
11159 +        }
11160 +        case 146:  /* Copy */
11161 +        {
11162 +          Image
11163 +            *source_image;
11164 +
11165 +          OffsetInfo
11166 +            offset;
11167 +
11168 +          RectangleInfo
11169 +            offset_geometry;
11170 +
11171 +          source_image=image;
11172 +          if (attribute_flag[0] != 0)
11173 +            source_image=argument_list[0].image_reference;
11174 +          SetGeometry(source_image,&geometry);
11175 +          if (attribute_flag[1] != 0)
11176 +            flags=ParseGravityGeometry(source_image,
11177 +              argument_list[1].string_reference,&geometry,exception);
11178 +          if (attribute_flag[2] != 0)
11179 +            geometry.width=argument_list[2].integer_reference;
11180 +          if (attribute_flag[3] != 0)
11181 +            geometry.height=argument_list[3].integer_reference;
11182 +          if (attribute_flag[4] != 0)
11183 +            geometry.x=argument_list[4].integer_reference;
11184 +          if (attribute_flag[5] != 0)
11185 +            geometry.y=argument_list[5].integer_reference;
11186 +          if (attribute_flag[6] != 0)
11187 +            image->gravity=(GravityType) argument_list[6].integer_reference;
11188 +          SetGeometry(image,&offset_geometry);
11189 +          if (attribute_flag[7] != 0)
11190 +            flags=ParseGravityGeometry(image,argument_list[7].string_reference,
11191 +              &offset_geometry,exception);
11192 +          offset.x=offset_geometry.x;
11193 +          offset.y=offset_geometry.y;
11194 +          if (attribute_flag[8] != 0)
11195 +            offset.x=argument_list[8].integer_reference;
11196 +          if (attribute_flag[9] != 0)
11197 +            offset.y=argument_list[9].integer_reference;
11198 +          (void) CopyImagePixels(image,source_image,&geometry,&offset,
11199 +            exception);
11200 +          break;
11201 +        }
11202 +        case 147:  /* WaveletDenoise */
11203 +        {
11204 +          if (attribute_flag[0] != 0)
11205 +            {
11206 +              flags=ParseGeometry(argument_list[0].string_reference,
11207 +                &geometry_info);
11208 +              if ((flags & PercentValue) != 0)
11209 +                {
11210 +                  geometry_info.rho=QuantumRange*geometry_info.rho/100.0;
11211 +                  geometry_info.sigma=QuantumRange*geometry_info.sigma/100.0;
11212 +                }
11213 +              if ((flags & SigmaValue) == 0)
11214 +                geometry_info.sigma=0.0;
11215 +            }
11216 +          if (attribute_flag[1] != 0)
11217 +            geometry_info.rho=argument_list[1].real_reference;
11218 +          if (attribute_flag[2] != 0)
11219 +            geometry_info.sigma=argument_list[2].real_reference;
11220 +          image=WaveletDenoiseImage(image,geometry_info.rho,geometry_info.sigma,
11221 +            exception);
11222 +          break;
11223 +        }
11224 +      }
11225 +      if (next != (Image *) NULL)
11226 +        (void) CatchImageException(next);
11227 +      if (region_image != (Image *) NULL)
11228 +        {
11229 +          /*
11230 +            Composite region.
11231 +          */
11232 +          status=CompositeImage(region_image,CopyCompositeOp,image,
11233 +            region_info.x,region_info.y);
11234 +          (void) status;
11235 +          (void) CatchImageException(region_image);
11236 +          image=DestroyImage(image);
11237 +          image=region_image;
11238 +        }
11239 +      if (image != (Image *) NULL)
11240 +        {
11241 +          number_images++;
11242 +          if (next && (next != image))
11243 +            {
11244 +              image->next=next->next;
11245 +              if (image->next != (Image *) NULL)
11246 +                image->next->previous=image;
11247 +              DeleteImageFromRegistry(*pv,next);
11248 +            }
11249 +          sv_setiv(*pv,PTR2IV(image));
11250 +          next=image;
11251 +        }
11252 +      if (*pv)
11253 +        pv++;
11254 +    }
11255 +
11256 +  PerlException:
11257 +    if (reference_vector)
11258 +      reference_vector=(SV **) RelinquishMagickMemory(reference_vector);
11259 +    InheritPerlException(exception,perl_exception);
11260 +    exception=DestroyExceptionInfo(exception);
11261 +    sv_setiv(perl_exception,(IV) number_images);
11262 +    SvPOK_on(perl_exception);
11263 +    ST(0)=sv_2mortal(perl_exception);
11264 +    XSRETURN(1);
11265 +  }
11266 +\f
11267 +#
11268 +###############################################################################
11269 +#                                                                             #
11270 +#                                                                             #
11271 +#                                                                             #
11272 +#   M o n t a g e                                                             #
11273 +#                                                                             #
11274 +#                                                                             #
11275 +#                                                                             #
11276 +###############################################################################
11277 +#
11278 +#
11279 +void
11280 +Montage(ref,...)
11281 +  Image::Magick ref = NO_INIT
11282 +  ALIAS:
11283 +    MontageImage  = 1
11284 +    montage       = 2
11285 +    montageimage  = 3
11286 +  PPCODE:
11287 +  {
11288 +    AV
11289 +      *av;
11290 +
11291 +    char
11292 +      *attribute;
11293 +
11294 +    ExceptionInfo
11295 +      *exception;
11296 +
11297 +    HV
11298 +      *hv;
11299 +
11300 +    Image
11301 +      *image,
11302 +      *next;
11303 +
11304 +    MagickPixelPacket
11305 +      transparent_color;
11306 +
11307 +    MontageInfo
11308 +      *montage_info;
11309 +
11310 +    register ssize_t
11311 +      i;
11312 +
11313 +    ssize_t
11314 +      sp;
11315 +
11316 +    struct PackageInfo
11317 +      *info;
11318 +
11319 +    SV
11320 +      *av_reference,
11321 +      *perl_exception,
11322 +      *reference,
11323 +      *rv,
11324 +      *sv;
11325 +
11326 +    PERL_UNUSED_VAR(ref);
11327 +    PERL_UNUSED_VAR(ix);
11328 +    exception=AcquireExceptionInfo();
11329 +    perl_exception=newSVpv("",0);
11330 +    sv=NULL;
11331 +    attribute=NULL;
11332 +    if (sv_isobject(ST(0)) == 0)
11333 +      {
11334 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
11335 +          PackageName);
11336 +        goto PerlException;
11337 +      }
11338 +    reference=SvRV(ST(0));
11339 +    hv=SvSTASH(reference);
11340 +    av=newAV();
11341 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
11342 +    SvREFCNT_dec(av);
11343 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
11344 +    if (image == (Image *) NULL)
11345 +      {
11346 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
11347 +          PackageName);
11348 +        goto PerlException;
11349 +      }
11350 +    /*
11351 +      Get options.
11352 +    */
11353 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
11354 +    montage_info=CloneMontageInfo(info->image_info,(MontageInfo *) NULL);
11355 +    (void) QueryMagickColor("none",&transparent_color,exception);
11356 +    for (i=2; i < items; i+=2)
11357 +    {
11358 +      attribute=(char *) SvPV(ST(i-1),na);
11359 +      switch (*attribute)
11360 +      {
11361 +        case 'B':
11362 +        case 'b':
11363 +        {
11364 +          if (LocaleCompare(attribute,"background") == 0)
11365 +            {
11366 +              (void) QueryColorDatabase(SvPV(ST(i),na),
11367 +                &montage_info->background_color,exception);
11368 +              for (next=image; next; next=next->next)
11369 +                next->background_color=montage_info->background_color;
11370 +              break;
11371 +            }
11372 +          if (LocaleCompare(attribute,"border") == 0)
11373 +            {
11374 +              montage_info->border_width=SvIV(ST(i));
11375 +              break;
11376 +            }
11377 +          if (LocaleCompare(attribute,"bordercolor") == 0)
11378 +            {
11379 +              (void) QueryColorDatabase(SvPV(ST(i),na),
11380 +                &montage_info->border_color,exception);
11381 +              for (next=image; next; next=next->next)
11382 +                next->border_color=montage_info->border_color;
11383 +              break;
11384 +            }
11385 +          if (LocaleCompare(attribute,"borderwidth") == 0)
11386 +            {
11387 +              montage_info->border_width=SvIV(ST(i));
11388 +              break;
11389 +            }
11390 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11391 +            attribute);
11392 +          break;
11393 +        }
11394 +        case 'C':
11395 +        case 'c':
11396 +        {
11397 +          if (LocaleCompare(attribute,"compose") == 0)
11398 +            {
11399 +              sp=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
11400 +                MagickComposeOptions,MagickFalse,SvPV(ST(i),na));
11401 +              if (sp < 0)
11402 +                {
11403 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
11404 +                    SvPV(ST(i),na));
11405 +                  break;
11406 +                }
11407 +              for (next=image; next; next=next->next)
11408 +                next->compose=(CompositeOperator) sp;
11409 +              break;
11410 +            }
11411 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11412 +            attribute);
11413 +          break;
11414 +        }
11415 +        case 'F':
11416 +        case 'f':
11417 +        {
11418 +          if (LocaleCompare(attribute,"fill") == 0)
11419 +            {
11420 +              (void) QueryColorDatabase(SvPV(ST(i),na),&montage_info->fill,
11421 +                exception);
11422 +              break;
11423 +            }
11424 +          if (LocaleCompare(attribute,"font") == 0)
11425 +            {
11426 +              (void) CloneString(&montage_info->font,SvPV(ST(i),na));
11427 +              break;
11428 +            }
11429 +          if (LocaleCompare(attribute,"frame") == 0)
11430 +            {
11431 +              char
11432 +                *p;
11433 +
11434 +              p=SvPV(ST(i),na);
11435 +              if (IsGeometry(p) == MagickFalse)
11436 +                {
11437 +                  ThrowPerlException(exception,OptionError,"MissingGeometry",
11438 +                    p);
11439 +                  break;
11440 +                }
11441 +              (void) CloneString(&montage_info->frame,p);
11442 +              if (*p == '\0')
11443 +                montage_info->frame=(char *) NULL;
11444 +              break;
11445 +            }
11446 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11447 +            attribute);
11448 +          break;
11449 +        }
11450 +        case 'G':
11451 +        case 'g':
11452 +        {
11453 +          if (LocaleCompare(attribute,"geometry") == 0)
11454 +            {
11455 +              char
11456 +                *p;
11457 +
11458 +              p=SvPV(ST(i),na);
11459 +              if (IsGeometry(p) == MagickFalse)
11460 +                {
11461 +                  ThrowPerlException(exception,OptionError,"MissingGeometry",
11462 +                    p);
11463 +                  break;
11464 +                }
11465 +             (void) CloneString(&montage_info->geometry,p);
11466 +             if (*p == '\0')
11467 +               montage_info->geometry=(char *) NULL;
11468 +             break;
11469 +           }
11470 +         if (LocaleCompare(attribute,"gravity") == 0)
11471 +           {
11472 +             ssize_t
11473 +               in;
11474 +
11475 +             in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
11476 +               MagickGravityOptions,MagickFalse,SvPV(ST(i),na));
11477 +             if (in < 0)
11478 +               {
11479 +                 ThrowPerlException(exception,OptionError,"UnrecognizedType",
11480 +                   SvPV(ST(i),na));
11481 +                 return;
11482 +               }
11483 +             montage_info->gravity=(GravityType) in;
11484 +             for (next=image; next; next=next->next)
11485 +               next->gravity=(GravityType) in;
11486 +             break;
11487 +           }
11488 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11489 +            attribute);
11490 +          break;
11491 +        }
11492 +        case 'L':
11493 +        case 'l':
11494 +        {
11495 +          if (LocaleCompare(attribute,"label") == 0)
11496 +            {
11497 +              for (next=image; next; next=next->next)
11498 +                (void) SetImageProperty(next,"label",InterpretImageProperties(
11499 +                  info ? info->image_info : (ImageInfo *) NULL,next,
11500 +                  SvPV(ST(i),na)));
11501 +              break;
11502 +            }
11503 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11504 +            attribute);
11505 +          break;
11506 +        }
11507 +        case 'M':
11508 +        case 'm':
11509 +        {
11510 +          if (LocaleCompare(attribute,"mattecolor") == 0)
11511 +            {
11512 +              (void) QueryColorDatabase(SvPV(ST(i),na),
11513 +                &montage_info->matte_color,exception);
11514 +              for (next=image; next; next=next->next)
11515 +                next->matte_color=montage_info->matte_color;
11516 +              break;
11517 +            }
11518 +          if (LocaleCompare(attribute,"mode") == 0)
11519 +            {
11520 +              ssize_t
11521 +                in;
11522 +
11523 +              in=!SvPOK(ST(i)) ? SvIV(ST(i)) :
11524 +                ParseCommandOption(MagickModeOptions,MagickFalse,SvPV(ST(i),na));
11525 +              switch (in)
11526 +              {
11527 +                default:
11528 +                {
11529 +                  ThrowPerlException(exception,OptionError,
11530 +                    "UnrecognizedModeType",SvPV(ST(i),na));
11531 +                  break;
11532 +                }
11533 +                case FrameMode:
11534 +                {
11535 +                  (void) CloneString(&montage_info->frame,"15x15+3+3");
11536 +                  montage_info->shadow=MagickTrue;
11537 +                  break;
11538 +                }
11539 +                case UnframeMode:
11540 +                {
11541 +                  montage_info->frame=(char *) NULL;
11542 +                  montage_info->shadow=MagickFalse;
11543 +                  montage_info->border_width=0;
11544 +                  break;
11545 +                }
11546 +                case ConcatenateMode:
11547 +                {
11548 +                  montage_info->frame=(char *) NULL;
11549 +                  montage_info->shadow=MagickFalse;
11550 +                  (void) CloneString(&montage_info->geometry,"+0+0");
11551 +                  montage_info->border_width=0;
11552 +                }
11553 +              }
11554 +              break;
11555 +            }
11556 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11557 +            attribute);
11558 +          break;
11559 +        }
11560 +        case 'P':
11561 +        case 'p':
11562 +        {
11563 +          if (LocaleCompare(attribute,"pointsize") == 0)
11564 +            {
11565 +              montage_info->pointsize=SvIV(ST(i));
11566 +              break;
11567 +            }
11568 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11569 +            attribute);
11570 +          break;
11571 +        }
11572 +        case 'S':
11573 +        case 's':
11574 +        {
11575 +          if (LocaleCompare(attribute,"shadow") == 0)
11576 +            {
11577 +              sp=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseCommandOption(
11578 +                MagickBooleanOptions,MagickFalse,SvPV(ST(i),na));
11579 +              if (sp < 0)
11580 +                {
11581 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
11582 +                    SvPV(ST(i),na));
11583 +                  break;
11584 +                }
11585 +             montage_info->shadow=sp != 0 ? MagickTrue : MagickFalse;
11586 +             break;
11587 +            }
11588 +          if (LocaleCompare(attribute,"stroke") == 0)
11589 +            {
11590 +              (void) QueryColorDatabase(SvPV(ST(i),na),&montage_info->stroke,
11591 +                exception);
11592 +              break;
11593 +            }
11594 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11595 +            attribute);
11596 +          break;
11597 +        }
11598 +        case 'T':
11599 +        case 't':
11600 +        {
11601 +          if (LocaleCompare(attribute,"texture") == 0)
11602 +            {
11603 +              (void) CloneString(&montage_info->texture,SvPV(ST(i),na));
11604 +              break;
11605 +            }
11606 +          if (LocaleCompare(attribute,"tile") == 0)
11607 +            {
11608 +              char *p=SvPV(ST(i),na);
11609 +              if (IsGeometry(p) == MagickFalse)
11610 +                {
11611 +                  ThrowPerlException(exception,OptionError,"MissingGeometry",
11612 +                    p);
11613 +                  break;
11614 +                }
11615 +              (void) CloneString(&montage_info->tile,p);
11616 +              if (*p == '\0')
11617 +                montage_info->tile=(char *) NULL;
11618 +              break;
11619 +            }
11620 +          if (LocaleCompare(attribute,"title") == 0)
11621 +            {
11622 +              (void) CloneString(&montage_info->title,SvPV(ST(i),na));
11623 +              break;
11624 +            }
11625 +          if (LocaleCompare(attribute,"transparent") == 0)
11626 +            {
11627 +              MagickPixelPacket
11628 +                transparent_color;
11629 +
11630 +              QueryMagickColor(SvPV(ST(i),na),&transparent_color,exception);
11631 +              for (next=image; next; next=next->next)
11632 +                (void) TransparentPaintImage(next,&transparent_color,
11633 +                  TransparentOpacity,MagickFalse);
11634 +              break;
11635 +            }
11636 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11637 +            attribute);
11638 +          break;
11639 +        }
11640 +        default:
11641 +        {
11642 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11643 +            attribute);
11644 +          break;
11645 +        }
11646 +      }
11647 +    }
11648 +    image=MontageImageList(info->image_info,montage_info,image,exception);
11649 +    montage_info=DestroyMontageInfo(montage_info);
11650 +    if (image == (Image *) NULL)
11651 +      goto PerlException;
11652 +    if (transparent_color.opacity != TransparentOpacity)
11653 +      for (next=image; next; next=next->next)
11654 +        (void) TransparentPaintImage(next,&transparent_color,
11655 +          TransparentOpacity,MagickFalse);
11656 +    for (  ; image; image=image->next)
11657 +    {
11658 +      AddImageToRegistry(sv,image);
11659 +      rv=newRV(sv);
11660 +      av_push(av,sv_bless(rv,hv));
11661 +      SvREFCNT_dec(sv);
11662 +    }
11663 +    exception=DestroyExceptionInfo(exception);
11664 +    ST(0)=av_reference;
11665 +    SvREFCNT_dec(perl_exception);
11666 +    XSRETURN(1);
11667 +
11668 +  PerlException:
11669 +    InheritPerlException(exception,perl_exception);
11670 +    exception=DestroyExceptionInfo(exception);
11671 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
11672 +    SvPOK_on(perl_exception);
11673 +    ST(0)=sv_2mortal(perl_exception);
11674 +    XSRETURN(1);
11675 +  }
11676 +\f
11677 +#
11678 +###############################################################################
11679 +#                                                                             #
11680 +#                                                                             #
11681 +#                                                                             #
11682 +#   M o r p h                                                                 #
11683 +#                                                                             #
11684 +#                                                                             #
11685 +#                                                                             #
11686 +###############################################################################
11687 +#
11688 +#
11689 +void
11690 +Morph(ref,...)
11691 +  Image::Magick ref = NO_INIT
11692 +  ALIAS:
11693 +    MorphImage  = 1
11694 +    morph       = 2
11695 +    morphimage  = 3
11696 +  PPCODE:
11697 +  {
11698 +    AV
11699 +      *av;
11700 +
11701 +    char
11702 +      *attribute;
11703 +
11704 +    ExceptionInfo
11705 +      *exception;
11706 +
11707 +    HV
11708 +      *hv;
11709 +
11710 +    Image
11711 +      *image;
11712 +
11713 +    register ssize_t
11714 +      i;
11715 +
11716 +    ssize_t
11717 +      number_frames;
11718 +
11719 +    struct PackageInfo
11720 +      *info;
11721 +
11722 +    SV
11723 +      *av_reference,
11724 +      *perl_exception,
11725 +      *reference,
11726 +      *rv,
11727 +      *sv;
11728 +
11729 +    PERL_UNUSED_VAR(ref);
11730 +    PERL_UNUSED_VAR(ix);
11731 +    exception=AcquireExceptionInfo();
11732 +    perl_exception=newSVpv("",0);
11733 +    sv=NULL;
11734 +    av=NULL;
11735 +    attribute=NULL;
11736 +    if (sv_isobject(ST(0)) == 0)
11737 +      {
11738 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
11739 +          PackageName);
11740 +        goto PerlException;
11741 +      }
11742 +    reference=SvRV(ST(0));
11743 +    hv=SvSTASH(reference);
11744 +    av=newAV();
11745 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
11746 +    SvREFCNT_dec(av);
11747 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
11748 +    if (image == (Image *) NULL)
11749 +      {
11750 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
11751 +          PackageName);
11752 +        goto PerlException;
11753 +      }
11754 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
11755 +    /*
11756 +      Get attribute.
11757 +    */
11758 +    number_frames=30;
11759 +    for (i=2; i < items; i+=2)
11760 +    {
11761 +      attribute=(char *) SvPV(ST(i-1),na);
11762 +      switch (*attribute)
11763 +      {
11764 +        case 'F':
11765 +        case 'f':
11766 +        {
11767 +          if (LocaleCompare(attribute,"frames") == 0)
11768 +            {
11769 +              number_frames=SvIV(ST(i));
11770 +              break;
11771 +            }
11772 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11773 +            attribute);
11774 +          break;
11775 +        }
11776 +        default:
11777 +        {
11778 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
11779 +            attribute);
11780 +          break;
11781 +        }
11782 +      }
11783 +    }
11784 +    image=MorphImages(image,number_frames,exception);
11785 +    if (image == (Image *) NULL)
11786 +      goto PerlException;
11787 +    for ( ; image; image=image->next)
11788 +    {
11789 +      AddImageToRegistry(sv,image);
11790 +      rv=newRV(sv);
11791 +      av_push(av,sv_bless(rv,hv));
11792 +      SvREFCNT_dec(sv);
11793 +    }
11794 +    exception=DestroyExceptionInfo(exception);
11795 +    ST(0)=av_reference;
11796 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
11797 +    XSRETURN(1);
11798 +
11799 +  PerlException:
11800 +    InheritPerlException(exception,perl_exception);
11801 +    exception=DestroyExceptionInfo(exception);
11802 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
11803 +    SvPOK_on(perl_exception);
11804 +    ST(0)=sv_2mortal(perl_exception);
11805 +    XSRETURN(1);
11806 +  }
11807 +\f
11808 +#
11809 +###############################################################################
11810 +#                                                                             #
11811 +#                                                                             #
11812 +#                                                                             #
11813 +#   M o s a i c                                                               #
11814 +#                                                                             #
11815 +#                                                                             #
11816 +#                                                                             #
11817 +###############################################################################
11818 +#
11819 +#
11820 +void
11821 +Mosaic(ref)
11822 +  Image::Magick ref = NO_INIT
11823 +  ALIAS:
11824 +    MosaicImage   = 1
11825 +    mosaic        = 2
11826 +    mosaicimage   = 3
11827 +  PPCODE:
11828 +  {
11829 +    AV
11830 +      *av;
11831 +
11832 +    ExceptionInfo
11833 +      *exception;
11834 +
11835 +    HV
11836 +      *hv;
11837 +
11838 +    Image
11839 +      *image;
11840 +
11841 +    struct PackageInfo
11842 +      *info;
11843 +
11844 +    SV
11845 +      *perl_exception,
11846 +      *reference,
11847 +      *rv,
11848 +      *sv;
11849 +
11850 +    PERL_UNUSED_VAR(ref);
11851 +    PERL_UNUSED_VAR(ix);
11852 +    exception=AcquireExceptionInfo();
11853 +    perl_exception=newSVpv("",0);
11854 +    sv=NULL;
11855 +    if (sv_isobject(ST(0)) == 0)
11856 +      {
11857 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
11858 +          PackageName);
11859 +        goto PerlException;
11860 +      }
11861 +    reference=SvRV(ST(0));
11862 +    hv=SvSTASH(reference);
11863 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
11864 +    if (image == (Image *) NULL)
11865 +      {
11866 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
11867 +          PackageName);
11868 +        goto PerlException;
11869 +      }
11870 +    image=MergeImageLayers(image,MosaicLayer,exception);
11871 +    /*
11872 +      Create blessed Perl array for the returned image.
11873 +    */
11874 +    av=newAV();
11875 +    ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
11876 +    SvREFCNT_dec(av);
11877 +    AddImageToRegistry(sv,image);
11878 +    rv=newRV(sv);
11879 +    av_push(av,sv_bless(rv,hv));
11880 +    SvREFCNT_dec(sv);
11881 +    (void) CopyMagickString(info->image_info->filename,image->filename,
11882 +      MaxTextExtent);
11883 +    SetImageInfo(info->image_info,0,&image->exception);
11884 +    exception=DestroyExceptionInfo(exception);
11885 +    SvREFCNT_dec(perl_exception);
11886 +    XSRETURN(1);
11887 +
11888 +  PerlException:
11889 +    InheritPerlException(exception,perl_exception);
11890 +    exception=DestroyExceptionInfo(exception);
11891 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
11892 +    SvPOK_on(perl_exception);  /* return messages in string context */
11893 +    ST(0)=sv_2mortal(perl_exception);
11894 +    XSRETURN(1);
11895 +  }
11896 +\f
11897 +#
11898 +###############################################################################
11899 +#                                                                             #
11900 +#                                                                             #
11901 +#                                                                             #
11902 +#   P i n g                                                                   #
11903 +#                                                                             #
11904 +#                                                                             #
11905 +#                                                                             #
11906 +###############################################################################
11907 +#
11908 +#
11909 +void
11910 +Ping(ref,...)
11911 +  Image::Magick ref = NO_INIT
11912 +  ALIAS:
11913 +    PingImage  = 1
11914 +    ping       = 2
11915 +    pingimage  = 3
11916 +  PPCODE:
11917 +  {
11918 +    AV
11919 +      *av;
11920 +
11921 +    char
11922 +      **keep,
11923 +      **list;
11924 +
11925 +    ExceptionInfo
11926 +      *exception;
11927 +
11928 +    Image
11929 +      *image,
11930 +      *next;
11931 +
11932 +    int
11933 +      n;
11934 +
11935 +    MagickBooleanType
11936 +      status;
11937 +
11938 +    register char
11939 +      **p;
11940 +
11941 +    register ssize_t
11942 +      i;
11943 +
11944 +    ssize_t
11945 +      ac;
11946 +
11947 +    STRLEN
11948 +      *length;
11949 +
11950 +    struct PackageInfo
11951 +      *info,
11952 +      *package_info;
11953 +
11954 +    SV
11955 +      *perl_exception,
11956 +      *reference;
11957 +
11958 +    size_t
11959 +      count;
11960 +
11961 +    PERL_UNUSED_VAR(ref);
11962 +    PERL_UNUSED_VAR(ix);
11963 +    exception=AcquireExceptionInfo();
11964 +    perl_exception=newSVpv("",0);
11965 +    package_info=(struct PackageInfo *) NULL;
11966 +    ac=(items < 2) ? 1 : items-1;
11967 +    list=(char **) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*list));
11968 +    keep=list;
11969 +    length=(STRLEN *) NULL;
11970 +    if (list == (char **) NULL)
11971 +      {
11972 +        ThrowPerlException(exception,ResourceLimitError,
11973 +          "MemoryAllocationFailed",PackageName);
11974 +        goto PerlException;
11975 +      }
11976 +    keep=list;
11977 +    length=(STRLEN *) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*length));
11978 +    if (length == (STRLEN *) NULL)
11979 +      {
11980 +        ThrowPerlException(exception,ResourceLimitError,
11981 +          "MemoryAllocationFailed",PackageName);
11982 +        goto PerlException;
11983 +      }
11984 +    if (sv_isobject(ST(0)) == 0)
11985 +      {
11986 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
11987 +          PackageName);
11988 +        goto PerlException;
11989 +      }
11990 +    reference=SvRV(ST(0));
11991 +    if (SvTYPE(reference) != SVt_PVAV)
11992 +      {
11993 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
11994 +          PackageName);
11995 +        goto PerlException;
11996 +      }
11997 +    av=(AV *) reference;
11998 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
11999 +      exception);
12000 +    package_info=ClonePackageInfo(info,exception);
12001 +    n=1;
12002 +    if (items <= 1)
12003 +      *list=(char *) (*package_info->image_info->filename ?
12004 +        package_info->image_info->filename : "XC:black");
12005 +    else
12006 +      for (n=0, i=0; i < ac; i++)
12007 +      {
12008 +        list[n]=(char *) SvPV(ST(i+1),length[n]);
12009 +        if ((items >= 3) && strEQcase(list[n],"blob"))
12010 +          {
12011 +            void
12012 +              *blob;
12013 +
12014 +            i++;
12015 +            blob=(void *) (SvPV(ST(i+1),length[n]));
12016 +            SetImageInfoBlob(package_info->image_info,blob,(size_t) length[n]);
12017 +          }
12018 +        if ((items >= 3) && strEQcase(list[n],"filename"))
12019 +          continue;
12020 +        if ((items >= 3) && strEQcase(list[n],"file"))
12021 +          {
12022 +            FILE
12023 +              *file;
12024 +
12025 +            PerlIO
12026 +              *io_info;
12027 +
12028 +            i++;
12029 +            io_info=IoIFP(sv_2io(ST(i+1)));
12030 +            if (io_info == (PerlIO *) NULL)
12031 +              {
12032 +                ThrowPerlException(exception,BlobError,"UnableToOpenFile",
12033 +                  PackageName);
12034 +                continue;
12035 +              }
12036 +            file=PerlIO_findFILE(io_info);
12037 +            if (file == (FILE *) NULL)
12038 +              {
12039 +                ThrowPerlException(exception,BlobError,"UnableToOpenFile",
12040 +                  PackageName);
12041 +                continue;
12042 +              }
12043 +            SetImageInfoFile(package_info->image_info,file);
12044 +          }
12045 +        if ((items >= 3) && strEQcase(list[n],"magick"))
12046 +          continue;
12047 +        n++;
12048 +      }
12049 +    list[n]=(char *) NULL;
12050 +    keep=list;
12051 +    status=ExpandFilenames(&n,&list);
12052 +    if (status == MagickFalse)
12053 +      {
12054 +        ThrowPerlException(exception,ResourceLimitError,
12055 +          "MemoryAllocationFailed",PackageName);
12056 +        goto PerlException;
12057 +      }
12058 +    count=0;
12059 +    for (i=0; i < n; i++)
12060 +    {
12061 +      (void) CopyMagickString(package_info->image_info->filename,list[i],
12062 +        MaxTextExtent);
12063 +      image=PingImage(package_info->image_info,exception);
12064 +      if (image == (Image *) NULL)
12065 +        break;
12066 +      if ((package_info->image_info->file != (FILE *) NULL) ||
12067 +          (package_info->image_info->blob != (void *) NULL))
12068 +        DisassociateImageStream(image);
12069 +      count+=GetImageListLength(image);
12070 +      EXTEND(sp,4*count);
12071 +      for (next=image; next; next=next->next)
12072 +      {
12073 +        PUSHs(sv_2mortal(newSViv(next->columns)));
12074 +        PUSHs(sv_2mortal(newSViv(next->rows)));
12075 +        PUSHs(sv_2mortal(newSViv((size_t) GetBlobSize(next))));
12076 +        PUSHs(sv_2mortal(newSVpv(next->magick,0)));
12077 +      }
12078 +      image=DestroyImageList(image);
12079 +    }
12080 +    /*
12081 +      Free resources.
12082 +    */
12083 +    for (i=0; i < n; i++)
12084 +      if (list[i] != (char *) NULL)
12085 +        for (p=keep; list[i] != *p++; )
12086 +          if (*p == NULL)
12087 +            {
12088 +              list[i]=(char *) RelinquishMagickMemory(list[i]);
12089 +              break;
12090 +            }
12091 +
12092 +  PerlException:
12093 +    if (package_info != (struct PackageInfo *) NULL)
12094 +      DestroyPackageInfo(package_info);
12095 +    if (list && (list != keep))
12096 +      list=(char **) RelinquishMagickMemory(list);
12097 +    if (keep)
12098 +      keep=(char **) RelinquishMagickMemory(keep);
12099 +    if (length)
12100 +      length=(STRLEN *) RelinquishMagickMemory(length);
12101 +    InheritPerlException(exception,perl_exception);
12102 +    exception=DestroyExceptionInfo(exception);
12103 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
12104 +  }
12105 +\f
12106 +#
12107 +###############################################################################
12108 +#                                                                             #
12109 +#                                                                             #
12110 +#                                                                             #
12111 +#   P r e v i e w                                                             #
12112 +#                                                                             #
12113 +#                                                                             #
12114 +#                                                                             #
12115 +###############################################################################
12116 +#
12117 +#
12118 +void
12119 +Preview(ref,...)
12120 +  Image::Magick ref = NO_INIT
12121 +  ALIAS:
12122 +    PreviewImage = 1
12123 +    preview      = 2
12124 +    previewimage = 3
12125 +  PPCODE:
12126 +  {
12127 +    AV
12128 +      *av;
12129 +
12130 +    ExceptionInfo
12131 +      *exception;
12132 +
12133 +    HV
12134 +      *hv;
12135 +
12136 +    Image
12137 +      *image,
12138 +      *preview_image;
12139 +
12140 +    PreviewType
12141 +      preview_type;
12142 +
12143 +    struct PackageInfo
12144 +      *info;
12145 +
12146 +    SV
12147 +      *av_reference,
12148 +      *perl_exception,
12149 +      *reference,
12150 +      *rv,
12151 +      *sv;
12152 +
12153 +    PERL_UNUSED_VAR(ref);
12154 +    PERL_UNUSED_VAR(ix);
12155 +    exception=AcquireExceptionInfo();
12156 +    perl_exception=newSVpv("",0);
12157 +    sv=NULL;
12158 +    av=NULL;
12159 +    if (sv_isobject(ST(0)) == 0)
12160 +      {
12161 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
12162 +          PackageName);
12163 +        goto PerlException;
12164 +      }
12165 +    reference=SvRV(ST(0));
12166 +    hv=SvSTASH(reference);
12167 +    av=newAV();
12168 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
12169 +    SvREFCNT_dec(av);
12170 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
12171 +    if (image == (Image *) NULL)
12172 +      {
12173 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
12174 +          PackageName);
12175 +        goto PerlException;
12176 +      }
12177 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
12178 +    preview_type=GammaPreview;
12179 +    if (items > 1)
12180 +      preview_type=(PreviewType)
12181 +        ParseCommandOption(MagickPreviewOptions,MagickFalse,SvPV(ST(1),na));
12182 +    for ( ; image; image=image->next)
12183 +    {
12184 +      preview_image=PreviewImage(image,preview_type,exception);
12185 +      if (preview_image == (Image *) NULL)
12186 +        goto PerlException;
12187 +      AddImageToRegistry(sv,preview_image);
12188 +      rv=newRV(sv);
12189 +      av_push(av,sv_bless(rv,hv));
12190 +      SvREFCNT_dec(sv);
12191 +    }
12192 +    exception=DestroyExceptionInfo(exception);
12193 +    ST(0)=av_reference;
12194 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
12195 +    XSRETURN(1);
12196 +
12197 +  PerlException:
12198 +    InheritPerlException(exception,perl_exception);
12199 +    exception=DestroyExceptionInfo(exception);
12200 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
12201 +    SvPOK_on(perl_exception);
12202 +    ST(0)=sv_2mortal(perl_exception);
12203 +    XSRETURN(1);
12204 +  }
12205 +\f
12206 +#
12207 +###############################################################################
12208 +#                                                                             #
12209 +#                                                                             #
12210 +#                                                                             #
12211 +#   Q u e r y C o l o r                                                       #
12212 +#                                                                             #
12213 +#                                                                             #
12214 +#                                                                             #
12215 +###############################################################################
12216 +#
12217 +#
12218 +void
12219 +QueryColor(ref,...)
12220 +  Image::Magick ref = NO_INIT
12221 +  ALIAS:
12222 +    querycolor = 1
12223 +  PPCODE:
12224 +  {
12225 +    char
12226 +      *name;
12227 +
12228 +    ExceptionInfo
12229 +      *exception;
12230 +
12231 +    MagickPixelPacket
12232 +      color;
12233 +
12234 +    register ssize_t
12235 +      i;
12236 +
12237 +    SV
12238 +      *perl_exception;
12239 +
12240 +    PERL_UNUSED_VAR(ref);
12241 +    PERL_UNUSED_VAR(ix);
12242 +    exception=AcquireExceptionInfo();
12243 +    perl_exception=newSVpv("",0);
12244 +    if (items == 1)
12245 +      {
12246 +        const ColorInfo
12247 +          **colorlist;
12248 +
12249 +        size_t
12250 +          colors;
12251 +
12252 +        colorlist=GetColorInfoList("*",&colors,exception);
12253 +        EXTEND(sp,colors);
12254 +        for (i=0; i < (ssize_t) colors; i++)
12255 +        {
12256 +          PUSHs(sv_2mortal(newSVpv(colorlist[i]->name,0)));
12257 +        }
12258 +        colorlist=(const ColorInfo **)
12259 +          RelinquishMagickMemory((ColorInfo **) colorlist);
12260 +        goto PerlException;
12261 +      }
12262 +    EXTEND(sp,5*items);
12263 +    for (i=1; i < items; i++)
12264 +    {
12265 +      name=(char *) SvPV(ST(i),na);
12266 +      if (QueryMagickColor(name,&color,exception) == MagickFalse)
12267 +        {
12268 +          PUSHs(&sv_undef);
12269 +          continue;
12270 +        }
12271 +      PUSHs(sv_2mortal(newSViv((size_t) floor(color.red+0.5))));
12272 +      PUSHs(sv_2mortal(newSViv((size_t) floor(color.green+0.5))));
12273 +      PUSHs(sv_2mortal(newSViv((size_t) floor(color.blue+0.5))));
12274 +      if (color.matte != MagickFalse)
12275 +        PUSHs(sv_2mortal(newSViv((size_t) floor(color.opacity+0.5))));
12276 +      if (color.colorspace == CMYKColorspace)
12277 +        PUSHs(sv_2mortal(newSViv((size_t) floor(color.index+0.5))));
12278 +    }
12279 +
12280 +  PerlException:
12281 +    InheritPerlException(exception,perl_exception);
12282 +    exception=DestroyExceptionInfo(exception);
12283 +    SvREFCNT_dec(perl_exception);
12284 +  }
12285 +\f
12286 +#
12287 +###############################################################################
12288 +#                                                                             #
12289 +#                                                                             #
12290 +#                                                                             #
12291 +#   Q u e r y C o l o r N a m e                                               #
12292 +#                                                                             #
12293 +#                                                                             #
12294 +#                                                                             #
12295 +###############################################################################
12296 +#
12297 +#
12298 +void
12299 +QueryColorname(ref,...)
12300 +  Image::Magick ref = NO_INIT
12301 +  ALIAS:
12302 +    querycolorname = 1
12303 +  PPCODE:
12304 +  {
12305 +    AV
12306 +      *av;
12307 +
12308 +    char
12309 +      message[MaxTextExtent];
12310 +
12311 +    ExceptionInfo
12312 +      *exception;
12313 +
12314 +    Image
12315 +      *image;
12316 +
12317 +    PixelPacket
12318 +      target_color;
12319 +
12320 +    register ssize_t
12321 +      i;
12322 +
12323 +    struct PackageInfo
12324 +      *info;
12325 +
12326 +    SV
12327 +      *perl_exception,
12328 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
12329 +
12330 +    PERL_UNUSED_VAR(ref);
12331 +    PERL_UNUSED_VAR(ix);
12332 +    exception=AcquireExceptionInfo();
12333 +    perl_exception=newSVpv("",0);
12334 +    reference=SvRV(ST(0));
12335 +    av=(AV *) reference;
12336 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
12337 +      exception);
12338 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
12339 +    if (image == (Image *) NULL)
12340 +      {
12341 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
12342 +          PackageName);
12343 +        goto PerlException;
12344 +      }
12345 +    EXTEND(sp,items);
12346 +    for (i=1; i < items; i++)
12347 +    {
12348 +      (void) QueryColorDatabase(SvPV(ST(i),na),&target_color,exception);
12349 +      (void) QueryColorname(image,&target_color,SVGCompliance,message,
12350 +        exception);
12351 +      PUSHs(sv_2mortal(newSVpv(message,0)));
12352 +    }
12353 +
12354 +  PerlException:
12355 +    InheritPerlException(exception,perl_exception);
12356 +    exception=DestroyExceptionInfo(exception);
12357 +    SvREFCNT_dec(perl_exception);
12358 +  }
12359 +\f
12360 +#
12361 +###############################################################################
12362 +#                                                                             #
12363 +#                                                                             #
12364 +#                                                                             #
12365 +#   Q u e r y F o n t                                                         #
12366 +#                                                                             #
12367 +#                                                                             #
12368 +#                                                                             #
12369 +###############################################################################
12370 +#
12371 +#
12372 +void
12373 +QueryFont(ref,...)
12374 +  Image::Magick ref = NO_INIT
12375 +  ALIAS:
12376 +    queryfont = 1
12377 +  PPCODE:
12378 +  {
12379 +    char
12380 +      *name,
12381 +      message[MaxTextExtent];
12382 +
12383 +    ExceptionInfo
12384 +      *exception;
12385 +
12386 +    register ssize_t
12387 +      i;
12388 +
12389 +    SV
12390 +      *perl_exception;
12391 +
12392 +    volatile const TypeInfo
12393 +      *type_info;
12394 +
12395 +    PERL_UNUSED_VAR(ref);
12396 +    PERL_UNUSED_VAR(ix);
12397 +    exception=AcquireExceptionInfo();
12398 +    perl_exception=newSVpv("",0);
12399 +    if (items == 1)
12400 +      {
12401 +        const TypeInfo
12402 +          **typelist;
12403 +
12404 +        size_t
12405 +          types;
12406 +
12407 +        typelist=GetTypeInfoList("*",&types,exception);
12408 +        EXTEND(sp,types);
12409 +        for (i=0; i < (ssize_t) types; i++)
12410 +        {
12411 +          PUSHs(sv_2mortal(newSVpv(typelist[i]->name,0)));
12412 +        }
12413 +        typelist=(const TypeInfo **) RelinquishMagickMemory((TypeInfo **)
12414 +          typelist);
12415 +        goto PerlException;
12416 +      }
12417 +    EXTEND(sp,10*items);
12418 +    for (i=1; i < items; i++)
12419 +    {
12420 +      name=(char *) SvPV(ST(i),na);
12421 +      type_info=GetTypeInfo(name,exception);
12422 +      if (type_info == (TypeInfo *) NULL)
12423 +        {
12424 +          PUSHs(&sv_undef);
12425 +          continue;
12426 +        }
12427 +      if (type_info->name == (char *) NULL)
12428 +        PUSHs(&sv_undef);
12429 +      else
12430 +        PUSHs(sv_2mortal(newSVpv(type_info->name,0)));
12431 +      if (type_info->description == (char *) NULL)
12432 +        PUSHs(&sv_undef);
12433 +      else
12434 +        PUSHs(sv_2mortal(newSVpv(type_info->description,0)));
12435 +      if (type_info->family == (char *) NULL)
12436 +        PUSHs(&sv_undef);
12437 +      else
12438 +        PUSHs(sv_2mortal(newSVpv(type_info->family,0)));
12439 +      if (type_info->style == UndefinedStyle)
12440 +        PUSHs(&sv_undef);
12441 +      else
12442 +        PUSHs(sv_2mortal(newSVpv(CommandOptionToMnemonic(MagickStyleOptions,
12443 +          type_info->style),0)));
12444 +      if (type_info->stretch == UndefinedStretch)
12445 +        PUSHs(&sv_undef);
12446 +      else
12447 +        PUSHs(sv_2mortal(newSVpv(CommandOptionToMnemonic(MagickStretchOptions,
12448 +          type_info->stretch),0)));
12449 +      (void) FormatLocaleString(message,MaxTextExtent,"%.20g",(double)
12450 +        type_info->weight);
12451 +      PUSHs(sv_2mortal(newSVpv(message,0)));
12452 +      if (type_info->encoding == (char *) NULL)
12453 +        PUSHs(&sv_undef);
12454 +      else
12455 +        PUSHs(sv_2mortal(newSVpv(type_info->encoding,0)));
12456 +      if (type_info->foundry == (char *) NULL)
12457 +        PUSHs(&sv_undef);
12458 +      else
12459 +        PUSHs(sv_2mortal(newSVpv(type_info->foundry,0)));
12460 +      if (type_info->format == (char *) NULL)
12461 +        PUSHs(&sv_undef);
12462 +      else
12463 +        PUSHs(sv_2mortal(newSVpv(type_info->format,0)));
12464 +      if (type_info->metrics == (char *) NULL)
12465 +        PUSHs(&sv_undef);
12466 +      else
12467 +        PUSHs(sv_2mortal(newSVpv(type_info->metrics,0)));
12468 +      if (type_info->glyphs == (char *) NULL)
12469 +        PUSHs(&sv_undef);
12470 +      else
12471 +        PUSHs(sv_2mortal(newSVpv(type_info->glyphs,0)));
12472 +    }
12473 +
12474 +  PerlException:
12475 +    InheritPerlException(exception,perl_exception);
12476 +    exception=DestroyExceptionInfo(exception);
12477 +    SvREFCNT_dec(perl_exception);
12478 +  }
12479 +\f
12480 +#
12481 +###############################################################################
12482 +#                                                                             #
12483 +#                                                                             #
12484 +#                                                                             #
12485 +#   Q u e r y F o n t M e t r i c s                                           #
12486 +#                                                                             #
12487 +#                                                                             #
12488 +#                                                                             #
12489 +###############################################################################
12490 +#
12491 +#
12492 +void
12493 +QueryFontMetrics(ref,...)
12494 +  Image::Magick ref = NO_INIT
12495 +  ALIAS:
12496 +    queryfontmetrics = 1
12497 +  PPCODE:
12498 +  {
12499 +    AffineMatrix
12500 +      affine,
12501 +      current;
12502 +
12503 +    AV
12504 +      *av;
12505 +
12506 +    char
12507 +      *attribute;
12508 +
12509 +    double
12510 +      x,
12511 +      y;
12512 +
12513 +    DrawInfo
12514 +      *draw_info;
12515 +
12516 +    ExceptionInfo
12517 +      *exception;
12518 +
12519 +    GeometryInfo
12520 +      geometry_info;
12521 +
12522 +    Image
12523 +      *image;
12524 +
12525 +    MagickBooleanType
12526 +      status;
12527 +
12528 +    MagickStatusType
12529 +      flags;
12530 +
12531 +    register ssize_t
12532 +      i;
12533 +
12534 +    ssize_t
12535 +      type;
12536 +
12537 +    struct PackageInfo
12538 +      *info,
12539 +      *package_info;
12540 +
12541 +    SV
12542 +      *perl_exception,
12543 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
12544 +
12545 +    TypeMetric
12546 +      metrics;
12547 +
12548 +    PERL_UNUSED_VAR(ref);
12549 +    PERL_UNUSED_VAR(ix);
12550 +    exception=AcquireExceptionInfo();
12551 +    package_info=(struct PackageInfo *) NULL;
12552 +    perl_exception=newSVpv("",0);
12553 +    reference=SvRV(ST(0));
12554 +    av=(AV *) reference;
12555 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
12556 +      exception);
12557 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
12558 +    if (image == (Image *) NULL)
12559 +      {
12560 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
12561 +          PackageName);
12562 +        goto PerlException;
12563 +      }
12564 +    package_info=ClonePackageInfo(info,exception);
12565 +    draw_info=CloneDrawInfo(package_info->image_info,(DrawInfo *) NULL);
12566 +    CloneString(&draw_info->text,"");
12567 +    current=draw_info->affine;
12568 +    GetAffineMatrix(&affine);
12569 +    x=0.0;
12570 +    y=0.0;
12571 +    EXTEND(sp,7*items);
12572 +    for (i=2; i < items; i+=2)
12573 +    {
12574 +      attribute=(char *) SvPV(ST(i-1),na);
12575 +      switch (*attribute)
12576 +      {
12577 +        case 'A':
12578 +        case 'a':
12579 +        {
12580 +          if (LocaleCompare(attribute,"antialias") == 0)
12581 +            {
12582 +              type=ParseCommandOption(MagickBooleanOptions,MagickFalse,
12583 +                SvPV(ST(i),na));
12584 +              if (type < 0)
12585 +                {
12586 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
12587 +                    SvPV(ST(i),na));
12588 +                  break;
12589 +                }
12590 +              draw_info->text_antialias=type != 0 ? MagickTrue : MagickFalse;
12591 +              break;
12592 +            }
12593 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12594 +            attribute);
12595 +          break;
12596 +        }
12597 +        case 'd':
12598 +        case 'D':
12599 +        {
12600 +          if (LocaleCompare(attribute,"density") == 0)
12601 +            {
12602 +              CloneString(&draw_info->density,SvPV(ST(i),na));
12603 +              break;
12604 +            }
12605 +          if (LocaleCompare(attribute,"direction") == 0)
12606 +            {
12607 +              draw_info->direction=(DirectionType) ParseCommandOption(
12608 +                MagickDirectionOptions,MagickFalse,SvPV(ST(i),na));
12609 +              break;
12610 +            }
12611 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12612 +            attribute);
12613 +          break;
12614 +        }
12615 +        case 'e':
12616 +        case 'E':
12617 +        {
12618 +          if (LocaleCompare(attribute,"encoding") == 0)
12619 +            {
12620 +              CloneString(&draw_info->encoding,SvPV(ST(i),na));
12621 +              break;
12622 +            }
12623 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12624 +            attribute);
12625 +          break;
12626 +        }
12627 +        case 'f':
12628 +        case 'F':
12629 +        {
12630 +          if (LocaleCompare(attribute,"family") == 0)
12631 +            {
12632 +              CloneString(&draw_info->family,SvPV(ST(i),na));
12633 +              break;
12634 +            }
12635 +          if (LocaleCompare(attribute,"fill") == 0)
12636 +            {
12637 +              if (info)
12638 +                (void) QueryColorDatabase(SvPV(ST(i),na),&draw_info->fill,
12639 +                  &image->exception);
12640 +              break;
12641 +            }
12642 +          if (LocaleCompare(attribute,"font") == 0)
12643 +            {
12644 +              CloneString(&draw_info->font,SvPV(ST(i),na));
12645 +              break;
12646 +            }
12647 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12648 +            attribute);
12649 +          break;
12650 +        }
12651 +        case 'g':
12652 +        case 'G':
12653 +        {
12654 +          if (LocaleCompare(attribute,"geometry") == 0)
12655 +            {
12656 +              CloneString(&draw_info->geometry,SvPV(ST(i),na));
12657 +              break;
12658 +            }
12659 +          if (LocaleCompare(attribute,"gravity") == 0)
12660 +            {
12661 +              draw_info->gravity=(GravityType) ParseCommandOption(
12662 +                MagickGravityOptions,MagickFalse,SvPV(ST(i),na));
12663 +              break;
12664 +            }
12665 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12666 +            attribute);
12667 +          break;
12668 +        }
12669 +        case 'i':
12670 +        case 'I':
12671 +        {
12672 +          if (LocaleCompare(attribute,"interline-spacing") == 0)
12673 +            {
12674 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12675 +              draw_info->interline_spacing=geometry_info.rho;
12676 +              break;
12677 +            }
12678 +          if (LocaleCompare(attribute,"interword-spacing") == 0)
12679 +            {
12680 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12681 +              draw_info->interword_spacing=geometry_info.rho;
12682 +              break;
12683 +            }
12684 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12685 +            attribute);
12686 +          break;
12687 +        }
12688 +        case 'k':
12689 +        case 'K':
12690 +        {
12691 +          if (LocaleCompare(attribute,"kerning") == 0)
12692 +            {
12693 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12694 +              draw_info->kerning=geometry_info.rho;
12695 +              break;
12696 +            }
12697 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12698 +            attribute);
12699 +          break;
12700 +        }
12701 +        case 'p':
12702 +        case 'P':
12703 +        {
12704 +          if (LocaleCompare(attribute,"pointsize") == 0)
12705 +            {
12706 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12707 +              draw_info->pointsize=geometry_info.rho;
12708 +              break;
12709 +            }
12710 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12711 +            attribute);
12712 +          break;
12713 +        }
12714 +        case 'r':
12715 +        case 'R':
12716 +        {
12717 +          if (LocaleCompare(attribute,"rotate") == 0)
12718 +            {
12719 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12720 +              affine.rx=geometry_info.rho;
12721 +              affine.ry=geometry_info.sigma;
12722 +              if ((flags & SigmaValue) == 0)
12723 +                affine.ry=affine.rx;
12724 +              break;
12725 +            }
12726 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12727 +            attribute);
12728 +          break;
12729 +        }
12730 +        case 's':
12731 +        case 'S':
12732 +        {
12733 +          if (LocaleCompare(attribute,"scale") == 0)
12734 +            {
12735 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12736 +              affine.sx=geometry_info.rho;
12737 +              affine.sy=geometry_info.sigma;
12738 +              if ((flags & SigmaValue) == 0)
12739 +                affine.sy=affine.sx;
12740 +              break;
12741 +            }
12742 +          if (LocaleCompare(attribute,"skew") == 0)
12743 +            {
12744 +              double
12745 +                x_angle,
12746 +                y_angle;
12747 +
12748 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12749 +              x_angle=geometry_info.rho;
12750 +              y_angle=geometry_info.sigma;
12751 +              if ((flags & SigmaValue) == 0)
12752 +                y_angle=x_angle;
12753 +              affine.ry=tan(DegreesToRadians(fmod(x_angle,360.0)));
12754 +              affine.rx=tan(DegreesToRadians(fmod(y_angle,360.0)));
12755 +              break;
12756 +            }
12757 +          if (LocaleCompare(attribute,"stroke") == 0)
12758 +            {
12759 +              if (info)
12760 +                (void) QueryColorDatabase(SvPV(ST(i),na),&draw_info->stroke,
12761 +                  &image->exception);
12762 +              break;
12763 +            }
12764 +          if (LocaleCompare(attribute,"style") == 0)
12765 +            {
12766 +              type=ParseCommandOption(MagickStyleOptions,MagickFalse,
12767 +                SvPV(ST(i),na));
12768 +              if (type < 0)
12769 +                {
12770 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
12771 +                    SvPV(ST(i),na));
12772 +                  break;
12773 +                }
12774 +              draw_info->style=(StyleType) type;
12775 +              break;
12776 +            }
12777 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12778 +            attribute);
12779 +          break;
12780 +        }
12781 +        case 't':
12782 +        case 'T':
12783 +        {
12784 +          if (LocaleCompare(attribute,"text") == 0)
12785 +            {
12786 +              CloneString(&draw_info->text,SvPV(ST(i),na));
12787 +              break;
12788 +            }
12789 +          if (LocaleCompare(attribute,"translate") == 0)
12790 +            {
12791 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12792 +              affine.tx=geometry_info.rho;
12793 +              affine.ty=geometry_info.sigma;
12794 +              if ((flags & SigmaValue) == 0)
12795 +                affine.ty=affine.tx;
12796 +              break;
12797 +            }
12798 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12799 +            attribute);
12800 +          break;
12801 +        }
12802 +        case 'w':
12803 +        case 'W':
12804 +        {
12805 +          if (LocaleCompare(attribute,"weight") == 0)
12806 +            {
12807 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12808 +              draw_info->weight=(size_t) geometry_info.rho;
12809 +              break;
12810 +            }
12811 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12812 +            attribute);
12813 +          break;
12814 +        }
12815 +        case 'x':
12816 +        case 'X':
12817 +        {
12818 +          if (LocaleCompare(attribute,"x") == 0)
12819 +            {
12820 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12821 +              x=geometry_info.rho;
12822 +              break;
12823 +            }
12824 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12825 +            attribute);
12826 +          break;
12827 +        }
12828 +        case 'y':
12829 +        case 'Y':
12830 +        {
12831 +          if (LocaleCompare(attribute,"y") == 0)
12832 +            {
12833 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
12834 +              y=geometry_info.rho;
12835 +              break;
12836 +            }
12837 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12838 +            attribute);
12839 +          break;
12840 +        }
12841 +        default:
12842 +        {
12843 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
12844 +            attribute);
12845 +          break;
12846 +        }
12847 +      }
12848 +    }
12849 +    draw_info->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
12850 +    draw_info->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
12851 +    draw_info->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
12852 +    draw_info->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
12853 +    draw_info->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
12854 +    draw_info->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
12855 +    if (draw_info->geometry == (char *) NULL)
12856 +      {
12857 +        draw_info->geometry=AcquireString((char *) NULL);
12858 +        (void) FormatLocaleString(draw_info->geometry,MaxTextExtent,
12859 +          "%.15g,%.15g",x,y);
12860 +      }
12861 +    status=GetTypeMetrics(image,draw_info,&metrics);
12862 +    (void) CatchImageException(image);
12863 +    if (status == MagickFalse)
12864 +      PUSHs(&sv_undef);
12865 +    else
12866 +      {
12867 +        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.x)));
12868 +        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.y)));
12869 +        PUSHs(sv_2mortal(newSVnv(metrics.ascent)));
12870 +        PUSHs(sv_2mortal(newSVnv(metrics.descent)));
12871 +        PUSHs(sv_2mortal(newSVnv(metrics.width)));
12872 +        PUSHs(sv_2mortal(newSVnv(metrics.height)));
12873 +        PUSHs(sv_2mortal(newSVnv(metrics.max_advance)));
12874 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x1)));
12875 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y1)));
12876 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x2)));
12877 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y2)));
12878 +        PUSHs(sv_2mortal(newSVnv(metrics.origin.x)));
12879 +        PUSHs(sv_2mortal(newSVnv(metrics.origin.y)));
12880 +      }
12881 +    draw_info=DestroyDrawInfo(draw_info);
12882 +
12883 +  PerlException:
12884 +    if (package_info != (struct PackageInfo *) NULL)
12885 +      DestroyPackageInfo(package_info);
12886 +    InheritPerlException(exception,perl_exception);
12887 +    exception=DestroyExceptionInfo(exception);
12888 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
12889 +  }
12890 +\f
12891 +#
12892 +###############################################################################
12893 +#                                                                             #
12894 +#                                                                             #
12895 +#                                                                             #
12896 +#   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                         #
12897 +#                                                                             #
12898 +#                                                                             #
12899 +#                                                                             #
12900 +###############################################################################
12901 +#
12902 +#
12903 +void
12904 +QueryMultilineFontMetrics(ref,...)
12905 +  Image::Magick ref = NO_INIT
12906 +  ALIAS:
12907 +    querymultilinefontmetrics = 1
12908 +  PPCODE:
12909 +  {
12910 +    AffineMatrix
12911 +      affine,
12912 +      current;
12913 +
12914 +    AV
12915 +      *av;
12916 +
12917 +    char
12918 +      *attribute;
12919 +
12920 +    double
12921 +      x,
12922 +      y;
12923 +
12924 +    DrawInfo
12925 +      *draw_info;
12926 +
12927 +    ExceptionInfo
12928 +      *exception;
12929 +
12930 +    GeometryInfo
12931 +      geometry_info;
12932 +
12933 +    Image
12934 +      *image;
12935 +
12936 +    MagickBooleanType
12937 +      status;
12938 +
12939 +    MagickStatusType
12940 +      flags;
12941 +
12942 +    register ssize_t
12943 +      i;
12944 +
12945 +    ssize_t
12946 +      type;
12947 +
12948 +    struct PackageInfo
12949 +      *info,
12950 +      *package_info;
12951 +
12952 +    SV
12953 +      *perl_exception,
12954 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
12955 +
12956 +    TypeMetric
12957 +      metrics;
12958 +
12959 +    PERL_UNUSED_VAR(ref);
12960 +    PERL_UNUSED_VAR(ix);
12961 +    exception=AcquireExceptionInfo();
12962 +    package_info=(struct PackageInfo *) NULL;
12963 +    perl_exception=newSVpv("",0);
12964 +    reference=SvRV(ST(0));
12965 +    av=(AV *) reference;
12966 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
12967 +      exception);
12968 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
12969 +    if (image == (Image *) NULL)
12970 +      {
12971 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
12972 +          PackageName);
12973 +        goto PerlException;
12974 +      }
12975 +    package_info=ClonePackageInfo(info,exception);
12976 +    draw_info=CloneDrawInfo(package_info->image_info,(DrawInfo *) NULL);
12977 +    CloneString(&draw_info->text,"");
12978 +    current=draw_info->affine;
12979 +    GetAffineMatrix(&affine);
12980 +    x=0.0;
12981 +    y=0.0;
12982 +    EXTEND(sp,7*items);
12983 +    for (i=2; i < items; i+=2)
12984 +    {
12985 +      attribute=(char *) SvPV(ST(i-1),na);
12986 +      switch (*attribute)
12987 +      {
12988 +        case 'A':
12989 +        case 'a':
12990 +        {
12991 +          if (LocaleCompare(attribute,"antialias") == 0)
12992 +            {
12993 +              type=ParseCommandOption(MagickBooleanOptions,MagickFalse,
12994 +                SvPV(ST(i),na));
12995 +              if (type < 0)
12996 +                {
12997 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
12998 +                    SvPV(ST(i),na));
12999 +                  break;
13000 +                }
13001 +              draw_info->text_antialias=type != 0 ? MagickTrue : MagickFalse;
13002 +              break;
13003 +            }
13004 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13005 +            attribute);
13006 +          break;
13007 +        }
13008 +        case 'd':
13009 +        case 'D':
13010 +        {
13011 +          if (LocaleCompare(attribute,"density") == 0)
13012 +            {
13013 +              CloneString(&draw_info->density,SvPV(ST(i),na));
13014 +              break;
13015 +            }
13016 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13017 +            attribute);
13018 +          break;
13019 +        }
13020 +        case 'e':
13021 +        case 'E':
13022 +        {
13023 +          if (LocaleCompare(attribute,"encoding") == 0)
13024 +            {
13025 +              CloneString(&draw_info->encoding,SvPV(ST(i),na));
13026 +              break;
13027 +            }
13028 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13029 +            attribute);
13030 +          break;
13031 +        }
13032 +        case 'f':
13033 +        case 'F':
13034 +        {
13035 +          if (LocaleCompare(attribute,"family") == 0)
13036 +            {
13037 +              CloneString(&draw_info->family,SvPV(ST(i),na));
13038 +              break;
13039 +            }
13040 +          if (LocaleCompare(attribute,"fill") == 0)
13041 +            {
13042 +              if (info)
13043 +                (void) QueryColorDatabase(SvPV(ST(i),na),&draw_info->fill,
13044 +                  &image->exception);
13045 +              break;
13046 +            }
13047 +          if (LocaleCompare(attribute,"font") == 0)
13048 +            {
13049 +              CloneString(&draw_info->font,SvPV(ST(i),na));
13050 +              break;
13051 +            }
13052 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13053 +            attribute);
13054 +          break;
13055 +        }
13056 +        case 'g':
13057 +        case 'G':
13058 +        {
13059 +          if (LocaleCompare(attribute,"geometry") == 0)
13060 +            {
13061 +              CloneString(&draw_info->geometry,SvPV(ST(i),na));
13062 +              break;
13063 +            }
13064 +          if (LocaleCompare(attribute,"gravity") == 0)
13065 +            {
13066 +              draw_info->gravity=(GravityType) ParseCommandOption(
13067 +                MagickGravityOptions,MagickFalse,SvPV(ST(i),na));
13068 +              break;
13069 +            }
13070 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13071 +            attribute);
13072 +          break;
13073 +        }
13074 +        case 'p':
13075 +        case 'P':
13076 +        {
13077 +          if (LocaleCompare(attribute,"pointsize") == 0)
13078 +            {
13079 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13080 +              draw_info->pointsize=geometry_info.rho;
13081 +              break;
13082 +            }
13083 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13084 +            attribute);
13085 +          break;
13086 +        }
13087 +        case 'r':
13088 +        case 'R':
13089 +        {
13090 +          if (LocaleCompare(attribute,"rotate") == 0)
13091 +            {
13092 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13093 +              affine.rx=geometry_info.rho;
13094 +              affine.ry=geometry_info.sigma;
13095 +              if ((flags & SigmaValue) == 0)
13096 +                affine.ry=affine.rx;
13097 +              break;
13098 +            }
13099 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13100 +            attribute);
13101 +          break;
13102 +        }
13103 +        case 's':
13104 +        case 'S':
13105 +        {
13106 +          if (LocaleCompare(attribute,"scale") == 0)
13107 +            {
13108 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13109 +              affine.sx=geometry_info.rho;
13110 +              affine.sy=geometry_info.sigma;
13111 +              if ((flags & SigmaValue) == 0)
13112 +                affine.sy=affine.sx;
13113 +              break;
13114 +            }
13115 +          if (LocaleCompare(attribute,"skew") == 0)
13116 +            {
13117 +              double
13118 +                x_angle,
13119 +                y_angle;
13120 +
13121 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13122 +              x_angle=geometry_info.rho;
13123 +              y_angle=geometry_info.sigma;
13124 +              if ((flags & SigmaValue) == 0)
13125 +                y_angle=x_angle;
13126 +              affine.ry=tan(DegreesToRadians(fmod(x_angle,360.0)));
13127 +              affine.rx=tan(DegreesToRadians(fmod(y_angle,360.0)));
13128 +              break;
13129 +            }
13130 +          if (LocaleCompare(attribute,"stroke") == 0)
13131 +            {
13132 +              if (info)
13133 +                (void) QueryColorDatabase(SvPV(ST(i),na),&draw_info->stroke,
13134 +                  &image->exception);
13135 +              break;
13136 +            }
13137 +          if (LocaleCompare(attribute,"style") == 0)
13138 +            {
13139 +              type=ParseCommandOption(MagickStyleOptions,MagickFalse,
13140 +                SvPV(ST(i),na));
13141 +              if (type < 0)
13142 +                {
13143 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
13144 +                    SvPV(ST(i),na));
13145 +                  break;
13146 +                }
13147 +              draw_info->style=(StyleType) type;
13148 +              break;
13149 +            }
13150 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13151 +            attribute);
13152 +          break;
13153 +        }
13154 +        case 't':
13155 +        case 'T':
13156 +        {
13157 +          if (LocaleCompare(attribute,"text") == 0)
13158 +            {
13159 +              CloneString(&draw_info->text,SvPV(ST(i),na));
13160 +              break;
13161 +            }
13162 +          if (LocaleCompare(attribute,"translate") == 0)
13163 +            {
13164 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13165 +              affine.tx=geometry_info.rho;
13166 +              affine.ty=geometry_info.sigma;
13167 +              if ((flags & SigmaValue) == 0)
13168 +                affine.ty=affine.tx;
13169 +              break;
13170 +            }
13171 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13172 +            attribute);
13173 +          break;
13174 +        }
13175 +        case 'w':
13176 +        case 'W':
13177 +        {
13178 +          if (LocaleCompare(attribute,"weight") == 0)
13179 +            {
13180 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13181 +              draw_info->weight=(size_t) geometry_info.rho;
13182 +              break;
13183 +            }
13184 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13185 +            attribute);
13186 +          break;
13187 +        }
13188 +        case 'x':
13189 +        case 'X':
13190 +        {
13191 +          if (LocaleCompare(attribute,"x") == 0)
13192 +            {
13193 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13194 +              x=geometry_info.rho;
13195 +              break;
13196 +            }
13197 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13198 +            attribute);
13199 +          break;
13200 +        }
13201 +        case 'y':
13202 +        case 'Y':
13203 +        {
13204 +          if (LocaleCompare(attribute,"y") == 0)
13205 +            {
13206 +              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
13207 +              y=geometry_info.rho;
13208 +              break;
13209 +            }
13210 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13211 +            attribute);
13212 +          break;
13213 +        }
13214 +        default:
13215 +        {
13216 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13217 +            attribute);
13218 +          break;
13219 +        }
13220 +      }
13221 +    }
13222 +    draw_info->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
13223 +    draw_info->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
13224 +    draw_info->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
13225 +    draw_info->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
13226 +    draw_info->affine.tx=current.sx*affine.tx+current.ry*affine.ty+current.tx;
13227 +    draw_info->affine.ty=current.rx*affine.tx+current.sy*affine.ty+current.ty;
13228 +    if (draw_info->geometry == (char *) NULL)
13229 +      {
13230 +        draw_info->geometry=AcquireString((char *) NULL);
13231 +        (void) FormatLocaleString(draw_info->geometry,MaxTextExtent,
13232 +          "%.15g,%.15g",x,y);
13233 +      }
13234 +    status=GetMultilineTypeMetrics(image,draw_info,&metrics);
13235 +    (void) CatchImageException(image);
13236 +    if (status == MagickFalse)
13237 +      PUSHs(&sv_undef);
13238 +    else
13239 +      {
13240 +        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.x)));
13241 +        PUSHs(sv_2mortal(newSVnv(metrics.pixels_per_em.y)));
13242 +        PUSHs(sv_2mortal(newSVnv(metrics.ascent)));
13243 +        PUSHs(sv_2mortal(newSVnv(metrics.descent)));
13244 +        PUSHs(sv_2mortal(newSVnv(metrics.width)));
13245 +        PUSHs(sv_2mortal(newSVnv(metrics.height)));
13246 +        PUSHs(sv_2mortal(newSVnv(metrics.max_advance)));
13247 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x1)));
13248 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y1)));
13249 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.x2)));
13250 +        PUSHs(sv_2mortal(newSVnv(metrics.bounds.y2)));
13251 +        PUSHs(sv_2mortal(newSVnv(metrics.origin.x)));
13252 +        PUSHs(sv_2mortal(newSVnv(metrics.origin.y)));
13253 +      }
13254 +    draw_info=DestroyDrawInfo(draw_info);
13255 +
13256 +  PerlException:
13257 +    if (package_info != (struct PackageInfo *) NULL)
13258 +      DestroyPackageInfo(package_info);
13259 +    InheritPerlException(exception,perl_exception);
13260 +    exception=DestroyExceptionInfo(exception);
13261 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
13262 +  }
13263 +\f
13264 +#
13265 +###############################################################################
13266 +#                                                                             #
13267 +#                                                                             #
13268 +#                                                                             #
13269 +#   Q u e r y F o r m a t                                                     #
13270 +#                                                                             #
13271 +#                                                                             #
13272 +#                                                                             #
13273 +###############################################################################
13274 +#
13275 +#
13276 +void
13277 +QueryFormat(ref,...)
13278 +  Image::Magick ref = NO_INIT
13279 +  ALIAS:
13280 +    queryformat = 1
13281 +  PPCODE:
13282 +  {
13283 +    char
13284 +      *name;
13285 +
13286 +    ExceptionInfo
13287 +      *exception;
13288 +
13289 +    register ssize_t
13290 +      i;
13291 +
13292 +    SV
13293 +      *perl_exception;
13294 +
13295 +    volatile const MagickInfo
13296 +      *magick_info;
13297 +
13298 +    PERL_UNUSED_VAR(ref);
13299 +    PERL_UNUSED_VAR(ix);
13300 +    exception=AcquireExceptionInfo();
13301 +    perl_exception=newSVpv("",0);
13302 +    if (items == 1)
13303 +      {
13304 +        char
13305 +          format[MaxTextExtent];
13306 +
13307 +        const MagickInfo
13308 +          **format_list;
13309 +
13310 +        size_t
13311 +          types;
13312 +
13313 +        format_list=GetMagickInfoList("*",&types,exception);
13314 +        EXTEND(sp,types);
13315 +        for (i=0; i < (ssize_t) types; i++)
13316 +        {
13317 +          (void) CopyMagickString(format,format_list[i]->name,MaxTextExtent);
13318 +          LocaleLower(format);
13319 +          PUSHs(sv_2mortal(newSVpv(format,0)));
13320 +        }
13321 +        format_list=(const MagickInfo **)
13322 +          RelinquishMagickMemory((MagickInfo *) format_list);
13323 +        goto PerlException;
13324 +      }
13325 +    EXTEND(sp,8*items);
13326 +    for (i=1; i < items; i++)
13327 +    {
13328 +      name=(char *) SvPV(ST(i),na);
13329 +      magick_info=GetMagickInfo(name,exception);
13330 +      if (magick_info == (const MagickInfo *) NULL)
13331 +        {
13332 +          PUSHs(&sv_undef);
13333 +          continue;
13334 +        }
13335 +      PUSHs(sv_2mortal(newSViv(magick_info->adjoin)));
13336 +      PUSHs(sv_2mortal(newSViv(magick_info->blob_support)));
13337 +      PUSHs(sv_2mortal(newSViv(magick_info->raw)));
13338 +      PUSHs(sv_2mortal(newSViv((long) magick_info->decoder)));
13339 +      PUSHs(sv_2mortal(newSViv((long) magick_info->encoder)));
13340 +      if (magick_info->description == (char *) NULL)
13341 +        PUSHs(&sv_undef);
13342 +      else
13343 +        PUSHs(sv_2mortal(newSVpv(magick_info->description,0)));
13344 +      if (magick_info->module == (char *) NULL)
13345 +        PUSHs(&sv_undef);
13346 +      else
13347 +        PUSHs(sv_2mortal(newSVpv(magick_info->module,0)));
13348 +    }
13349 +
13350 +  PerlException:
13351 +    InheritPerlException(exception,perl_exception);
13352 +    exception=DestroyExceptionInfo(exception);
13353 +    SvREFCNT_dec(perl_exception);
13354 +  }
13355 +\f
13356 +#
13357 +###############################################################################
13358 +#                                                                             #
13359 +#                                                                             #
13360 +#                                                                             #
13361 +#   Q u e r y O p t i o n                                                     #
13362 +#                                                                             #
13363 +#                                                                             #
13364 +#                                                                             #
13365 +###############################################################################
13366 +#
13367 +#
13368 +void
13369 +QueryOption(ref,...)
13370 +  Image::Magick ref = NO_INIT
13371 +  ALIAS:
13372 +    queryoption = 1
13373 +  PPCODE:
13374 +  {
13375 +    char
13376 +      **options;
13377 +
13378 +    ExceptionInfo
13379 +      *exception;
13380 +
13381 +    register ssize_t
13382 +      i;
13383 +
13384 +    ssize_t
13385 +      j,
13386 +      option;
13387 +
13388 +    SV
13389 +      *perl_exception;
13390 +
13391 +    PERL_UNUSED_VAR(ref);
13392 +    PERL_UNUSED_VAR(ix);
13393 +    exception=AcquireExceptionInfo();
13394 +    perl_exception=newSVpv("",0);
13395 +    EXTEND(sp,8*items);
13396 +    for (i=1; i < items; i++)
13397 +    {
13398 +      option=ParseCommandOption(MagickListOptions,MagickFalse,(char *)
13399 +        SvPV(ST(i),na));
13400 +      options=GetCommandOptions((CommandOption) option);
13401 +      if (options == (char **) NULL)
13402 +        PUSHs(&sv_undef);
13403 +      else
13404 +        {
13405 +          for (j=0; options[j] != (char *) NULL; j++)
13406 +            PUSHs(sv_2mortal(newSVpv(options[j],0)));
13407 +          options=DestroyStringList(options);
13408 +        }
13409 +    }
13410 +
13411 +    InheritPerlException(exception,perl_exception);
13412 +    exception=DestroyExceptionInfo(exception);
13413 +    SvREFCNT_dec(perl_exception);
13414 +  }
13415 +\f
13416 +#
13417 +###############################################################################
13418 +#                                                                             #
13419 +#                                                                             #
13420 +#                                                                             #
13421 +#   R e a d                                                                   #
13422 +#                                                                             #
13423 +#                                                                             #
13424 +#                                                                             #
13425 +###############################################################################
13426 +#
13427 +#
13428 +void
13429 +Read(ref,...)
13430 +  Image::Magick ref = NO_INIT
13431 +  ALIAS:
13432 +    ReadImage  = 1
13433 +    read       = 2
13434 +    readimage  = 3
13435 +  PPCODE:
13436 +  {
13437 +    AV
13438 +      *av;
13439 +
13440 +    char
13441 +      **keep,
13442 +      **list;
13443 +
13444 +    ExceptionInfo
13445 +      *exception;
13446 +
13447 +    HV
13448 +      *hv;
13449 +
13450 +    Image
13451 +      *image;
13452 +
13453 +    int
13454 +      n;
13455 +
13456 +    MagickBooleanType
13457 +      status;
13458 +
13459 +    register char
13460 +      **p;
13461 +
13462 +    register ssize_t
13463 +      i;
13464 +
13465 +    ssize_t
13466 +      ac,
13467 +      number_images;
13468 +
13469 +    STRLEN
13470 +      *length;
13471 +
13472 +    struct PackageInfo
13473 +      *info,
13474 +      *package_info;
13475 +
13476 +    SV
13477 +      *perl_exception,  /* Perl variable for storing messages */
13478 +      *reference,
13479 +      *rv,
13480 +      *sv;
13481 +
13482 +    PERL_UNUSED_VAR(ref);
13483 +    PERL_UNUSED_VAR(ix);
13484 +    exception=AcquireExceptionInfo();
13485 +    perl_exception=newSVpv("",0);
13486 +    sv=NULL;
13487 +    package_info=(struct PackageInfo *) NULL;
13488 +    number_images=0;
13489 +    ac=(items < 2) ? 1 : items-1;
13490 +    list=(char **) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*list));
13491 +    keep=list;
13492 +    length=(STRLEN *) NULL;
13493 +    if (list == (char **) NULL)
13494 +      {
13495 +        ThrowPerlException(exception,ResourceLimitError,
13496 +          "MemoryAllocationFailed",PackageName);
13497 +        goto PerlException;
13498 +      }
13499 +    length=(STRLEN *) AcquireQuantumMemory((size_t) ac+1UL,sizeof(*length));
13500 +    if (length == (STRLEN *) NULL)
13501 +      {
13502 +        ThrowPerlException(exception,ResourceLimitError,
13503 +          "MemoryAllocationFailed",PackageName);
13504 +        goto PerlException;
13505 +      }
13506 +    if (sv_isobject(ST(0)) == 0)
13507 +      {
13508 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
13509 +          PackageName);
13510 +        goto PerlException;
13511 +      }
13512 +    reference=SvRV(ST(0));
13513 +    hv=SvSTASH(reference);
13514 +    if (SvTYPE(reference) != SVt_PVAV)
13515 +      {
13516 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
13517 +          PackageName);
13518 +        goto PerlException;
13519 +      }
13520 +    av=(AV *) reference;
13521 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
13522 +      exception);
13523 +    package_info=ClonePackageInfo(info,exception);
13524 +    n=1;
13525 +    if (items <= 1)
13526 +      *list=(char *) (*package_info->image_info->filename ?
13527 +        package_info->image_info->filename : "XC:black");
13528 +    else
13529 +      for (n=0, i=0; i < ac; i++)
13530 +      {
13531 +        list[n]=(char *) SvPV(ST(i+1),length[n]);
13532 +        if ((items >= 3) && strEQcase(list[n],"blob"))
13533 +          {
13534 +            void
13535 +              *blob;
13536 +
13537 +            i++;
13538 +            blob=(void *) (SvPV(ST(i+1),length[n]));
13539 +            SetImageInfoBlob(package_info->image_info,blob,(size_t) length[n]);
13540 +          }
13541 +        if ((items >= 3) && strEQcase(list[n],"filename"))
13542 +          continue;
13543 +        if ((items >= 3) && strEQcase(list[n],"file"))
13544 +          {
13545 +            FILE
13546 +              *file;
13547 +
13548 +            PerlIO
13549 +              *io_info;
13550 +
13551 +            i++;
13552 +            io_info=IoIFP(sv_2io(ST(i+1)));
13553 +            if (io_info == (PerlIO *) NULL)
13554 +              {
13555 +                ThrowPerlException(exception,BlobError,"UnableToOpenFile",
13556 +                  PackageName);
13557 +                continue;
13558 +              }
13559 +            file=PerlIO_findFILE(io_info);
13560 +            if (file == (FILE *) NULL)
13561 +              {
13562 +                ThrowPerlException(exception,BlobError,"UnableToOpenFile",
13563 +                  PackageName);
13564 +                continue;
13565 +              }
13566 +            SetImageInfoFile(package_info->image_info,file);
13567 +          }
13568 +        if ((items >= 3) && strEQcase(list[n],"magick"))
13569 +          continue;
13570 +        n++;
13571 +      }
13572 +    list[n]=(char *) NULL;
13573 +    keep=list;
13574 +    status=ExpandFilenames(&n,&list);
13575 +    if (status == MagickFalse)
13576 +      {
13577 +        ThrowPerlException(exception,ResourceLimitError,
13578 +          "MemoryAllocationFailed",PackageName);
13579 +        goto PerlException;
13580 +      }
13581 +    number_images=0;
13582 +    for (i=0; i < n; i++)
13583 +    {
13584 +      if ((package_info->image_info->file != (FILE *) NULL) ||
13585 +          (package_info->image_info->blob != (void *) NULL))
13586 +        {
13587 +          image=ReadImages(package_info->image_info,exception);
13588 +          if (image != (Image *) NULL)
13589 +            DisassociateImageStream(image);
13590 +        }
13591 +      else
13592 +        {
13593 +          (void) CopyMagickString(package_info->image_info->filename,list[i],
13594 +            MaxTextExtent);
13595 +          image=ReadImages(package_info->image_info,exception);
13596 +        }
13597 +      if (image == (Image *) NULL)
13598 +        break;
13599 +      for ( ; image; image=image->next)
13600 +      {
13601 +        AddImageToRegistry(sv,image);
13602 +        rv=newRV(sv);
13603 +        av_push(av,sv_bless(rv,hv));
13604 +        SvREFCNT_dec(sv);
13605 +        number_images++;
13606 +      }
13607 +    }
13608 +    /*
13609 +      Free resources.
13610 +    */
13611 +    for (i=0; i < n; i++)
13612 +      if (list[i] != (char *) NULL)
13613 +        for (p=keep; list[i] != *p++; )
13614 +          if (*p == (char *) NULL)
13615 +            {
13616 +              list[i]=(char *) RelinquishMagickMemory(list[i]);
13617 +              break;
13618 +            }
13619 +
13620 +  PerlException:
13621 +    if (package_info != (struct PackageInfo *) NULL)
13622 +      DestroyPackageInfo(package_info);
13623 +    if (list && (list != keep))
13624 +      list=(char **) RelinquishMagickMemory(list);
13625 +    if (keep)
13626 +      keep=(char **) RelinquishMagickMemory(keep);
13627 +    if (length)
13628 +      length=(STRLEN *) RelinquishMagickMemory(length);
13629 +    InheritPerlException(exception,perl_exception);
13630 +    exception=DestroyExceptionInfo(exception);
13631 +    sv_setiv(perl_exception,(IV) number_images);
13632 +    SvPOK_on(perl_exception);
13633 +    ST(0)=sv_2mortal(perl_exception);
13634 +    XSRETURN(1);
13635 +  }
13636 +\f
13637 +#
13638 +###############################################################################
13639 +#                                                                             #
13640 +#                                                                             #
13641 +#                                                                             #
13642 +#   R e m o t e                                                               #
13643 +#                                                                             #
13644 +#                                                                             #
13645 +#                                                                             #
13646 +###############################################################################
13647 +#
13648 +#
13649 +void
13650 +Remote(ref,...)
13651 +  Image::Magick ref = NO_INIT
13652 +  ALIAS:
13653 +    RemoteCommand  = 1
13654 +    remote         = 2
13655 +    remoteCommand  = 3
13656 +  PPCODE:
13657 +  {
13658 +    AV
13659 +      *av;
13660 +
13661 +    ExceptionInfo
13662 +      *exception;
13663 +
13664 +    register ssize_t
13665 +      i;
13666 +
13667 +    SV
13668 +      *perl_exception,
13669 +      *reference;
13670 +
13671 +    struct PackageInfo
13672 +      *info;
13673 +
13674 +    PERL_UNUSED_VAR(ref);
13675 +    PERL_UNUSED_VAR(ix);
13676 +    exception=AcquireExceptionInfo();
13677 +    perl_exception=newSVpv("",0);
13678 +    reference=SvRV(ST(0));
13679 +    av=(AV *) reference;
13680 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
13681 +      exception);
13682 +    for (i=1; i < items; i++)
13683 +      (void) RemoteDisplayCommand(info->image_info,(char *) NULL,(char *)
13684 +        SvPV(ST(i),na),exception);
13685 +    InheritPerlException(exception,perl_exception);
13686 +    exception=DestroyExceptionInfo(exception);
13687 +    SvREFCNT_dec(perl_exception);    /* throw away all errors */
13688 +  }
13689 +\f
13690 +#
13691 +###############################################################################
13692 +#                                                                             #
13693 +#                                                                             #
13694 +#                                                                             #
13695 +#   S e t                                                                     #
13696 +#                                                                             #
13697 +#                                                                             #
13698 +#                                                                             #
13699 +###############################################################################
13700 +#
13701 +#
13702 +void
13703 +Set(ref,...)
13704 +  Image::Magick ref = NO_INIT
13705 +  ALIAS:
13706 +    SetAttributes  = 1
13707 +    SetAttribute   = 2
13708 +    set            = 3
13709 +    setattributes  = 4
13710 +    setattribute   = 5
13711 +  PPCODE:
13712 +  {
13713 +    ExceptionInfo
13714 +      *exception;
13715 +
13716 +    Image
13717 +      *image;
13718 +
13719 +    register ssize_t
13720 +      i;
13721 +
13722 +    struct PackageInfo
13723 +      *info;
13724 +
13725 +    SV
13726 +      *perl_exception,
13727 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
13728 +
13729 +    PERL_UNUSED_VAR(ref);
13730 +    PERL_UNUSED_VAR(ix);
13731 +    exception=AcquireExceptionInfo();
13732 +    perl_exception=newSVpv("",0);
13733 +    if (sv_isobject(ST(0)) == 0)
13734 +      {
13735 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
13736 +          PackageName);
13737 +        goto PerlException;
13738 +      }
13739 +    reference=SvRV(ST(0));
13740 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
13741 +    if (items == 2)
13742 +      SetAttribute(aTHX_ info,image,"size",ST(1),exception);
13743 +    else
13744 +      for (i=2; i < items; i+=2)
13745 +        SetAttribute(aTHX_ info,image,SvPV(ST(i-1),na),ST(i),exception);
13746 +
13747 +  PerlException:
13748 +    InheritPerlException(exception,perl_exception);
13749 +    exception=DestroyExceptionInfo(exception);
13750 +    sv_setiv(perl_exception,(IV) (SvCUR(perl_exception) != 0));
13751 +    SvPOK_on(perl_exception);
13752 +    ST(0)=sv_2mortal(perl_exception);
13753 +    XSRETURN(1);
13754 +  }
13755 +\f
13756 +#
13757 +###############################################################################
13758 +#                                                                             #
13759 +#                                                                             #
13760 +#                                                                             #
13761 +#   S e t P i x e l                                                           #
13762 +#                                                                             #
13763 +#                                                                             #
13764 +#                                                                             #
13765 +###############################################################################
13766 +#
13767 +#
13768 +void
13769 +SetPixel(ref,...)
13770 +  Image::Magick ref = NO_INIT
13771 +  ALIAS:
13772 +    setpixel = 1
13773 +    setPixel = 2
13774 +  PPCODE:
13775 +  {
13776 +    AV
13777 +      *av;
13778 +
13779 +    char
13780 +      *attribute;
13781 +
13782 +    ChannelType
13783 +      channel;
13784 +
13785 +    ExceptionInfo
13786 +      *exception;
13787 +
13788 +    Image
13789 +      *image;
13790 +
13791 +    MagickBooleanType
13792 +      normalize;
13793 +
13794 +    RectangleInfo
13795 +      region;
13796 +
13797 +    register IndexPacket
13798 +      *indexes;
13799 +
13800 +    register ssize_t
13801 +      i;
13802 +
13803 +    register PixelPacket
13804 +      *q;
13805 +
13806 +    ssize_t
13807 +      option;
13808 +
13809 +    struct PackageInfo
13810 +      *info;
13811 +
13812 +    SV
13813 +      *perl_exception,
13814 +      *reference;  /* reference is the SV* of ref=SvIV(reference) */
13815 +
13816 +    PERL_UNUSED_VAR(ref);
13817 +    PERL_UNUSED_VAR(ix);
13818 +    exception=AcquireExceptionInfo();
13819 +    perl_exception=newSVpv("",0);
13820 +    reference=SvRV(ST(0));
13821 +    av=(AV *) reference;
13822 +    info=GetPackageInfo(aTHX_ (void *) av,(struct PackageInfo *) NULL,
13823 +      exception);
13824 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
13825 +    if (image == (Image *) NULL)
13826 +      {
13827 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
13828 +          PackageName);
13829 +        goto PerlException;
13830 +      }
13831 +    av=(AV *) NULL;
13832 +    channel=DefaultChannels;
13833 +    normalize=MagickTrue;
13834 +    region.x=0;
13835 +    region.y=0;
13836 +    region.width=image->columns;
13837 +    region.height=1;
13838 +    if (items == 1)
13839 +      (void) ParseAbsoluteGeometry(SvPV(ST(1),na),&region);
13840 +    for (i=2; i < items; i+=2)
13841 +    {
13842 +      attribute=(char *) SvPV(ST(i-1),na);
13843 +      switch (*attribute)
13844 +      {
13845 +        case 'C':
13846 +        case 'c':
13847 +        {
13848 +          if (LocaleCompare(attribute,"channel") == 0)
13849 +            {
13850 +              ssize_t
13851 +                option;
13852 +
13853 +              option=ParseChannelOption(SvPV(ST(i),na));
13854 +              if (option < 0)
13855 +                {
13856 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
13857 +                    SvPV(ST(i),na));
13858 +                  return;
13859 +                }
13860 +               channel=(ChannelType) option;
13861 +              break;
13862 +            }
13863 +          if (LocaleCompare(attribute,"color") == 0)
13864 +            {
13865 +              if (SvTYPE(ST(i)) != SVt_RV)
13866 +                {
13867 +                  char
13868 +                    message[MaxTextExtent];
13869 +
13870 +                  (void) FormatLocaleString(message,MaxTextExtent,
13871 +                    "invalid %.60s value",attribute);
13872 +                  ThrowPerlException(exception,OptionError,message,
13873 +                    SvPV(ST(i),na));
13874 +                }
13875 +              av=(AV *) SvRV(ST(i));
13876 +              break;
13877 +            }
13878 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13879 +            attribute);
13880 +          break;
13881 +        }
13882 +        case 'g':
13883 +        case 'G':
13884 +        {
13885 +          if (LocaleCompare(attribute,"geometry") == 0)
13886 +            {
13887 +              (void) ParseAbsoluteGeometry(SvPV(ST(i),na),&region);
13888 +              break;
13889 +            }
13890 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13891 +            attribute);
13892 +          break;
13893 +        }
13894 +        case 'N':
13895 +        case 'n':
13896 +        {
13897 +          if (LocaleCompare(attribute,"normalize") == 0)
13898 +            {
13899 +              option=ParseCommandOption(MagickBooleanOptions,MagickFalse,
13900 +                SvPV(ST(i),na));
13901 +              if (option < 0)
13902 +                {
13903 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
13904 +                    SvPV(ST(i),na));
13905 +                  break;
13906 +                }
13907 +             normalize=option != 0 ? MagickTrue : MagickFalse;
13908 +             break;
13909 +            }
13910 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13911 +            attribute);
13912 +          break;
13913 +        }
13914 +        case 'x':
13915 +        case 'X':
13916 +        {
13917 +          if (LocaleCompare(attribute,"x") == 0)
13918 +            {
13919 +              region.x=SvIV(ST(i));
13920 +              break;
13921 +            }
13922 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13923 +            attribute);
13924 +          break;
13925 +        }
13926 +        case 'y':
13927 +        case 'Y':
13928 +        {
13929 +          if (LocaleCompare(attribute,"y") == 0)
13930 +            {
13931 +              region.y=SvIV(ST(i));
13932 +              break;
13933 +            }
13934 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13935 +            attribute);
13936 +          break;
13937 +        }
13938 +        default:
13939 +        {
13940 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
13941 +            attribute);
13942 +          break;
13943 +        }
13944 +      }
13945 +    }
13946 +    (void) SetImageStorageClass(image,DirectClass);
13947 +    q=GetAuthenticPixels(image,region.x,region.y,1,1,exception);
13948 +    if ((q == (PixelPacket *) NULL) || (av == (AV *) NULL) ||
13949 +        (SvTYPE(av) != SVt_PVAV))
13950 +      PUSHs(&sv_undef);
13951 +    else
13952 +      {
13953 +        double
13954 +          scale;
13955 +
13956 +        register ssize_t
13957 +          i;
13958 +
13959 +        i=0;
13960 +        indexes=GetAuthenticIndexQueue(image);
13961 +        scale=1.0;
13962 +        if (normalize != MagickFalse)
13963 +          scale=QuantumRange;
13964 +        if (((channel & RedChannel) != 0) && (i <= av_len(av)))
13965 +          {
13966 +            SetPixelRed(q,ClampToQuantum(scale*SvNV(*(
13967 +              av_fetch(av,i,0)))));
13968 +            i++;
13969 +          }
13970 +        if (((channel & GreenChannel) != 0) && (i <= av_len(av)))
13971 +          {
13972 +            SetPixelGreen(q,ClampToQuantum(scale*SvNV(*(
13973 +              av_fetch(av,i,0)))));
13974 +            i++;
13975 +          }
13976 +        if (((channel & BlueChannel) != 0) && (i <= av_len(av)))
13977 +          {
13978 +            SetPixelBlue(q,ClampToQuantum(scale*SvNV(*(
13979 +              av_fetch(av,i,0)))));
13980 +            i++;
13981 +          }
13982 +        if ((((channel & IndexChannel) != 0) &&
13983 +            (image->colorspace == CMYKColorspace)) && (i <= av_len(av)))
13984 +          {
13985 +            SetPixelIndex(indexes,ClampToQuantum(scale*
13986 +              SvNV(*(av_fetch(av,i,0)))));
13987 +            i++;
13988 +          }
13989 +        if (((channel & OpacityChannel) != 0) && (i <= av_len(av)))
13990 +          {
13991 +            SetPixelOpacity(q,ClampToQuantum(scale*
13992 +              SvNV(*(av_fetch(av,i,0)))));
13993 +            i++;
13994 +          }
13995 +        (void) SyncAuthenticPixels(image,exception);
13996 +      }
13997 +
13998 +  PerlException:
13999 +    InheritPerlException(exception,perl_exception);
14000 +    exception=DestroyExceptionInfo(exception);
14001 +    SvREFCNT_dec(perl_exception);
14002 +  }
14003 +\f
14004 +#
14005 +###############################################################################
14006 +#                                                                             #
14007 +#                                                                             #
14008 +#                                                                             #
14009 +#   S m u s h                                                                 #
14010 +#                                                                             #
14011 +#                                                                             #
14012 +#                                                                             #
14013 +###############################################################################
14014 +#
14015 +#
14016 +void
14017 +Smush(ref,...)
14018 +  Image::Magick ref = NO_INIT
14019 +  ALIAS:
14020 +    SmushImage  = 1
14021 +    smush       = 2
14022 +    smushimage  = 3
14023 +  PPCODE:
14024 +  {
14025 +    AV
14026 +      *av;
14027 +
14028 +    char
14029 +      *attribute;
14030 +
14031 +    ExceptionInfo
14032 +      *exception;
14033 +
14034 +    HV
14035 +      *hv;
14036 +
14037 +    Image
14038 +      *image;
14039 +
14040 +    register ssize_t
14041 +      i;
14042 +
14043 +    ssize_t
14044 +      offset,
14045 +      stack;
14046 +
14047 +    struct PackageInfo
14048 +      *info;
14049 +
14050 +    SV
14051 +      *av_reference,
14052 +      *perl_exception,
14053 +      *reference,
14054 +      *rv,
14055 +      *sv;
14056 +
14057 +    PERL_UNUSED_VAR(ref);
14058 +    PERL_UNUSED_VAR(ix);
14059 +    exception=AcquireExceptionInfo();
14060 +    perl_exception=newSVpv("",0);
14061 +    sv=NULL;
14062 +    attribute=NULL;
14063 +    av=NULL;
14064 +    if (sv_isobject(ST(0)) == 0)
14065 +      {
14066 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
14067 +          PackageName);
14068 +        goto PerlException;
14069 +      }
14070 +    reference=SvRV(ST(0));
14071 +    hv=SvSTASH(reference);
14072 +    av=newAV();
14073 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
14074 +    SvREFCNT_dec(av);
14075 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
14076 +    if (image == (Image *) NULL)
14077 +      {
14078 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
14079 +          PackageName);
14080 +        goto PerlException;
14081 +      }
14082 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
14083 +    /*
14084 +      Get options.
14085 +    */
14086 +    offset=0;
14087 +    stack=MagickTrue;
14088 +    for (i=2; i < items; i+=2)
14089 +    {
14090 +      attribute=(char *) SvPV(ST(i-1),na);
14091 +      switch (*attribute)
14092 +      {
14093 +        case 'O':
14094 +        case 'o':
14095 +        {
14096 +          if (LocaleCompare(attribute,"offset") == 0)
14097 +            {
14098 +              offset=(ssize_t) StringToLong((char *) SvPV(ST(1),na));
14099 +              break;
14100 +            }
14101 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
14102 +            attribute);
14103 +          break;
14104 +        }
14105 +        case 'S':
14106 +        case 's':
14107 +        {
14108 +          if (LocaleCompare(attribute,"stack") == 0)
14109 +            {
14110 +              stack=ParseCommandOption(MagickBooleanOptions,MagickFalse,
14111 +                SvPV(ST(i),na));
14112 +              if (stack < 0)
14113 +                {
14114 +                  ThrowPerlException(exception,OptionError,"UnrecognizedType",
14115 +                    SvPV(ST(i),na));
14116 +                  return;
14117 +                }
14118 +              break;
14119 +            }
14120 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
14121 +            attribute);
14122 +          break;
14123 +        }
14124 +        default:
14125 +        {
14126 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
14127 +            attribute);
14128 +          break;
14129 +        }
14130 +      }
14131 +    }
14132 +    image=SmushImages(image,stack != 0 ? MagickTrue : MagickFalse,offset,
14133 +      exception);
14134 +    if (image == (Image *) NULL)
14135 +      goto PerlException;
14136 +    for ( ; image; image=image->next)
14137 +    {
14138 +      AddImageToRegistry(sv,image);
14139 +      rv=newRV(sv);
14140 +      av_push(av,sv_bless(rv,hv));
14141 +      SvREFCNT_dec(sv);
14142 +    }
14143 +    exception=DestroyExceptionInfo(exception);
14144 +    ST(0)=av_reference;
14145 +    SvREFCNT_dec(perl_exception);
14146 +    XSRETURN(1);
14147 +
14148 +  PerlException:
14149 +    InheritPerlException(exception,perl_exception);
14150 +    exception=DestroyExceptionInfo(exception);
14151 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
14152 +    SvPOK_on(perl_exception);
14153 +    ST(0)=sv_2mortal(perl_exception);
14154 +    XSRETURN(1);
14155 +  }
14156 +\f
14157 +#
14158 +###############################################################################
14159 +#                                                                             #
14160 +#                                                                             #
14161 +#                                                                             #
14162 +#   S t a t i s t i c s                                                       #
14163 +#                                                                             #
14164 +#                                                                             #
14165 +#                                                                             #
14166 +###############################################################################
14167 +#
14168 +#
14169 +void
14170 +Statistics(ref,...)
14171 +  Image::Magick ref = NO_INIT
14172 +  ALIAS:
14173 +    StatisticsImage = 1
14174 +    statistics      = 2
14175 +    statisticsimage = 3
14176 +  PPCODE:
14177 +  {
14178 +#define ChannelStatistics(channel) \
14179 +{ \
14180 +  (void) FormatLocaleString(message,MaxTextExtent,"%.20g", \
14181 +    (double) channel_statistics[channel].depth); \
14182 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14183 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14184 +    channel_statistics[channel].minima/scale); \
14185 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14186 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14187 +    channel_statistics[channel].maxima/scale); \
14188 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14189 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14190 +    channel_statistics[channel].mean/scale); \
14191 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14192 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14193 +    channel_statistics[channel].standard_deviation/scale); \
14194 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14195 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14196 +    channel_statistics[channel].kurtosis); \
14197 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14198 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14199 +    channel_statistics[channel].skewness); \
14200 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14201 +  (void) FormatLocaleString(message,MaxTextExtent,"%.15g", \
14202 +    channel_statistics[channel].entropy); \
14203 +  PUSHs(sv_2mortal(newSVpv(message,0))); \
14204 +}
14205 +
14206 +    AV
14207 +      *av;
14208 +
14209 +    char
14210 +      message[MaxTextExtent];
14211 +
14212 +    ChannelStatistics
14213 +      *channel_statistics;
14214 +
14215 +    double
14216 +      scale;
14217 +
14218 +    ExceptionInfo
14219 +      *exception;
14220 +
14221 +    Image
14222 +      *image;
14223 +
14224 +    ssize_t
14225 +      count;
14226 +
14227 +    struct PackageInfo
14228 +      *info;
14229 +
14230 +    SV
14231 +      *perl_exception,
14232 +      *reference;
14233 +
14234 +    PERL_UNUSED_VAR(ref);
14235 +    PERL_UNUSED_VAR(ix);
14236 +    exception=AcquireExceptionInfo();
14237 +    perl_exception=newSVpv("",0);
14238 +    av=NULL;
14239 +    if (sv_isobject(ST(0)) == 0)
14240 +      {
14241 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
14242 +          PackageName);
14243 +        goto PerlException;
14244 +      }
14245 +    reference=SvRV(ST(0));
14246 +    av=newAV();
14247 +    SvREFCNT_dec(av);
14248 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
14249 +    if (image == (Image *) NULL)
14250 +      {
14251 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
14252 +          PackageName);
14253 +        goto PerlException;
14254 +      }
14255 +    count=0;
14256 +    for ( ; image; image=image->next)
14257 +    {
14258 +      channel_statistics=GetImageChannelStatistics(image,&image->exception);
14259 +      if (channel_statistics == (ChannelStatistics *) NULL)
14260 +        continue;
14261 +      count++;
14262 +      EXTEND(sp,35*count);
14263 +      scale=(double) QuantumRange;
14264 +      ChannelStatistics(RedChannel);
14265 +      ChannelStatistics(GreenChannel);
14266 +      ChannelStatistics(BlueChannel);
14267 +      if (image->colorspace == CMYKColorspace)
14268 +        ChannelStatistics(IndexChannel);
14269 +      if (image->matte != MagickFalse)
14270 +        ChannelStatistics(OpacityChannel);
14271 +      channel_statistics=(ChannelStatistics *)
14272 +        RelinquishMagickMemory(channel_statistics);
14273 +    }
14274 +
14275 +  PerlException:
14276 +    InheritPerlException(exception,perl_exception);
14277 +    exception=DestroyExceptionInfo(exception);
14278 +    SvREFCNT_dec(perl_exception);
14279 +  }
14280 +\f
14281 +#
14282 +###############################################################################
14283 +#                                                                             #
14284 +#                                                                             #
14285 +#                                                                             #
14286 +#   S y n c A u t h e n t i c P i x e l s                                     #
14287 +#                                                                             #
14288 +#                                                                             #
14289 +#                                                                             #
14290 +###############################################################################
14291 +#
14292 +#
14293 +void
14294 +SyncAuthenticPixels(ref,...)
14295 +  Image::Magick ref = NO_INIT
14296 +  ALIAS:
14297 +    Syncauthenticpixels = 1
14298 +    SyncImagePixels = 2
14299 +    syncimagepixels = 3
14300 +  CODE:
14301 +  {
14302 +    ExceptionInfo
14303 +      *exception;
14304 +
14305 +    Image
14306 +      *image;
14307 +
14308 +    MagickBooleanType
14309 +      status;
14310 +
14311 +    struct PackageInfo
14312 +      *info;
14313 +
14314 +    SV
14315 +      *perl_exception,
14316 +      *reference;
14317 +
14318 +    PERL_UNUSED_VAR(ref);
14319 +    PERL_UNUSED_VAR(ix);
14320 +    exception=AcquireExceptionInfo();
14321 +    perl_exception=newSVpv("",0);
14322 +    if (sv_isobject(ST(0)) == 0)
14323 +      {
14324 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
14325 +          PackageName);
14326 +        goto PerlException;
14327 +      }
14328 +
14329 +    reference=SvRV(ST(0));
14330 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
14331 +    if (image == (Image *) NULL)
14332 +      {
14333 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
14334 +          PackageName);
14335 +        goto PerlException;
14336 +      }
14337 +
14338 +    status=SyncAuthenticPixels(image,exception);
14339 +    if (status != MagickFalse)
14340 +      return;
14341 +    InheritException(exception,&image->exception);
14342 +
14343 +  PerlException:
14344 +    InheritPerlException(exception,perl_exception);
14345 +    exception=DestroyExceptionInfo(exception);
14346 +    SvREFCNT_dec(perl_exception);  /* throw away all errors */
14347 +  }
14348 +\f
14349 +#
14350 +###############################################################################
14351 +#                                                                             #
14352 +#                                                                             #
14353 +#                                                                             #
14354 +#   T r a n s f o r m                                                         #
14355 +#                                                                             #
14356 +#                                                                             #
14357 +#                                                                             #
14358 +###############################################################################
14359 +#
14360 +#
14361 +void
14362 +Transform(ref,...)
14363 +  Image::Magick ref = NO_INIT
14364 +  ALIAS:
14365 +    TransformImage = 1
14366 +    transform      = 2
14367 +    transformimage = 3
14368 +  PPCODE:
14369 +  {
14370 +    AV
14371 +      *av;
14372 +
14373 +    char
14374 +      *attribute,
14375 +      *crop_geometry,
14376 +      *geometry;
14377 +
14378 +    ExceptionInfo
14379 +      *exception;
14380 +
14381 +    HV
14382 +      *hv;
14383 +
14384 +    Image
14385 +      *clone,
14386 +      *image;
14387 +
14388 +    register ssize_t
14389 +      i;
14390 +
14391 +    struct PackageInfo
14392 +      *info;
14393 +
14394 +    SV
14395 +      *av_reference,
14396 +      *perl_exception,
14397 +      *reference,
14398 +      *rv,
14399 +      *sv;
14400 +
14401 +    PERL_UNUSED_VAR(ref);
14402 +    PERL_UNUSED_VAR(ix);
14403 +    exception=AcquireExceptionInfo();
14404 +    perl_exception=newSVpv("",0);
14405 +    sv=NULL;
14406 +    av=NULL;
14407 +    attribute=NULL;
14408 +    if (sv_isobject(ST(0)) == 0)
14409 +      {
14410 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
14411 +          PackageName);
14412 +        goto PerlException;
14413 +      }
14414 +    reference=SvRV(ST(0));
14415 +    hv=SvSTASH(reference);
14416 +    av=newAV();
14417 +    av_reference=sv_2mortal(sv_bless(newRV((SV *) av),hv));
14418 +    SvREFCNT_dec(av);
14419 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
14420 +    if (image == (Image *) NULL)
14421 +      {
14422 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
14423 +          PackageName);
14424 +        goto PerlException;
14425 +      }
14426 +    info=GetPackageInfo(aTHX_ (void *) av,info,exception);
14427 +    /*
14428 +      Get attribute.
14429 +    */
14430 +    crop_geometry=(char *) NULL;
14431 +    geometry=(char *) NULL;
14432 +    for (i=2; i < items; i+=2)
14433 +    {
14434 +      attribute=(char *) SvPV(ST(i-1),na);
14435 +      switch (*attribute)
14436 +      {
14437 +        case 'c':
14438 +        case 'C':
14439 +        {
14440 +          if (LocaleCompare(attribute,"crop") == 0)
14441 +            {
14442 +              crop_geometry=SvPV(ST(i),na);
14443 +              break;
14444 +            }
14445 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
14446 +            attribute);
14447 +          break;
14448 +        }
14449 +        case 'g':
14450 +        case 'G':
14451 +        {
14452 +          if (LocaleCompare(attribute,"geometry") == 0)
14453 +            {
14454 +              geometry=SvPV(ST(i),na);
14455 +              break;
14456 +            }
14457 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
14458 +            attribute);
14459 +          break;
14460 +        }
14461 +        default:
14462 +        {
14463 +          ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
14464 +            attribute);
14465 +          break;
14466 +        }
14467 +      }
14468 +    }
14469 +    for ( ; image; image=image->next)
14470 +    {
14471 +      clone=CloneImage(image,0,0,MagickTrue,exception);
14472 +      if (clone == (Image *) NULL)
14473 +        goto PerlException;
14474 +      TransformImage(&clone,crop_geometry,geometry);
14475 +      for ( ; clone; clone=clone->next)
14476 +      {
14477 +        AddImageToRegistry(sv,clone);
14478 +        rv=newRV(sv);
14479 +        av_push(av,sv_bless(rv,hv));
14480 +        SvREFCNT_dec(sv);
14481 +      }
14482 +    }
14483 +    exception=DestroyExceptionInfo(exception);
14484 +    ST(0)=av_reference;
14485 +    SvREFCNT_dec(perl_exception);  /* can't return warning messages */
14486 +    XSRETURN(1);
14487 +
14488 +  PerlException:
14489 +    InheritPerlException(exception,perl_exception);
14490 +    exception=DestroyExceptionInfo(exception);
14491 +    sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
14492 +    SvPOK_on(perl_exception);
14493 +    ST(0)=sv_2mortal(perl_exception);
14494 +    XSRETURN(1);
14495 +  }
14496 +\f
14497 +#
14498 +###############################################################################
14499 +#                                                                             #
14500 +#                                                                             #
14501 +#                                                                             #
14502 +#   W r i t e                                                                 #
14503 +#                                                                             #
14504 +#                                                                             #
14505 +#                                                                             #
14506 +###############################################################################
14507 +#
14508 +#
14509 +void
14510 +Write(ref,...)
14511 +  Image::Magick ref = NO_INIT
14512 +  ALIAS:
14513 +    WriteImage    = 1
14514 +    write         = 2
14515 +    writeimage    = 3
14516 +  PPCODE:
14517 +  {
14518 +    char
14519 +      filename[MaxTextExtent];
14520 +
14521 +    ExceptionInfo
14522 +      *exception;
14523 +
14524 +    Image
14525 +      *image,
14526 +      *next;
14527 +
14528 +    register ssize_t
14529 +      i;
14530 +
14531 +    ssize_t
14532 +      number_images,
14533 +      scene;
14534 +
14535 +    struct PackageInfo
14536 +      *info,
14537 +      *package_info;
14538 +
14539 +    SV
14540 +      *perl_exception,
14541 +      *reference;
14542 +
14543 +    PERL_UNUSED_VAR(ref);
14544 +    PERL_UNUSED_VAR(ix);
14545 +    exception=AcquireExceptionInfo();
14546 +    perl_exception=newSVpv("",0);
14547 +    number_images=0;
14548 +    package_info=(struct PackageInfo *) NULL;
14549 +    if (sv_isobject(ST(0)) == 0)
14550 +      {
14551 +        ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
14552 +          PackageName);
14553 +        goto PerlException;
14554 +      }
14555 +    reference=SvRV(ST(0));
14556 +    image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
14557 +    if (image == (Image *) NULL)
14558 +      {
14559 +        ThrowPerlException(exception,OptionError,"NoImagesDefined",
14560 +          PackageName);
14561 +        goto PerlException;
14562 +      }
14563 +    package_info=ClonePackageInfo(info,exception);
14564 +    if (items == 2)
14565 +      SetAttribute(aTHX_ package_info,NULL,"filename",ST(1),exception);
14566 +    else
14567 +      if (items > 2)
14568 +        for (i=2; i < items; i+=2)
14569 +          SetAttribute(aTHX_ package_info,image,SvPV(ST(i-1),na),ST(i),
14570 +            exception);
14571 +    (void) CopyMagickString(filename,package_info->image_info->filename,
14572 +      MaxTextExtent);
14573 +    scene=0;
14574 +    for (next=image; next; next=next->next)
14575 +    {
14576 +      (void) CopyMagickString(next->filename,filename,MaxTextExtent);
14577 +      next->scene=scene++;
14578 +    }
14579 +    *package_info->image_info->magick='\0';
14580 +    SetImageInfo(package_info->image_info,(unsigned int)
14581 +      GetImageListLength(image),&image->exception);
14582 +    for (next=image; next; next=next->next)
14583 +    {
14584 +      (void) WriteImage(package_info->image_info,next);
14585 +      if (next->exception.severity >= ErrorException)
14586 +        InheritException(exception,&next->exception);
14587 +      GetImageException(next,exception);
14588 +      number_images++;
14589 +      if (package_info->image_info->adjoin)
14590 +        break;
14591 +    }
14592 +
14593 +  PerlException:
14594 +    if (package_info != (struct PackageInfo *) NULL)
14595 +      DestroyPackageInfo(package_info);
14596 +    InheritPerlException(exception,perl_exception);
14597 +    exception=DestroyExceptionInfo(exception);
14598 +    sv_setiv(perl_exception,(IV) number_images);
14599 +    SvPOK_on(perl_exception);
14600 +    ST(0)=sv_2mortal(perl_exception);
14601 +    XSRETURN(1);
14602 +  }