granicus.if.org Git - imagemagick/blob - MagickWand/mogrify.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %              M   M   OOO   GGGGG  RRRR   IIIII  FFFFF  Y   Y                %
   7 %              MM MM  O   O  G      R   R    I    F       Y Y                 %
   8 %              M M M  O   O  G GGG  RRRR     I    FFF      Y                  %
   9 %              M   M  O   O  G   G  R R      I    F        Y                  %
  10 %              M   M   OOO   GGGG   R  R   IIIII  F        Y                  %
  11 %                                                                             %
  12 %                                                                             %
  13 %                         MagickWand Module Methods                           %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                March 2000                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %  Use the mogrify program to resize an image, blur, crop, despeckle, dither,
  37 %  draw on, flip, join, re-sample, and much more. This tool is similiar to
  38 %  convert except that the original image file is overwritten (unless you
  39 %  change the file suffix with the -format option) with any changes you
  40 %  request.
  41 %
  42 */
  43 \f
  44 /*
  45   Include declarations.
  46 */
  47 #include "MagickWand/studio.h"
  48 #include "MagickWand/MagickWand.h"
  49 #include "MagickWand/mogrify-private.h"
  50 #undef DegreesToRadians
  51 #undef RadiansToDegrees
  52 #include "MagickCore/image-private.h"
  53 #include "MagickCore/monitor-private.h"
  54 #include "MagickCore/thread-private.h"
  55 #include "MagickCore/string-private.h"
  56 #include "MagickCore/utility-private.h"
  57 \f
  58 /*
  59  Constant declaration.
  60 */
  61 static const char
  62   MogrifyBackgroundColor[] = "#ffffff",  /* white */
  63   MogrifyBorderColor[] = "#dfdfdf",  /* gray */
  64   MogrifyMatteColor[] = "#bdbdbd";  /* gray */
  65 \f
  66 /*
  67   Define declarations.
  68 */
  69 #define UndefinedCompressionQuality  0UL
  70 \f
  71 /*
  72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  73 %                                                                             %
  74 %                                                                             %
  75 %                                                                             %
  76 %     M a g i c k C o m m a n d G e n e s i s                                 %
  77 %                                                                             %
  78 %                                                                             %
  79 %                                                                             %
  80 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  81 %
  82 %  MagickCommandGenesis() applies image processing options to an image as
  83 %  prescribed by command line options.
  84 %
  85 %  The format of the MagickCommandGenesis method is:
  86 %
  87 %      MagickBooleanType MagickCommandGenesis(ImageInfo *image_info,
  88 %        MagickCommand command,int argc,char **argv,char **metadata,
  89 %        ExceptionInfo *exception)
  90 %
  91 %  A description of each parameter follows:
  92 %
  93 %    o image_info: the image info.
  94 %
  95 %    o command: Choose from ConvertImageCommand, IdentifyImageCommand,
  96 %      MogrifyImageCommand, CompositeImageCommand, CompareImagesCommand,
  97 %      ConjureImageCommand, StreamImageCommand, ImportImageCommand,
  98 %      DisplayImageCommand, or AnimateImageCommand.
  99 %
 100 %    o argc: Specifies a pointer to an integer describing the number of
 101 %      elements in the argument vector.
 102 %
 103 %    o argv: Specifies a pointer to a text array containing the command line
 104 %      arguments.
 105 %
 106 %    o metadata: any metadata is returned here.
 107 %
 108 %    o exception: return any errors or warnings in this structure.
 109 %
 110 */
 111 WandExport MagickBooleanType MagickCommandGenesis(ImageInfo *image_info,
 112   MagickCommand command,int argc,char **argv,char **metadata,
 113   ExceptionInfo *exception)
 114 {
 115   char
 116     *option;
 117
 118   double
 119     duration,
 120     elapsed_time,
 121     user_time;
 122
 123   MagickBooleanType
 124     concurrent,
 125     regard_warnings,
 126     status;
 127
 128   register ssize_t
 129     i;
 130
 131   TimerInfo
 132     *timer;
 133
 134   size_t
 135     iterations;
 136
 137   (void) setlocale(LC_ALL,"");
 138   (void) setlocale(LC_NUMERIC,"C");
 139   concurrent=MagickFalse;
 140   duration=(-1.0);
 141   iterations=1;
 142   status=MagickFalse;
 143   regard_warnings=MagickFalse;
 144   for (i=1; i < (ssize_t) (argc-1); i++)
 145   {
 146     option=argv[i];
 147     if ((strlen(option) == 1) || ((*option != '-') && (*option != '+')))
 148       continue;
 149     if (LocaleCompare("bench",option+1) == 0)
 150       iterations=StringToUnsignedLong(argv[++i]);
 151     if (LocaleCompare("concurrent",option+1) == 0)
 152       concurrent=MagickTrue;
 153     if (LocaleCompare("debug",option+1) == 0)
 154       (void) SetLogEventMask(argv[++i]);
 155     if (LocaleCompare("duration",option+1) == 0)
 156       duration=InterpretLocaleValue(argv[++i],(char **) NULL);
 157     if (LocaleCompare("regard-warnings",option+1) == 0)
 158       regard_warnings=MagickTrue;
 159   }
 160   timer=AcquireTimerInfo();
 161   if (concurrent == MagickFalse)
 162     {
 163       for (i=0; i < (ssize_t) iterations; i++)
 164       {
 165         if (status != MagickFalse)
 166           continue;
 167         if (duration > 0)
 168           {
 169             if (GetElapsedTime(timer) > duration)
 170               continue;
 171             (void) ContinueTimer(timer);
 172           }
 173         status=command(image_info,argc,argv,metadata,exception);
 174         if (exception->severity != UndefinedException)
 175           {
 176             if ((exception->severity > ErrorException) ||
 177                 (regard_warnings != MagickFalse))
 178               status=MagickTrue;
 179             CatchException(exception);
 180           }
 181         if ((metadata != (char **) NULL) && (*metadata != (char *) NULL))
 182           {
 183             (void) fputs(*metadata,stdout);
 184             (void) fputc('\n',stdout);
 185             *metadata=DestroyString(*metadata);
 186           }
 187       }
 188     }
 189   else
 190     {
 191       SetOpenMPNested(1);
 192 #if defined(MAGICKCORE_OPENMP_SUPPORT)
 193   # pragma omp parallel for shared(status)
 194 #endif
 195       for (i=0; i < (ssize_t) iterations; i++)
 196       {
 197         if (status != MagickFalse)
 198           continue;
 199         if (duration > 0)
 200           {
 201             if (GetElapsedTime(timer) > duration)
 202               continue;
 203             (void) ContinueTimer(timer);
 204           }
 205         status=command(image_info,argc,argv,metadata,exception);
 206 #if defined(MAGICKCORE_OPENMP_SUPPORT)
 207   # pragma omp critical (MagickCore_CommandGenesis)
 208 #endif
 209         {
 210           if (exception->severity != UndefinedException)
 211             {
 212               if ((exception->severity > ErrorException) ||
 213                   (regard_warnings != MagickFalse))
 214                 status=MagickTrue;
 215               CatchException(exception);
 216             }
 217           if ((metadata != (char **) NULL) && (*metadata != (char *) NULL))
 218             {
 219               (void) fputs(*metadata,stdout);
 220               (void) fputc('\n',stdout);
 221               *metadata=DestroyString(*metadata);
 222             }
 223         }
 224       }
 225     }
 226   if (iterations > 1)
 227     {
 228       elapsed_time=GetElapsedTime(timer);
 229       user_time=GetUserTime(timer);
 230       (void) FormatLocaleFile(stderr,
 231         "Performance: %.20gi %gips %0.3fu %.20g:%02g.%03g\n",(double)
 232         iterations,1.0*iterations/elapsed_time,user_time,(double)
 233         (elapsed_time/60.0),floor(fmod(elapsed_time,60.0)),(double)
 234         (1000.0*(elapsed_time-floor(elapsed_time))));
 235       (void) fflush(stderr);
 236     }
 237   timer=DestroyTimerInfo(timer);
 238   return(status);
 239 }
 240 \f
 241 /*
 242 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 243 %                                                                             %
 244 %                                                                             %
 245 %                                                                             %
 246 +     M o g r i f y I m a g e                                                 %
 247 %                                                                             %
 248 %                                                                             %
 249 %                                                                             %
 250 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 251 %
 252 %  MogrifyImage() applies simple single image processing options to a single
 253 %  image that may be part of a large list, but also handles any 'region'
 254 %  image handling.
 255 %
 256 %  The image in the list may be modified in three different ways...
 257 %
 258 %    * directly modified (EG: -negate, -gamma, -level, -annotate, -draw),
 259 %    * replaced by a new image (EG: -spread, -resize, -rotate, -morphology)
 260 %    * replace by a list of images (only the -separate option!)
 261 %
 262 %  In each case the result is returned into the list, and a pointer to the
 263 %  modified image (last image added if replaced by a list of images) is
 264 %  returned.
 265 %
 266 %  ASIDE: The -crop is present but restricted to non-tile single image crops
 267 %
 268 %  This means if all the images are being processed (such as by
 269 %  MogrifyImages(), next image to be processed will be as per the pointer
 270 %  (*image)->next.  Also the image list may grow as a result of some specific
 271 %  operations but as images are never merged or deleted, it will never shrink
 272 %  in length.  Typically the list will remain the same length.
 273 %
 274 %  WARNING: As the image pointed to may be replaced, the first image in the
 275 %  list may also change.  GetFirstImageInList() should be used by caller if
 276 %  they wish return the Image pointer to the first image in list.
 277 %
 278 %
 279 %  The format of the MogrifyImage method is:
 280 %
 281 %      MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
 282 %        const char **argv,Image **image)
 283 %
 284 %  A description of each parameter follows:
 285 %
 286 %    o image_info: the image info..
 287 %
 288 %    o argc: Specifies a pointer to an integer describing the number of
 289 %      elements in the argument vector.
 290 %
 291 %    o argv: Specifies a pointer to a text array containing the command line
 292 %      arguments.
 293 %
 294 %    o image: the image.
 295 %
 296 %    o exception: return any errors or warnings in this structure.
 297 %
 298 */
 299
 300 /*
 301 ** GetImageCache() will read an image into a image cache if not already
 302 ** present then return the image that is in the cache under that filename.
 303 */
 304 static inline Image *GetImageCache(const ImageInfo *image_info,const char *path,
 305   ExceptionInfo *exception)
 306 {
 307   char
 308     key[MaxTextExtent];
 309
 310   ExceptionInfo
 311     *sans_exception;
 312
 313   Image
 314     *image;
 315
 316   ImageInfo
 317     *read_info;
 318
 319   (void) FormatLocaleString(key,MaxTextExtent,"cache:%s",path);
 320   sans_exception=AcquireExceptionInfo();
 321   image=(Image *) GetImageRegistry(ImageRegistryType,key,sans_exception);
 322   sans_exception=DestroyExceptionInfo(sans_exception);
 323   if (image != (Image *) NULL)
 324     return(image);
 325   read_info=CloneImageInfo(image_info);
 326   (void) CopyMagickString(read_info->filename,path,MaxTextExtent);
 327   image=ReadImage(read_info,exception);
 328   read_info=DestroyImageInfo(read_info);
 329   if (image != (Image *) NULL)
 330     (void) SetImageRegistry(ImageRegistryType,key,image,exception);
 331   return(image);
 332 }
 333
 334 static MagickBooleanType IsPathWritable(const char *path)
 335 {
 336   if (IsPathAccessible(path) == MagickFalse)
 337     return(MagickFalse);
 338   if (access_utf8(path,W_OK) != 0)
 339     return(MagickFalse);
 340   return(MagickTrue);
 341 }
 342
 343 static inline ssize_t MagickMax(const ssize_t x,const ssize_t y)
 344 {
 345   if (x > y)
 346     return(x);
 347   return(y);
 348 }
 349
 350 static MagickBooleanType MonitorProgress(const char *text,
 351   const MagickOffsetType offset,const MagickSizeType extent,
 352   void *wand_unused(client_data))
 353 {
 354   char
 355     message[MaxTextExtent],
 356     tag[MaxTextExtent];
 357
 358   const char
 359     *locale_message;
 360
 361   register char
 362     *p;
 363
 364   if (extent < 2)
 365     return(MagickTrue);
 366   (void) CopyMagickMemory(tag,text,MaxTextExtent);
 367   p=strrchr(tag,'/');
 368   if (p != (char *) NULL)
 369     *p='\0';
 370   (void) FormatLocaleString(message,MaxTextExtent,"Monitor/%s",tag);
 371   locale_message=GetLocaleMessage(message);
 372   if (locale_message == message)
 373     locale_message=tag;
 374   if (p == (char *) NULL)
 375     (void) FormatLocaleFile(stderr,"%s: %ld of %lu, %02ld%% complete\r",
 376       locale_message,(long) offset,(unsigned long) extent,(long)
 377       (100L*offset/(extent-1)));
 378   else
 379     (void) FormatLocaleFile(stderr,"%s[%s]: %ld of %lu, %02ld%% complete\r",
 380       locale_message,p+1,(long) offset,(unsigned long) extent,(long)
 381       (100L*offset/(extent-1)));
 382   if (offset == (MagickOffsetType) (extent-1))
 383     (void) FormatLocaleFile(stderr,"\n");
 384   (void) fflush(stderr);
 385   return(MagickTrue);
 386 }
 387
 388 static Image *SparseColorOption(const Image *image,
 389   const SparseColorMethod method,const char *arguments,
 390   const MagickBooleanType color_from_image,ExceptionInfo *exception)
 391 {
 392   char
 393     token[MaxTextExtent];
 394
 395   const char
 396     *p;
 397
 398   double
 399     *sparse_arguments;
 400
 401   Image
 402     *sparse_image;
 403
 404   PixelInfo
 405     color;
 406
 407   MagickBooleanType
 408     error;
 409
 410   register size_t
 411     x;
 412
 413   size_t
 414     number_arguments,
 415     number_colors;
 416
 417   /*
 418     SparseColorOption() parses the complex -sparse-color argument into an
 419     an array of floating point values then calls SparseColorImage().
 420     Argument is a complex mix of floating-point pixel coodinates, and color
 421     specifications (or direct floating point numbers).  The number of floats
 422     needed to represent a color varies depending on the current channel
 423     setting.
 424   */
 425   assert(image != (Image *) NULL);
 426   assert(image->signature == MagickSignature);
 427   if (image->debug != MagickFalse)
 428     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 429   assert(exception != (ExceptionInfo *) NULL);
 430   assert(exception->signature == MagickSignature);
 431   /*
 432     Limit channels according to image - and add up number of color channel.
 433   */
 434   number_colors=0;
 435   if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
 436     number_colors++;
 437   if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
 438     number_colors++;
 439   if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
 440     number_colors++;
 441   if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
 442       (image->colorspace == CMYKColorspace))
 443     number_colors++;
 444   if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
 445       (image->matte != MagickFalse))
 446     number_colors++;
 447
 448   /*
 449     Read string, to determine number of arguments needed,
 450   */
 451   p=arguments;
 452   x=0;
 453   while( *p != '\0' )
 454   {
 455     GetMagickToken(p,&p,token);
 456     if ( token[0] == ',' ) continue;
 457     if ( isalpha((int) token[0]) || token[0] == '#' ) {
 458       if ( color_from_image ) {
 459         (void) ThrowMagickException(exception,GetMagickModule(),
 460             OptionError, "InvalidArgument", "`%s': %s", "sparse-color",
 461             "Color arg given, when colors are coming from image");
 462         return( (Image *)NULL);
 463       }
 464       x += number_colors;  /* color argument */
 465     }
 466     else {
 467       x++;   /* floating point argument */
 468     }
 469   }
 470   error=MagickTrue;
 471   if ( color_from_image ) {
 472     /* just the control points are being given */
 473     error = ( x % 2 != 0 ) ? MagickTrue : MagickFalse;
 474     number_arguments=(x/2)*(2+number_colors);
 475   }
 476   else {
 477     /* control points and color values */
 478     error = ( x % (2+number_colors) != 0 ) ? MagickTrue : MagickFalse;
 479     number_arguments=x;
 480   }
 481   if ( error ) {
 482     (void) ThrowMagickException(exception,GetMagickModule(),
 483                OptionError, "InvalidArgument", "`%s': %s", "sparse-color",
 484                "Invalid number of Arguments");
 485     return( (Image *)NULL);
 486   }
 487
 488   /* Allocate and fill in the floating point arguments */
 489   sparse_arguments=(double *) AcquireQuantumMemory(number_arguments,
 490     sizeof(*sparse_arguments));
 491   if (sparse_arguments == (double *) NULL) {
 492     (void) ThrowMagickException(exception,GetMagickModule(),ResourceLimitError,
 493       "MemoryAllocationFailed","%s","SparseColorOption");
 494     return( (Image *)NULL);
 495   }
 496   (void) ResetMagickMemory(sparse_arguments,0,number_arguments*
 497     sizeof(*sparse_arguments));
 498   p=arguments;
 499   x=0;
 500   while( *p != '\0' && x < number_arguments ) {
 501     /* X coordinate */
 502     token[0]=','; while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 503     if ( token[0] == '\0' ) break;
 504     if ( isalpha((int) token[0]) || token[0] == '#' ) {
 505       (void) ThrowMagickException(exception,GetMagickModule(),
 506             OptionError, "InvalidArgument", "`%s': %s", "sparse-color",
 507             "Color found, instead of X-coord");
 508       error = MagickTrue;
 509       break;
 510     }
 511     sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 512     /* Y coordinate */
 513     token[0]=','; while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 514     if ( token[0] == '\0' ) break;
 515     if ( isalpha((int) token[0]) || token[0] == '#' ) {
 516       (void) ThrowMagickException(exception,GetMagickModule(),
 517             OptionError, "InvalidArgument", "`%s': %s", "sparse-color",
 518             "Color found, instead of Y-coord");
 519       error = MagickTrue;
 520       break;
 521     }
 522     sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 523     /* color values for this control point */
 524 #if 0
 525     if ( (color_from_image ) {
 526       /* get color from image */
 527       /* HOW??? */
 528     }
 529     else
 530 #endif
 531     {
 532       /* color name or function given in string argument */
 533       token[0]=','; while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 534       if ( token[0] == '\0' ) break;
 535       if ( isalpha((int) token[0]) || token[0] == '#' ) {
 536         /* Color string given */
 537         (void) QueryMagickColorCompliance(token,AllCompliance,&color,exception);
 538         if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
 539           sparse_arguments[x++] = QuantumScale*color.red;
 540         if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
 541           sparse_arguments[x++] = QuantumScale*color.green;
 542         if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
 543           sparse_arguments[x++] = QuantumScale*color.blue;
 544         if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
 545             (image->colorspace == CMYKColorspace))
 546           sparse_arguments[x++] = QuantumScale*color.black;
 547         if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
 548             (image->matte != MagickFalse))
 549           sparse_arguments[x++] = QuantumScale*color.alpha;
 550       }
 551       else {
 552         /* Colors given as a set of floating point values - experimental */
 553         /* NB: token contains the first floating point value to use! */
 554         if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
 555           {
 556           while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 557           if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' )
 558             break;
 559           sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 560           token[0] = ','; /* used this token - get another */
 561         }
 562         if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
 563           {
 564           while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 565           if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' )
 566             break;
 567           sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 568           token[0] = ','; /* used this token - get another */
 569         }
 570         if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
 571           {
 572           while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 573           if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' )
 574             break;
 575           sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 576           token[0] = ','; /* used this token - get another */
 577         }
 578         if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
 579             (image->colorspace == CMYKColorspace))
 580           {
 581           while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 582           if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' )
 583             break;
 584           sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 585           token[0] = ','; /* used this token - get another */
 586         }
 587         if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
 588             (image->matte != MagickFalse))
 589           {
 590           while ( token[0] == ',' ) GetMagickToken(p,&p,token);
 591           if ( token[0] == '\0' || isalpha((int)token[0]) || token[0] == '#' )
 592             break;
 593           sparse_arguments[x++]=InterpretLocaleValue(token,(char **) NULL);
 594           token[0] = ','; /* used this token - get another */
 595         }
 596       }
 597     }
 598   }
 599   if ( number_arguments != x && !error ) {
 600     (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
 601       "InvalidArgument","`%s': %s","sparse-color","Argument Parsing Error");
 602     sparse_arguments=(double *) RelinquishMagickMemory(sparse_arguments);
 603     return( (Image *)NULL);
 604   }
 605   if ( error )
 606     return( (Image *)NULL);
 607
 608   /* Call the Interpolation function with the parsed arguments */
 609   sparse_image=SparseColorImage(image,method,number_arguments,sparse_arguments,
 610     exception);
 611   sparse_arguments=(double *) RelinquishMagickMemory(sparse_arguments);
 612   return( sparse_image );
 613 }
 614
 615 WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
 616   const char **argv,Image **image,ExceptionInfo *exception)
 617 {
 618   ChannelType
 619     channel;
 620
 621   CompositeOperator
 622     compose;
 623
 624   const char
 625     *format,
 626     *option;
 627
 628   DrawInfo
 629     *draw_info;
 630
 631   GeometryInfo
 632     geometry_info;
 633
 634   Image
 635     *region_image;
 636
 637   ImageInfo
 638     *mogrify_info;
 639
 640   MagickStatusType
 641     status;
 642
 643   PixelInfo
 644     fill;
 645
 646   MagickStatusType
 647     flags;
 648
 649   PixelInterpolateMethod
 650     interpolate_method;
 651
 652   QuantizeInfo
 653     *quantize_info;
 654
 655   RectangleInfo
 656     geometry,
 657     region_geometry;
 658
 659   register ssize_t
 660     i;
 661
 662   /*
 663     Initialize method variables.
 664   */
 665   assert(image_info != (const ImageInfo *) NULL);
 666   assert(image_info->signature == MagickSignature);
 667   assert(image != (Image **) NULL);
 668   assert((*image)->signature == MagickSignature);
 669   if ((*image)->debug != MagickFalse)
 670     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
 671   if (argc < 0)
 672     return(MagickTrue);
 673   mogrify_info=CloneImageInfo(image_info);
 674   draw_info=CloneDrawInfo(mogrify_info,(DrawInfo *) NULL);
 675   quantize_info=AcquireQuantizeInfo(mogrify_info);
 676   SetGeometryInfo(&geometry_info);
 677   GetPixelInfo(*image,&fill);
 678   SetPixelInfoPacket(*image,&(*image)->background_color,&fill);
 679   compose=(*image)->compose;
 680   interpolate_method=UndefinedInterpolatePixel;
 681   channel=mogrify_info->channel;
 682   format=GetImageOption(mogrify_info,"format");
 683   SetGeometry(*image,&region_geometry);
 684   region_image=NewImageList();
 685   /*
 686     Transmogrify the image.
 687   */
 688   for (i=0; i < (ssize_t) argc; i++)
 689   {
 690     Image
 691       *mogrify_image;
 692
 693     ssize_t
 694       count;
 695
 696     option=argv[i];
 697     if (IsCommandOption(option) == MagickFalse)
 698       continue;
 699     count=MagickMax(ParseCommandOption(MagickCommandOptions,MagickFalse,option),
 700       0L);
 701     if ((i+count) >= (ssize_t) argc)
 702       break;
 703     status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception);
 704     mogrify_image=(Image *)NULL;
 705     switch (*(option+1))
 706     {
 707       case 'a':
 708       {
 709         if (LocaleCompare("adaptive-blur",option+1) == 0)
 710           {
 711             /*
 712               Adaptive blur image.
 713             */
 714             (void) SyncImageSettings(mogrify_info,*image);
 715             flags=ParseGeometry(argv[i+1],&geometry_info);
 716             if ((flags & SigmaValue) == 0)
 717               geometry_info.sigma=1.0;
 718             if ((flags & XiValue) == 0)
 719               geometry_info.xi=0.0;
 720             mogrify_image=AdaptiveBlurImage(*image,geometry_info.rho,
 721               geometry_info.sigma,geometry_info.xi,exception);
 722             break;
 723           }
 724         if (LocaleCompare("adaptive-resize",option+1) == 0)
 725           {
 726             /*
 727               Adaptive resize image.
 728             */
 729             (void) SyncImageSettings(mogrify_info,*image);
 730             (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
 731             mogrify_image=AdaptiveResizeImage(*image,geometry.width,
 732               geometry.height,interpolate_method,exception);
 733             break;
 734           }
 735         if (LocaleCompare("adaptive-sharpen",option+1) == 0)
 736           {
 737             /*
 738               Adaptive sharpen image.
 739             */
 740             (void) SyncImageSettings(mogrify_info,*image);
 741             flags=ParseGeometry(argv[i+1],&geometry_info);
 742             if ((flags & SigmaValue) == 0)
 743               geometry_info.sigma=1.0;
 744             if ((flags & XiValue) == 0)
 745               geometry_info.xi=0.0;
 746             mogrify_image=AdaptiveSharpenImage(*image,geometry_info.rho,
 747               geometry_info.sigma,geometry_info.xi,exception);
 748             break;
 749           }
 750         if (LocaleCompare("affine",option+1) == 0)
 751           {
 752             /*
 753               Affine matrix.
 754             */
 755             if (*option == '+')
 756               {
 757                 GetAffineMatrix(&draw_info->affine);
 758                 break;
 759               }
 760             (void) ParseAffineGeometry(argv[i+1],&draw_info->affine,exception);
 761             break;
 762           }
 763         if (LocaleCompare("alpha",option+1) == 0)
 764           {
 765             AlphaChannelType
 766               alpha_type;
 767
 768             (void) SyncImageSettings(mogrify_info,*image);
 769             alpha_type=(AlphaChannelType) ParseCommandOption(MagickAlphaOptions,
 770               MagickFalse,argv[i+1]);
 771             (void) SetImageAlphaChannel(*image,alpha_type,exception);
 772             break;
 773           }
 774         if (LocaleCompare("annotate",option+1) == 0)
 775           {
 776             char
 777               *text,
 778               geometry[MaxTextExtent];
 779
 780             /*
 781               Annotate image.
 782             */
 783             (void) SyncImageSettings(mogrify_info,*image);
 784             SetGeometryInfo(&geometry_info);
 785             flags=ParseGeometry(argv[i+1],&geometry_info);
 786             if ((flags & SigmaValue) == 0)
 787               geometry_info.sigma=geometry_info.rho;
 788             text=InterpretImageProperties(mogrify_info,*image,argv[i+2],
 789               exception);
 790             if (text == (char *) NULL)
 791               break;
 792             (void) CloneString(&draw_info->text,text);
 793             text=DestroyString(text);
 794             (void) FormatLocaleString(geometry,MaxTextExtent,"%+f%+f",
 795               geometry_info.xi,geometry_info.psi);
 796             (void) CloneString(&draw_info->geometry,geometry);
 797             draw_info->affine.sx=cos(DegreesToRadians(
 798               fmod(geometry_info.rho,360.0)));
 799             draw_info->affine.rx=sin(DegreesToRadians(
 800               fmod(geometry_info.rho,360.0)));
 801             draw_info->affine.ry=(-sin(DegreesToRadians(
 802               fmod(geometry_info.sigma,360.0))));
 803             draw_info->affine.sy=cos(DegreesToRadians(
 804               fmod(geometry_info.sigma,360.0)));
 805             (void) AnnotateImage(*image,draw_info,exception);
 806             break;
 807           }
 808         if (LocaleCompare("antialias",option+1) == 0)
 809           {
 810             draw_info->stroke_antialias=(*option == '-') ? MagickTrue :
 811               MagickFalse;
 812             draw_info->text_antialias=(*option == '-') ? MagickTrue :
 813               MagickFalse;
 814             break;
 815           }
 816         if (LocaleCompare("auto-gamma",option+1) == 0)
 817           {
 818             /*
 819               Auto Adjust Gamma of image based on its mean
 820             */
 821             (void) SyncImageSettings(mogrify_info,*image);
 822             (void) AutoGammaImage(*image,exception);
 823             break;
 824           }
 825         if (LocaleCompare("auto-level",option+1) == 0)
 826           {
 827             /*
 828               Perfectly Normalize (max/min stretch) the image
 829             */
 830             (void) SyncImageSettings(mogrify_info,*image);
 831             (void) AutoLevelImage(*image,exception);
 832             break;
 833           }
 834         if (LocaleCompare("auto-orient",option+1) == 0)
 835           {
 836             (void) SyncImageSettings(mogrify_info,*image);
 837             switch ((*image)->orientation)
 838             {
 839               case TopRightOrientation:
 840               {
 841                 mogrify_image=FlopImage(*image,exception);
 842                 break;
 843               }
 844               case BottomRightOrientation:
 845               {
 846                 mogrify_image=RotateImage(*image,180.0,exception);
 847                 break;
 848               }
 849               case BottomLeftOrientation:
 850               {
 851                 mogrify_image=FlipImage(*image,exception);
 852                 break;
 853               }
 854               case LeftTopOrientation:
 855               {
 856                 mogrify_image=TransposeImage(*image,exception);
 857                 break;
 858               }
 859               case RightTopOrientation:
 860               {
 861                 mogrify_image=RotateImage(*image,90.0,exception);
 862                 break;
 863               }
 864               case RightBottomOrientation:
 865               {
 866                 mogrify_image=TransverseImage(*image,exception);
 867                 break;
 868               }
 869               case LeftBottomOrientation:
 870               {
 871                 mogrify_image=RotateImage(*image,270.0,exception);
 872                 break;
 873               }
 874               default:
 875                 break;
 876             }
 877             if (mogrify_image != (Image *) NULL)
 878               mogrify_image->orientation=TopLeftOrientation;
 879             break;
 880           }
 881         break;
 882       }
 883       case 'b':
 884       {
 885         if (LocaleCompare("black-threshold",option+1) == 0)
 886           {
 887             /*
 888               Black threshold image.
 889             */
 890             (void) SyncImageSettings(mogrify_info,*image);
 891             (void) BlackThresholdImage(*image,argv[i+1],exception);
 892             InheritException(exception,&(*image)->exception);
 893             break;
 894           }
 895         if (LocaleCompare("blue-shift",option+1) == 0)
 896           {
 897             /*
 898               Blue shift image.
 899             */
 900             (void) SyncImageSettings(mogrify_info,*image);
 901             geometry_info.rho=1.5;
 902             if (*option == '-')
 903               flags=ParseGeometry(argv[i+1],&geometry_info);
 904             mogrify_image=BlueShiftImage(*image,geometry_info.rho,exception);
 905             break;
 906           }
 907         if (LocaleCompare("blur",option+1) == 0)
 908           {
 909             /*
 910               Gaussian blur image.
 911             */
 912             (void) SyncImageSettings(mogrify_info,*image);
 913             flags=ParseGeometry(argv[i+1],&geometry_info);
 914             if ((flags & SigmaValue) == 0)
 915               geometry_info.sigma=1.0;
 916             if ((flags & XiValue) == 0)
 917               geometry_info.xi=0.0;
 918             mogrify_image=BlurImage(*image,geometry_info.rho,
 919               geometry_info.sigma,geometry_info.xi,exception);
 920             break;
 921           }
 922         if (LocaleCompare("border",option+1) == 0)
 923           {
 924             /*
 925               Surround image with a border of solid color.
 926             */
 927             (void) SyncImageSettings(mogrify_info,*image);
 928             flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
 929             if ((flags & SigmaValue) == 0)
 930               geometry.height=geometry.width;
 931             mogrify_image=BorderImage(*image,&geometry,compose,exception);
 932             break;
 933           }
 934         if (LocaleCompare("bordercolor",option+1) == 0)
 935           {
 936             if (*option == '+')
 937               {
 938                 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance,
 939                   &draw_info->border_color,exception);
 940                 break;
 941               }
 942             (void) QueryColorCompliance(argv[i+1],AllCompliance,
 943               &draw_info->border_color,exception);
 944             break;
 945           }
 946         if (LocaleCompare("box",option+1) == 0)
 947           {
 948             (void) QueryColorCompliance(argv[i+1],AllCompliance,
 949               &draw_info->undercolor,exception);
 950             break;
 951           }
 952         if (LocaleCompare("brightness-contrast",option+1) == 0)
 953           {
 954             double
 955               brightness,
 956               contrast;
 957
 958             GeometryInfo
 959               geometry_info;
 960
 961             MagickStatusType
 962               flags;
 963
 964             /*
 965               Brightness / contrast image.
 966             */
 967             (void) SyncImageSettings(mogrify_info,*image);
 968             flags=ParseGeometry(argv[i+1],&geometry_info);
 969             brightness=geometry_info.rho;
 970             contrast=0.0;
 971             if ((flags & SigmaValue) != 0)
 972               contrast=geometry_info.sigma;
 973             (void) BrightnessContrastImage(*image,brightness,contrast,
 974               exception);
 975             InheritException(exception,&(*image)->exception);
 976             break;
 977           }
 978         break;
 979       }
 980       case 'c':
 981       {
 982         if (LocaleCompare("cdl",option+1) == 0)
 983           {
 984             char
 985               *color_correction_collection;
 986
 987             /*
 988               Color correct with a color decision list.
 989             */
 990             (void) SyncImageSettings(mogrify_info,*image);
 991             color_correction_collection=FileToString(argv[i+1],~0,exception);
 992             if (color_correction_collection == (char *) NULL)
 993               break;
 994             (void) ColorDecisionListImage(*image,color_correction_collection,
 995               exception);
 996             InheritException(exception,&(*image)->exception);
 997             break;
 998           }
 999         if (LocaleCompare("channel",option+1) == 0)
1000           {
1001             if (*option == '+')
1002               channel=DefaultChannels;
1003             else
1004               channel=(ChannelType) ParseChannelOption(argv[i+1]);
1005             SetPixelChannelMap(*image,channel);
1006             break;
1007           }
1008         if (LocaleCompare("charcoal",option+1) == 0)
1009           {
1010             /*
1011               Charcoal image.
1012             */
1013             (void) SyncImageSettings(mogrify_info,*image);
1014             flags=ParseGeometry(argv[i+1],&geometry_info);
1015             if ((flags & SigmaValue) == 0)
1016               geometry_info.sigma=1.0;
1017             if ((flags & XiValue) == 0)
1018               geometry_info.xi=1.0;
1019             mogrify_image=CharcoalImage(*image,geometry_info.rho,
1020               geometry_info.sigma,geometry_info.xi,exception);
1021             break;
1022           }
1023         if (LocaleCompare("chop",option+1) == 0)
1024           {
1025             /*
1026               Chop the image.
1027             */
1028             (void) SyncImageSettings(mogrify_info,*image);
1029             (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
1030             mogrify_image=ChopImage(*image,&geometry,exception);
1031             break;
1032           }
1033         if (LocaleCompare("clamp",option+1) == 0)
1034           {
1035             /*
1036               Clamp image.
1037             */
1038             (void) SyncImageSettings(mogrify_info,*image);
1039             (void) ClampImage(*image);
1040             InheritException(exception,&(*image)->exception);
1041             break;
1042           }
1043         if (LocaleCompare("clip",option+1) == 0)
1044           {
1045             (void) SyncImageSettings(mogrify_info,*image);
1046             if (*option == '+')
1047               {
1048                 (void) SetImageClipMask(*image,(Image *) NULL,exception);
1049                 break;
1050               }
1051             (void) ClipImage(*image,exception);
1052             break;
1053           }
1054         if (LocaleCompare("clip-mask",option+1) == 0)
1055           {
1056             CacheView
1057               *mask_view;
1058
1059             Image
1060               *mask_image;
1061
1062             register Quantum
1063               *restrict q;
1064
1065             register ssize_t
1066               x;
1067
1068             ssize_t
1069               y;
1070
1071             (void) SyncImageSettings(mogrify_info,*image);
1072             if (*option == '+')
1073               {
1074                 /*
1075                   Remove a mask.
1076                 */
1077                 (void) SetImageMask(*image,(Image *) NULL,exception);
1078                 break;
1079               }
1080             /*
1081               Set the image mask.
1082               FUTURE: This Should Be a SetImageAlphaChannel() call, Or two.
1083             */
1084             mask_image=GetImageCache(mogrify_info,argv[i+1],exception);
1085             if (mask_image == (Image *) NULL)
1086               break;
1087             if (SetImageStorageClass(mask_image,DirectClass,exception) == MagickFalse)
1088               return(MagickFalse);
1089             mask_view=AcquireCacheView(mask_image);
1090             for (y=0; y < (ssize_t) mask_image->rows; y++)
1091             {
1092               q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1,
1093                 exception);
1094               if (q == (Quantum *) NULL)
1095                 break;
1096               for (x=0; x < (ssize_t) mask_image->columns; x++)
1097               {
1098                 if (mask_image->matte == MagickFalse)
1099                   SetPixelAlpha(mask_image,GetPixelIntensity(mask_image,q),q);
1100                 SetPixelRed(mask_image,GetPixelAlpha(mask_image,q),q);
1101                 SetPixelGreen(mask_image,GetPixelAlpha(mask_image,q),q);
1102                 SetPixelBlue(mask_image,GetPixelAlpha(mask_image,q),q);
1103                 q+=GetPixelChannels(mask_image);
1104               }
1105               if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse)
1106                 break;
1107             }
1108             mask_view=DestroyCacheView(mask_view);
1109             mask_image->matte=MagickTrue;
1110             (void) SetImageClipMask(*image,mask_image,exception);
1111             InheritException(exception,&(*image)->exception);
1112             break;
1113           }
1114         if (LocaleCompare("clip-path",option+1) == 0)
1115           {
1116             (void) SyncImageSettings(mogrify_info,*image);
1117             (void) ClipImagePath(*image,argv[i+1],*option == '-' ? MagickTrue :
1118               MagickFalse,exception);
1119             break;
1120           }
1121         if (LocaleCompare("colorize",option+1) == 0)
1122           {
1123             /*
1124               Colorize the image.
1125             */
1126             (void) SyncImageSettings(mogrify_info,*image);
1127             mogrify_image=ColorizeImage(*image,argv[i+1],&fill,exception);
1128             break;
1129           }
1130         if (LocaleCompare("color-matrix",option+1) == 0)
1131           {
1132             KernelInfo
1133               *kernel;
1134
1135             (void) SyncImageSettings(mogrify_info,*image);
1136             kernel=AcquireKernelInfo(argv[i+1]);
1137             if (kernel == (KernelInfo *) NULL)
1138               break;
1139             mogrify_image=ColorMatrixImage(*image,kernel,exception);
1140             kernel=DestroyKernelInfo(kernel);
1141             break;
1142           }
1143         if (LocaleCompare("colors",option+1) == 0)
1144           {
1145             /*
1146               Reduce the number of colors in the image.
1147             */
1148             (void) SyncImageSettings(mogrify_info,*image);
1149             quantize_info->number_colors=StringToUnsignedLong(argv[i+1]);
1150             if (quantize_info->number_colors == 0)
1151               break;
1152             if (((*image)->storage_class == DirectClass) ||
1153                 (*image)->colors > quantize_info->number_colors)
1154               (void) QuantizeImage(quantize_info,*image,exception);
1155             else
1156               (void) CompressImageColormap(*image,exception);
1157             break;
1158           }
1159         if (LocaleCompare("colorspace",option+1) == 0)
1160           {
1161             ColorspaceType
1162               colorspace;
1163
1164             (void) SyncImageSettings(mogrify_info,*image);
1165             if (*option == '+')
1166               {
1167                 (void) TransformImageColorspace(*image,RGBColorspace);
1168                 InheritException(exception,&(*image)->exception);
1169                 break;
1170               }
1171             colorspace=(ColorspaceType) ParseCommandOption(
1172               MagickColorspaceOptions,MagickFalse,argv[i+1]);
1173             (void) TransformImageColorspace(*image,colorspace);
1174             InheritException(exception,&(*image)->exception);
1175             break;
1176           }
1177         if (LocaleCompare("compose",option+1) == 0)
1178           {
1179             (void) SyncImageSettings(mogrify_info,*image);
1180             compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
1181               MagickFalse,argv[i+1]);
1182             break;
1183           }
1184         if (LocaleCompare("contrast",option+1) == 0)
1185           {
1186             (void) SyncImageSettings(mogrify_info,*image);
1187             (void) ContrastImage(*image,(*option == '-') ? MagickTrue :
1188               MagickFalse,exception);
1189             break;
1190           }
1191         if (LocaleCompare("contrast-stretch",option+1) == 0)
1192           {
1193             double
1194               black_point,
1195               white_point;
1196
1197             MagickStatusType
1198               flags;
1199
1200             /*
1201               Contrast stretch image.
1202             */
1203             (void) SyncImageSettings(mogrify_info,*image);
1204             flags=ParseGeometry(argv[i+1],&geometry_info);
1205             black_point=geometry_info.rho;
1206             white_point=(flags & SigmaValue) != 0 ? geometry_info.sigma :
1207               black_point;
1208             if ((flags & PercentValue) != 0)
1209               {
1210                 black_point*=(double) (*image)->columns*(*image)->rows/100.0;
1211                 white_point*=(double) (*image)->columns*(*image)->rows/100.0;
1212               }
1213             white_point=(MagickRealType) (*image)->columns*(*image)->rows-
1214               white_point;
1215             (void) ContrastStretchImage(*image,black_point,white_point,
1216               exception);
1217             InheritException(exception,&(*image)->exception);
1218             break;
1219           }
1220         if (LocaleCompare("convolve",option+1) == 0)
1221           {
1222             KernelInfo
1223               *kernel_info;
1224
1225             (void) SyncImageSettings(mogrify_info,*image);
1226             kernel_info=AcquireKernelInfo(argv[i+1]);
1227             if (kernel_info == (KernelInfo *) NULL)
1228               break;
1229             kernel_info->bias=(*image)->bias;
1230             mogrify_image=ConvolveImage(*image,kernel_info,exception);
1231             kernel_info=DestroyKernelInfo(kernel_info);
1232             break;
1233           }
1234         if (LocaleCompare("crop",option+1) == 0)
1235           {
1236             /*
1237               Crop a image to a smaller size
1238             */
1239             (void) SyncImageSettings(mogrify_info,*image);
1240             mogrify_image=CropImageToTiles(*image,argv[i+1],exception);
1241             break;
1242           }
1243         if (LocaleCompare("cycle",option+1) == 0)
1244           {
1245             /*
1246               Cycle an image colormap.
1247             */
1248             (void) SyncImageSettings(mogrify_info,*image);
1249             (void) CycleColormapImage(*image,(ssize_t) StringToLong(argv[i+1]),
1250               exception);
1251             break;
1252           }
1253         break;
1254       }
1255       case 'd':
1256       {
1257         if (LocaleCompare("decipher",option+1) == 0)
1258           {
1259             StringInfo
1260               *passkey;
1261
1262             /*
1263               Decipher pixels.
1264             */
1265             (void) SyncImageSettings(mogrify_info,*image);
1266             passkey=FileToStringInfo(argv[i+1],~0,exception);
1267             if (passkey != (StringInfo *) NULL)
1268               {
1269                 (void) PasskeyDecipherImage(*image,passkey,exception);
1270                 passkey=DestroyStringInfo(passkey);
1271               }
1272             break;
1273           }
1274         if (LocaleCompare("density",option+1) == 0)
1275           {
1276             /*
1277               Set image density.
1278             */
1279             (void) CloneString(&draw_info->density,argv[i+1]);
1280             break;
1281           }
1282         if (LocaleCompare("depth",option+1) == 0)
1283           {
1284             (void) SyncImageSettings(mogrify_info,*image);
1285             if (*option == '+')
1286               {
1287                 (void) SetImageDepth(*image,MAGICKCORE_QUANTUM_DEPTH);
1288                 break;
1289               }
1290             (void) SetImageDepth(*image,StringToUnsignedLong(argv[i+1]));
1291             break;
1292           }
1293         if (LocaleCompare("deskew",option+1) == 0)
1294           {
1295             double
1296               threshold;
1297
1298             /*
1299               Straighten the image.
1300             */
1301             (void) SyncImageSettings(mogrify_info,*image);
1302             if (*option == '+')
1303               threshold=40.0*QuantumRange/100.0;
1304             else
1305               threshold=SiPrefixToDouble(argv[i+1],QuantumRange);
1306             mogrify_image=DeskewImage(*image,threshold,exception);
1307             break;
1308           }
1309         if (LocaleCompare("despeckle",option+1) == 0)
1310           {
1311             /*
1312               Reduce the speckles within an image.
1313             */
1314             (void) SyncImageSettings(mogrify_info,*image);
1315             mogrify_image=DespeckleImage(*image,exception);
1316             break;
1317           }
1318         if (LocaleCompare("display",option+1) == 0)
1319           {
1320             (void) CloneString(&draw_info->server_name,argv[i+1]);
1321             break;
1322           }
1323         if (LocaleCompare("distort",option+1) == 0)
1324           {
1325             char
1326               *args,
1327               token[MaxTextExtent];
1328
1329             const char
1330               *p;
1331
1332             DistortImageMethod
1333               method;
1334
1335             double
1336               *arguments;
1337
1338             register ssize_t
1339               x;
1340
1341             size_t
1342               number_arguments;
1343
1344             /*
1345               Distort image.
1346             */
1347             (void) SyncImageSettings(mogrify_info,*image);
1348             method=(DistortImageMethod) ParseCommandOption(MagickDistortOptions,
1349               MagickFalse,argv[i+1]);
1350             if ( method == ResizeDistortion )
1351               {
1352                  /* Special Case - Argument is actually a resize geometry!
1353                  ** Convert that to an appropriate distortion argument array.
1354                  */
1355                  double
1356                    resize_args[2];
1357                  (void) ParseRegionGeometry(*image,argv[i+2],&geometry,
1358                       exception);
1359                  resize_args[0]=(double)geometry.width;
1360                  resize_args[1]=(double)geometry.height;
1361                  mogrify_image=DistortImage(*image,method,(size_t)2,
1362                       resize_args,MagickTrue,exception);
1363                  break;
1364               }
1365             args=InterpretImageProperties(mogrify_info,*image,argv[i+2],
1366               exception);
1367             if (args == (char *) NULL)
1368               break;
1369             p=(char *) args;
1370             for (x=0; *p != '\0'; x++)
1371             {
1372               GetMagickToken(p,&p,token);
1373               if (*token == ',')
1374                 GetMagickToken(p,&p,token);
1375             }
1376             number_arguments=(size_t) x;
1377             arguments=(double *) AcquireQuantumMemory(number_arguments,
1378               sizeof(*arguments));
1379             if (arguments == (double *) NULL)
1380               ThrowWandFatalException(ResourceLimitFatalError,
1381                 "MemoryAllocationFailed",(*image)->filename);
1382             (void) ResetMagickMemory(arguments,0,number_arguments*
1383               sizeof(*arguments));
1384             p=(char *) args;
1385             for (x=0; (x < (ssize_t) number_arguments) && (*p != '\0'); x++)
1386             {
1387               GetMagickToken(p,&p,token);
1388               if (*token == ',')
1389                 GetMagickToken(p,&p,token);
1390               arguments[x]=InterpretLocaleValue(token,(char **) NULL);
1391             }
1392             args=DestroyString(args);
1393             mogrify_image=DistortImage(*image,method,number_arguments,arguments,
1394               (*option == '+') ? MagickTrue : MagickFalse,exception);
1395             arguments=(double *) RelinquishMagickMemory(arguments);
1396             break;
1397           }
1398         if (LocaleCompare("dither",option+1) == 0)
1399           {
1400             if (*option == '+')
1401               {
1402                 quantize_info->dither=MagickFalse;
1403                 break;
1404               }
1405             quantize_info->dither=MagickTrue;
1406             quantize_info->dither_method=(DitherMethod) ParseCommandOption(
1407               MagickDitherOptions,MagickFalse,argv[i+1]);
1408             if (quantize_info->dither_method == NoDitherMethod)
1409               quantize_info->dither=MagickFalse;
1410             break;
1411           }
1412         if (LocaleCompare("draw",option+1) == 0)
1413           {
1414             /*
1415               Draw image.
1416             */
1417             (void) SyncImageSettings(mogrify_info,*image);
1418             (void) CloneString(&draw_info->primitive,argv[i+1]);
1419             (void) DrawImage(*image,draw_info,exception);
1420             break;
1421           }
1422         break;
1423       }
1424       case 'e':
1425       {
1426         if (LocaleCompare("edge",option+1) == 0)
1427           {
1428             /*
1429               Enhance edges in the image.
1430             */
1431             (void) SyncImageSettings(mogrify_info,*image);
1432             flags=ParseGeometry(argv[i+1],&geometry_info);
1433             if ((flags & SigmaValue) == 0)
1434               geometry_info.sigma=1.0;
1435             mogrify_image=EdgeImage(*image,geometry_info.rho,
1436               geometry_info.sigma,exception);
1437             break;
1438           }
1439         if (LocaleCompare("emboss",option+1) == 0)
1440           {
1441             /*
1442               Gaussian embossen image.
1443             */
1444             (void) SyncImageSettings(mogrify_info,*image);
1445             flags=ParseGeometry(argv[i+1],&geometry_info);
1446             if ((flags & SigmaValue) == 0)
1447               geometry_info.sigma=1.0;
1448             mogrify_image=EmbossImage(*image,geometry_info.rho,
1449               geometry_info.sigma,exception);
1450             break;
1451           }
1452         if (LocaleCompare("encipher",option+1) == 0)
1453           {
1454             StringInfo
1455               *passkey;
1456
1457             /*
1458               Encipher pixels.
1459             */
1460             (void) SyncImageSettings(mogrify_info,*image);
1461             passkey=FileToStringInfo(argv[i+1],~0,exception);
1462             if (passkey != (StringInfo *) NULL)
1463               {
1464                 (void) PasskeyEncipherImage(*image,passkey,exception);
1465                 passkey=DestroyStringInfo(passkey);
1466               }
1467             break;
1468           }
1469         if (LocaleCompare("encoding",option+1) == 0)
1470           {
1471             (void) CloneString(&draw_info->encoding,argv[i+1]);
1472             break;
1473           }
1474         if (LocaleCompare("enhance",option+1) == 0)
1475           {
1476             /*
1477               Enhance image.
1478             */
1479             (void) SyncImageSettings(mogrify_info,*image);
1480             mogrify_image=EnhanceImage(*image,exception);
1481             break;
1482           }
1483         if (LocaleCompare("equalize",option+1) == 0)
1484           {
1485             /*
1486               Equalize image.
1487             */
1488             (void) SyncImageSettings(mogrify_info,*image);
1489             (void) EqualizeImage(*image,exception);
1490             break;
1491           }
1492         if (LocaleCompare("evaluate",option+1) == 0)
1493           {
1494             double
1495               constant;
1496
1497             MagickEvaluateOperator
1498               op;
1499
1500             (void) SyncImageSettings(mogrify_info,*image);
1501             op=(MagickEvaluateOperator) ParseCommandOption(
1502               MagickEvaluateOptions,MagickFalse,argv[i+1]);
1503             constant=SiPrefixToDouble(argv[i+2],QuantumRange);
1504             (void) EvaluateImage(*image,op,constant,exception);
1505             break;
1506           }
1507         if (LocaleCompare("extent",option+1) == 0)
1508           {
1509             /*
1510               Set the image extent.
1511             */
1512             (void) SyncImageSettings(mogrify_info,*image);
1513             flags=ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
1514             if (geometry.width == 0)
1515               geometry.width=(*image)->columns;
1516             if (geometry.height == 0)
1517               geometry.height=(*image)->rows;
1518             mogrify_image=ExtentImage(*image,&geometry,exception);
1519             break;
1520           }
1521         break;
1522       }
1523       case 'f':
1524       {
1525         if (LocaleCompare("family",option+1) == 0)
1526           {
1527             if (*option == '+')
1528               {
1529                 if (draw_info->family != (char *) NULL)
1530                   draw_info->family=DestroyString(draw_info->family);
1531                 break;
1532               }
1533             (void) CloneString(&draw_info->family,argv[i+1]);
1534             break;
1535           }
1536         if (LocaleCompare("features",option+1) == 0)
1537           {
1538             if (*option == '+')
1539               {
1540                 (void) DeleteImageArtifact(*image,"identify:features");
1541                 break;
1542               }
1543             (void) SetImageArtifact(*image,"identify:features",argv[i+1]);
1544             break;
1545           }
1546         if (LocaleCompare("fill",option+1) == 0)
1547           {
1548             ExceptionInfo
1549               *sans;
1550
1551             GetPixelInfo(*image,&fill);
1552             if (*option == '+')
1553               {
1554                 (void) QueryMagickColorCompliance("none",AllCompliance,&fill,
1555                   exception);
1556                 (void) QueryColorCompliance("none",AllCompliance,
1557                   &draw_info->fill,exception);
1558                 if (draw_info->fill_pattern != (Image *) NULL)
1559                   draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern);
1560                 break;
1561               }
1562             sans=AcquireExceptionInfo();
1563             (void) QueryMagickColorCompliance(argv[i+1],AllCompliance,&fill,
1564               sans);
1565             status=QueryColorCompliance(argv[i+1],AllCompliance,
1566               &draw_info->fill,sans);
1567             sans=DestroyExceptionInfo(sans);
1568             if (status == MagickFalse)
1569               draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1],
1570                 exception);
1571             break;
1572           }
1573         if (LocaleCompare("flip",option+1) == 0)
1574           {
1575             /*
1576               Flip image scanlines.
1577             */
1578             (void) SyncImageSettings(mogrify_info,*image);
1579             mogrify_image=FlipImage(*image,exception);
1580             break;
1581           }
1582         if (LocaleCompare("floodfill",option+1) == 0)
1583           {
1584             PixelInfo
1585               target;
1586
1587             /*
1588               Floodfill image.
1589             */
1590             (void) SyncImageSettings(mogrify_info,*image);
1591             (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception);
1592             (void) QueryMagickColorCompliance(argv[i+2],AllCompliance,&target,
1593               exception);
1594             (void) FloodfillPaintImage(*image,draw_info,&target,geometry.x,
1595               geometry.y,*option == '-' ? MagickFalse : MagickTrue,exception);
1596             break;
1597           }
1598         if (LocaleCompare("flop",option+1) == 0)
1599           {
1600             /*
1601               Flop image scanlines.
1602             */
1603             (void) SyncImageSettings(mogrify_info,*image);
1604             mogrify_image=FlopImage(*image,exception);
1605             break;
1606           }
1607         if (LocaleCompare("font",option+1) == 0)
1608           {
1609             if (*option == '+')
1610               {
1611                 if (draw_info->font != (char *) NULL)
1612                   draw_info->font=DestroyString(draw_info->font);
1613                 break;
1614               }
1615             (void) CloneString(&draw_info->font,argv[i+1]);
1616             break;
1617           }
1618         if (LocaleCompare("format",option+1) == 0)
1619           {
1620             format=argv[i+1];
1621             break;
1622           }
1623         if (LocaleCompare("frame",option+1) == 0)
1624           {
1625             FrameInfo
1626               frame_info;
1627
1628             /*
1629               Surround image with an ornamental border.
1630             */
1631             (void) SyncImageSettings(mogrify_info,*image);
1632             flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
1633             frame_info.width=geometry.width;
1634             frame_info.height=geometry.height;
1635             if ((flags & HeightValue) == 0)
1636               frame_info.height=geometry.width;
1637             frame_info.outer_bevel=geometry.x;
1638             frame_info.inner_bevel=geometry.y;
1639             frame_info.x=(ssize_t) frame_info.width;
1640             frame_info.y=(ssize_t) frame_info.height;
1641             frame_info.width=(*image)->columns+2*frame_info.width;
1642             frame_info.height=(*image)->rows+2*frame_info.height;
1643             mogrify_image=FrameImage(*image,&frame_info,compose,exception);
1644             break;
1645           }
1646         if (LocaleCompare("function",option+1) == 0)
1647           {
1648             char
1649               *arguments,
1650               token[MaxTextExtent];
1651
1652             const char
1653               *p;
1654
1655             double
1656               *parameters;
1657
1658             MagickFunction
1659               function;
1660
1661             register ssize_t
1662               x;
1663
1664             size_t
1665               number_parameters;
1666
1667             /*
1668               Function Modify Image Values
1669             */
1670             (void) SyncImageSettings(mogrify_info,*image);
1671             function=(MagickFunction) ParseCommandOption(MagickFunctionOptions,
1672               MagickFalse,argv[i+1]);
1673             arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2],
1674               exception);
1675             if (arguments == (char *) NULL)
1676               break;
1677             p=(char *) arguments;
1678             for (x=0; *p != '\0'; x++)
1679             {
1680               GetMagickToken(p,&p,token);
1681               if (*token == ',')
1682                 GetMagickToken(p,&p,token);
1683             }
1684             number_parameters=(size_t) x;
1685             parameters=(double *) AcquireQuantumMemory(number_parameters,
1686               sizeof(*parameters));
1687             if (parameters == (double *) NULL)
1688               ThrowWandFatalException(ResourceLimitFatalError,
1689                 "MemoryAllocationFailed",(*image)->filename);
1690             (void) ResetMagickMemory(parameters,0,number_parameters*
1691               sizeof(*parameters));
1692             p=(char *) arguments;
1693             for (x=0; (x < (ssize_t) number_parameters) && (*p != '\0'); x++)
1694             {
1695               GetMagickToken(p,&p,token);
1696               if (*token == ',')
1697                 GetMagickToken(p,&p,token);
1698               parameters[x]=InterpretLocaleValue(token,(char **) NULL);
1699             }
1700             arguments=DestroyString(arguments);
1701             (void) FunctionImage(*image,function,number_parameters,parameters,
1702               exception);
1703             parameters=(double *) RelinquishMagickMemory(parameters);
1704             break;
1705           }
1706         break;
1707       }
1708       case 'g':
1709       {
1710         if (LocaleCompare("gamma",option+1) == 0)
1711           {
1712             /*
1713               Gamma image.
1714             */
1715             (void) SyncImageSettings(mogrify_info,*image);
1716             if (*option == '+')
1717               (*image)->gamma=InterpretLocaleValue(argv[i+1],(char **) NULL);
1718             else
1719               (void) GammaImage(*image,InterpretLocaleValue(argv[i+1],
1720                 (char **) NULL),exception);
1721             break;
1722           }
1723         if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
1724             (LocaleCompare("gaussian",option+1) == 0))
1725           {
1726             /*
1727               Gaussian blur image.
1728             */
1729             (void) SyncImageSettings(mogrify_info,*image);
1730             flags=ParseGeometry(argv[i+1],&geometry_info);
1731             if ((flags & SigmaValue) == 0)
1732               geometry_info.sigma=1.0;
1733             if ((flags & XiValue) == 0)
1734               geometry_info.xi=0.0;
1735             mogrify_image=GaussianBlurImage(*image,geometry_info.rho,
1736               geometry_info.sigma,geometry_info.xi,exception);
1737             break;
1738           }
1739         if (LocaleCompare("geometry",option+1) == 0)
1740           {
1741               /*
1742                 Record Image offset, Resize last image.
1743               */
1744             (void) SyncImageSettings(mogrify_info,*image);
1745             if (*option == '+')
1746               {
1747                 if ((*image)->geometry != (char *) NULL)
1748                   (*image)->geometry=DestroyString((*image)->geometry);
1749                 break;
1750               }
1751             flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
1752             if (((flags & XValue) != 0) || ((flags & YValue) != 0))
1753               (void) CloneString(&(*image)->geometry,argv[i+1]);
1754             else
1755               mogrify_image=ResizeImage(*image,geometry.width,geometry.height,
1756                 (*image)->filter,(*image)->blur,exception);
1757             break;
1758           }
1759         if (LocaleCompare("gravity",option+1) == 0)
1760           {
1761             if (*option == '+')
1762               {
1763                 draw_info->gravity=UndefinedGravity;
1764                 break;
1765               }
1766             draw_info->gravity=(GravityType) ParseCommandOption(
1767               MagickGravityOptions,MagickFalse,argv[i+1]);
1768             break;
1769           }
1770         break;
1771       }
1772       case 'h':
1773       {
1774         if (LocaleCompare("highlight-color",option+1) == 0)
1775           {
1776             (void) SetImageArtifact(*image,option+1,argv[i+1]);
1777             break;
1778           }
1779         break;
1780       }
1781       case 'i':
1782       {
1783         if (LocaleCompare("identify",option+1) == 0)
1784           {
1785             char
1786               *text;
1787
1788             (void) SyncImageSettings(mogrify_info,*image);
1789             if (format == (char *) NULL)
1790               {
1791                 (void) IdentifyImage(*image,stdout,mogrify_info->verbose,
1792                   exception);
1793                 break;
1794               }
1795             text=InterpretImageProperties(mogrify_info,*image,format,
1796               exception);
1797             if (text == (char *) NULL)
1798               break;
1799             (void) fputs(text,stdout);
1800             (void) fputc('\n',stdout);
1801             text=DestroyString(text);
1802             break;
1803           }
1804         if (LocaleCompare("implode",option+1) == 0)
1805           {
1806             /*
1807               Implode image.
1808             */
1809             (void) SyncImageSettings(mogrify_info,*image);
1810             (void) ParseGeometry(argv[i+1],&geometry_info);
1811             mogrify_image=ImplodeImage(*image,geometry_info.rho,
1812               interpolate_method,exception);
1813             break;
1814           }
1815         if (LocaleCompare("interline-spacing",option+1) == 0)
1816           {
1817             if (*option == '+')
1818               (void) ParseGeometry("0",&geometry_info);
1819             else
1820               (void) ParseGeometry(argv[i+1],&geometry_info);
1821             draw_info->interline_spacing=geometry_info.rho;
1822             break;
1823           }
1824         if (LocaleCompare("interpolate",option+1) == 0)
1825           {
1826             interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
1827               MagickInterpolateOptions,MagickFalse,argv[i+1]);
1828             break;
1829           }
1830         if (LocaleCompare("interword-spacing",option+1) == 0)
1831           {
1832             if (*option == '+')
1833               (void) ParseGeometry("0",&geometry_info);
1834             else
1835               (void) ParseGeometry(argv[i+1],&geometry_info);
1836             draw_info->interword_spacing=geometry_info.rho;
1837             break;
1838           }
1839         break;
1840       }
1841       case 'k':
1842       {
1843         if (LocaleCompare("kerning",option+1) == 0)
1844           {
1845             if (*option == '+')
1846               (void) ParseGeometry("0",&geometry_info);
1847             else
1848               (void) ParseGeometry(argv[i+1],&geometry_info);
1849             draw_info->kerning=geometry_info.rho;
1850             break;
1851           }
1852         break;
1853       }
1854       case 'l':
1855       {
1856         if (LocaleCompare("lat",option+1) == 0)
1857           {
1858             /*
1859               Local adaptive threshold image.
1860             */
1861             (void) SyncImageSettings(mogrify_info,*image);
1862             flags=ParseGeometry(argv[i+1],&geometry_info);
1863             if ((flags & PercentValue) != 0)
1864               geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
1865             mogrify_image=AdaptiveThresholdImage(*image,(size_t)
1866               geometry_info.rho,(size_t) geometry_info.sigma,(double)
1867               geometry_info.xi,exception);
1868             break;
1869           }
1870         if (LocaleCompare("level",option+1) == 0)
1871           {
1872             MagickRealType
1873               black_point,
1874               gamma,
1875               white_point;
1876
1877             MagickStatusType
1878               flags;
1879
1880             /*
1881               Parse levels.
1882             */
1883             (void) SyncImageSettings(mogrify_info,*image);
1884             flags=ParseGeometry(argv[i+1],&geometry_info);
1885             black_point=geometry_info.rho;
1886             white_point=(MagickRealType) QuantumRange;
1887             if ((flags & SigmaValue) != 0)
1888               white_point=geometry_info.sigma;
1889             gamma=1.0;
1890             if ((flags & XiValue) != 0)
1891               gamma=geometry_info.xi;
1892             if ((flags & PercentValue) != 0)
1893               {
1894                 black_point*=(MagickRealType) (QuantumRange/100.0);
1895                 white_point*=(MagickRealType) (QuantumRange/100.0);
1896               }
1897             if ((flags & SigmaValue) == 0)
1898               white_point=(MagickRealType) QuantumRange-black_point;
1899             if ((*option == '+') || ((flags & AspectValue) != 0))
1900               (void) LevelizeImage(*image,black_point,white_point,gamma,
1901                 exception);
1902             else
1903               (void) LevelImage(*image,black_point,white_point,gamma,
1904                 exception);
1905             InheritException(exception,&(*image)->exception);
1906             break;
1907           }
1908         if (LocaleCompare("level-colors",option+1) == 0)
1909           {
1910             char
1911               token[MaxTextExtent];
1912
1913             const char
1914               *p;
1915
1916             PixelInfo
1917               black_point,
1918               white_point;
1919
1920             p=(const char *) argv[i+1];
1921             GetMagickToken(p,&p,token);  /* get black point color */
1922             if ((isalpha((int) *token) != 0) || ((*token == '#') != 0))
1923               (void) QueryMagickColorCompliance(token,AllCompliance,
1924                 &black_point,exception);
1925             else
1926               (void) QueryMagickColorCompliance("#000000",AllCompliance,
1927                 &black_point,exception);
1928             if (isalpha((int) token[0]) || (token[0] == '#'))
1929               GetMagickToken(p,&p,token);
1930             if (*token == '\0')
1931               white_point=black_point; /* set everything to that color */
1932             else
1933               {
1934                 if ((isalpha((int) *token) == 0) && ((*token == '#') == 0))
1935                   GetMagickToken(p,&p,token); /* Get white point color. */
1936                 if ((isalpha((int) *token) != 0) || ((*token == '#') != 0))
1937                   (void) QueryMagickColorCompliance(token,AllCompliance,
1938                     &white_point,exception);
1939                 else
1940                   (void) QueryMagickColorCompliance("#ffffff",AllCompliance,
1941                     &white_point,exception);
1942               }
1943             (void) LevelImageColors(*image,&black_point,&white_point,
1944               *option == '+' ? MagickTrue : MagickFalse,exception);
1945             break;
1946           }
1947         if (LocaleCompare("linear-stretch",option+1) == 0)
1948           {
1949             double
1950               black_point,
1951               white_point;
1952
1953             MagickStatusType
1954               flags;
1955
1956             (void) SyncImageSettings(mogrify_info,*image);
1957             flags=ParseGeometry(argv[i+1],&geometry_info);
1958             black_point=geometry_info.rho;
1959             white_point=(MagickRealType) (*image)->columns*(*image)->rows;
1960             if ((flags & SigmaValue) != 0)
1961               white_point=geometry_info.sigma;
1962             if ((flags & PercentValue) != 0)
1963               {
1964                 black_point*=(double) (*image)->columns*(*image)->rows/100.0;
1965                 white_point*=(double) (*image)->columns*(*image)->rows/100.0;
1966               }
1967             if ((flags & SigmaValue) == 0)
1968               white_point=(MagickRealType) (*image)->columns*(*image)->rows-
1969                 black_point;
1970             (void) LinearStretchImage(*image,black_point,white_point,exception);
1971             InheritException(exception,&(*image)->exception);
1972             break;
1973           }
1974         if (LocaleCompare("linewidth",option+1) == 0)
1975           {
1976             draw_info->stroke_width=InterpretLocaleValue(argv[i+1],
1977               (char **) NULL);
1978             break;
1979           }
1980         if (LocaleCompare("liquid-rescale",option+1) == 0)
1981           {
1982             /*
1983               Liquid rescale image.
1984             */
1985             (void) SyncImageSettings(mogrify_info,*image);
1986             flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
1987             if ((flags & XValue) == 0)
1988               geometry.x=1;
1989             if ((flags & YValue) == 0)
1990               geometry.y=0;
1991             mogrify_image=LiquidRescaleImage(*image,geometry.width,
1992               geometry.height,1.0*geometry.x,1.0*geometry.y,exception);
1993             break;
1994           }
1995         if (LocaleCompare("lowlight-color",option+1) == 0)
1996           {
1997             (void) SetImageArtifact(*image,option+1,argv[i+1]);
1998             break;
1999           }
2000         break;
2001       }
2002       case 'm':
2003       {
2004         if (LocaleCompare("map",option+1) == 0)
2005           {
2006             Image
2007               *remap_image;
2008
2009             /*
2010               Transform image colors to match this set of colors.
2011             */
2012             (void) SyncImageSettings(mogrify_info,*image);
2013             if (*option == '+')
2014               break;
2015             remap_image=GetImageCache(mogrify_info,argv[i+1],exception);
2016             if (remap_image == (Image *) NULL)
2017               break;
2018             (void) RemapImage(quantize_info,*image,remap_image,exception);
2019             remap_image=DestroyImage(remap_image);
2020             break;
2021           }
2022         if (LocaleCompare("mask",option+1) == 0)
2023           {
2024             Image
2025               *mask;
2026
2027             (void) SyncImageSettings(mogrify_info,*image);
2028             if (*option == '+')
2029               {
2030                 /*
2031                   Remove a mask.
2032                 */
2033                 (void) SetImageMask(*image,(Image *) NULL,exception);
2034                 break;
2035               }
2036             /*
2037               Set the image mask.
2038             */
2039             mask=GetImageCache(mogrify_info,argv[i+1],exception);
2040             if (mask == (Image *) NULL)
2041               break;
2042             (void) SetImageMask(*image,mask,exception);
2043             mask=DestroyImage(mask);
2044             break;
2045           }
2046         if (LocaleCompare("matte",option+1) == 0)
2047           {
2048             (void) SetImageAlphaChannel(*image,(*option == '-') ?
2049               SetAlphaChannel : DeactivateAlphaChannel,exception);
2050             break;
2051           }
2052         if (LocaleCompare("median",option+1) == 0)
2053           {
2054             /*
2055               Median filter image.
2056             */
2057             (void) SyncImageSettings(mogrify_info,*image);
2058             flags=ParseGeometry(argv[i+1],&geometry_info);
2059             if ((flags & SigmaValue) == 0)
2060               geometry_info.sigma=geometry_info.rho;
2061             mogrify_image=StatisticImage(*image,MedianStatistic,(size_t)
2062               geometry_info.rho,(size_t) geometry_info.sigma,exception);
2063             break;
2064           }
2065         if (LocaleCompare("mode",option+1) == 0)
2066           {
2067             /*
2068               Mode image.
2069             */
2070             (void) SyncImageSettings(mogrify_info,*image);
2071             flags=ParseGeometry(argv[i+1],&geometry_info);
2072             if ((flags & SigmaValue) == 0)
2073               geometry_info.sigma=geometry_info.rho;
2074             mogrify_image=StatisticImage(*image,ModeStatistic,(size_t)
2075               geometry_info.rho,(size_t) geometry_info.sigma,exception);
2076             break;
2077           }
2078         if (LocaleCompare("modulate",option+1) == 0)
2079           {
2080             (void) SyncImageSettings(mogrify_info,*image);
2081             (void) ModulateImage(*image,argv[i+1],exception);
2082             break;
2083           }
2084         if (LocaleCompare("monitor",option+1) == 0)
2085           {
2086             if (*option == '+')
2087               {
2088                 (void) SetImageProgressMonitor(*image,
2089                   (MagickProgressMonitor) NULL,(void *) NULL);
2090                 break;
2091               }
2092             (void) SetImageProgressMonitor(*image,MonitorProgress,
2093               (void *) NULL);
2094             break;
2095           }
2096         if (LocaleCompare("monochrome",option+1) == 0)
2097           {
2098             (void) SyncImageSettings(mogrify_info,*image);
2099             (void) SetImageType(*image,BilevelType,exception);
2100             break;
2101           }
2102         if (LocaleCompare("morphology",option+1) == 0)
2103           {
2104             char
2105               token[MaxTextExtent];
2106
2107             const char
2108               *p;
2109
2110             KernelInfo
2111               *kernel;
2112
2113             MorphologyMethod
2114               method;
2115
2116             ssize_t
2117               iterations;
2118
2119             /*
2120               Morphological Image Operation
2121             */
2122             (void) SyncImageSettings(mogrify_info,*image);
2123             p=argv[i+1];
2124             GetMagickToken(p,&p,token);
2125             method=(MorphologyMethod) ParseCommandOption(
2126               MagickMorphologyOptions,MagickFalse,token);
2127             iterations=1L;
2128             GetMagickToken(p,&p,token);
2129             if ((*p == ':') || (*p == ','))
2130               GetMagickToken(p,&p,token);
2131             if ((*p != '\0'))
2132               iterations=(ssize_t) StringToLong(p);
2133             kernel=AcquireKernelInfo(argv[i+2]);
2134             if (kernel == (KernelInfo *) NULL)
2135               {
2136                 (void) ThrowMagickException(exception,GetMagickModule(),
2137                   OptionError,"UnabletoParseKernel","morphology");
2138                 status=MagickFalse;
2139                 break;
2140               }
2141             mogrify_image=MorphologyImage(*image,method,iterations,kernel,
2142               exception);
2143             kernel=DestroyKernelInfo(kernel);
2144             break;
2145           }
2146         if (LocaleCompare("motion-blur",option+1) == 0)
2147           {
2148             /*
2149               Motion blur image.
2150             */
2151             (void) SyncImageSettings(mogrify_info,*image);
2152             flags=ParseGeometry(argv[i+1],&geometry_info);
2153             if ((flags & SigmaValue) == 0)
2154               geometry_info.sigma=1.0;
2155             mogrify_image=MotionBlurImage(*image,geometry_info.rho,
2156               geometry_info.sigma,geometry_info.xi,geometry_info.psi,
2157               exception);
2158             break;
2159           }
2160         break;
2161       }
2162       case 'n':
2163       {
2164         if (LocaleCompare("negate",option+1) == 0)
2165           {
2166             (void) SyncImageSettings(mogrify_info,*image);
2167             (void) NegateImage(*image,*option == '+' ? MagickTrue :
2168               MagickFalse,exception);
2169             break;
2170           }
2171         if (LocaleCompare("noise",option+1) == 0)
2172           {
2173             (void) SyncImageSettings(mogrify_info,*image);
2174             if (*option == '-')
2175               {
2176                 flags=ParseGeometry(argv[i+1],&geometry_info);
2177                 if ((flags & SigmaValue) == 0)
2178                   geometry_info.sigma=geometry_info.rho;
2179                 mogrify_image=StatisticImage(*image,NonpeakStatistic,(size_t)
2180                   geometry_info.rho,(size_t) geometry_info.sigma,exception);
2181               }
2182             else
2183               {
2184                 NoiseType
2185                   noise;
2186
2187                 noise=(NoiseType) ParseCommandOption(MagickNoiseOptions,
2188                   MagickFalse,argv[i+1]);
2189                 mogrify_image=AddNoiseImage(*image,noise,exception);
2190               }
2191             break;
2192           }
2193         if (LocaleCompare("normalize",option+1) == 0)
2194           {
2195             (void) SyncImageSettings(mogrify_info,*image);
2196             (void) NormalizeImage(*image,exception);
2197             break;
2198           }
2199         break;
2200       }
2201       case 'o':
2202       {
2203         if (LocaleCompare("opaque",option+1) == 0)
2204           {
2205             PixelInfo
2206               target;
2207
2208             (void) SyncImageSettings(mogrify_info,*image);
2209             (void) QueryMagickColorCompliance(argv[i+1],AllCompliance,&target,
2210               exception);
2211             (void) OpaquePaintImage(*image,&target,&fill,*option == '-' ?
2212               MagickFalse : MagickTrue,exception);
2213             break;
2214           }
2215         if (LocaleCompare("ordered-dither",option+1) == 0)
2216           {
2217             (void) SyncImageSettings(mogrify_info,*image);
2218             (void) OrderedPosterizeImage(*image,argv[i+1],exception);
2219             break;
2220           }
2221         break;
2222       }
2223       case 'p':
2224       {
2225         if (LocaleCompare("paint",option+1) == 0)
2226           {
2227             (void) SyncImageSettings(mogrify_info,*image);
2228             (void) ParseGeometry(argv[i+1],&geometry_info);
2229             mogrify_image=OilPaintImage(*image,geometry_info.rho,
2230               geometry_info.sigma,exception);
2231             break;
2232           }
2233         if (LocaleCompare("pen",option+1) == 0)
2234           {
2235             if (*option == '+')
2236               {
2237                 (void) QueryColorCompliance("none",AllCompliance,
2238                   &draw_info->fill,exception);
2239                 break;
2240               }
2241             (void) QueryColorCompliance(argv[i+1],AllCompliance,
2242               &draw_info->fill,exception);
2243             break;
2244           }
2245         if (LocaleCompare("pointsize",option+1) == 0)
2246           {
2247             if (*option == '+')
2248               (void) ParseGeometry("12",&geometry_info);
2249             else
2250               (void) ParseGeometry(argv[i+1],&geometry_info);
2251             draw_info->pointsize=geometry_info.rho;
2252             break;
2253           }
2254         if (LocaleCompare("polaroid",option+1) == 0)
2255           {
2256             double
2257               angle;
2258
2259             RandomInfo
2260               *random_info;
2261
2262             /*
2263               Simulate a Polaroid picture.
2264             */
2265             (void) SyncImageSettings(mogrify_info,*image);
2266             random_info=AcquireRandomInfo();
2267             angle=22.5*(GetPseudoRandomValue(random_info)-0.5);
2268             random_info=DestroyRandomInfo(random_info);
2269             if (*option == '-')
2270               {
2271                 SetGeometryInfo(&geometry_info);
2272                 flags=ParseGeometry(argv[i+1],&geometry_info);
2273                 angle=geometry_info.rho;
2274               }
2275             mogrify_image=PolaroidImage(*image,draw_info,angle,
2276               interpolate_method,exception);
2277             break;
2278           }
2279         if (LocaleCompare("posterize",option+1) == 0)
2280           {
2281             /*
2282               Posterize image.
2283             */
2284             (void) SyncImageSettings(mogrify_info,*image);
2285             (void) PosterizeImage(*image,StringToUnsignedLong(argv[i+1]),
2286               quantize_info->dither,exception);
2287             break;
2288           }
2289         if (LocaleCompare("preview",option+1) == 0)
2290           {
2291             PreviewType
2292               preview_type;
2293
2294             /*
2295               Preview image.
2296             */
2297             (void) SyncImageSettings(mogrify_info,*image);
2298             if (*option == '+')
2299               preview_type=UndefinedPreview;
2300             else
2301               preview_type=(PreviewType) ParseCommandOption(
2302                 MagickPreviewOptions,MagickFalse,argv[i+1]);
2303             mogrify_image=PreviewImage(*image,preview_type,exception);
2304             break;
2305           }
2306         if (LocaleCompare("profile",option+1) == 0)
2307           {
2308             const char
2309               *name;
2310
2311             const StringInfo
2312               *profile;
2313
2314             Image
2315               *profile_image;
2316
2317             ImageInfo
2318               *profile_info;
2319
2320             (void) SyncImageSettings(mogrify_info,*image);
2321             if (*option == '+')
2322               {
2323                 /*
2324                   Remove a profile from the image.
2325                 */
2326                 (void) ProfileImage(*image,argv[i+1],(const unsigned char *)
2327                   NULL,0,MagickTrue);
2328                 InheritException(exception,&(*image)->exception);
2329                 break;
2330               }
2331             /*
2332               Associate a profile with the image.
2333             */
2334             profile_info=CloneImageInfo(mogrify_info);
2335             profile=GetImageProfile(*image,"iptc");
2336             if (profile != (StringInfo *) NULL)
2337               profile_info->profile=(void *) CloneStringInfo(profile);
2338             profile_image=GetImageCache(profile_info,argv[i+1],exception);
2339             profile_info=DestroyImageInfo(profile_info);
2340             if (profile_image == (Image *) NULL)
2341               {
2342                 StringInfo
2343                   *profile;
2344
2345                 profile_info=CloneImageInfo(mogrify_info);
2346                 (void) CopyMagickString(profile_info->filename,argv[i+1],
2347                   MaxTextExtent);
2348                 profile=FileToStringInfo(profile_info->filename,~0UL,exception);
2349                 if (profile != (StringInfo *) NULL)
2350                   {
2351                     (void) ProfileImage(*image,profile_info->magick,
2352                       GetStringInfoDatum(profile),(size_t)
2353                       GetStringInfoLength(profile),MagickFalse);
2354                     profile=DestroyStringInfo(profile);
2355                   }
2356                 profile_info=DestroyImageInfo(profile_info);
2357                 break;
2358               }
2359             ResetImageProfileIterator(profile_image);
2360             name=GetNextImageProfile(profile_image);
2361             while (name != (const char *) NULL)
2362             {
2363               profile=GetImageProfile(profile_image,name);
2364               if (profile != (StringInfo *) NULL)
2365                 (void) ProfileImage(*image,name,GetStringInfoDatum(profile),
2366                   (size_t) GetStringInfoLength(profile),MagickFalse);
2367               name=GetNextImageProfile(profile_image);
2368             }
2369             profile_image=DestroyImage(profile_image);
2370             break;
2371           }
2372         break;
2373       }
2374       case 'q':
2375       {
2376         if (LocaleCompare("quantize",option+1) == 0)
2377           {
2378             if (*option == '+')
2379               {
2380                 quantize_info->colorspace=UndefinedColorspace;
2381                 break;
2382               }
2383             quantize_info->colorspace=(ColorspaceType) ParseCommandOption(
2384               MagickColorspaceOptions,MagickFalse,argv[i+1]);
2385             break;
2386           }
2387         break;
2388       }
2389       case 'r':
2390       {
2391         if (LocaleCompare("radial-blur",option+1) == 0)
2392           {
2393             /*
2394               Radial blur image.
2395             */
2396             (void) SyncImageSettings(mogrify_info,*image);
2397             flags=ParseGeometry(argv[i+1],&geometry_info);
2398             mogrify_image=RadialBlurImage(*image,geometry_info.rho,
2399               geometry_info.sigma,exception);
2400             break;
2401           }
2402         if (LocaleCompare("raise",option+1) == 0)
2403           {
2404             /*
2405               Surround image with a raise of solid color.
2406             */
2407             flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
2408             if ((flags & SigmaValue) == 0)
2409               geometry.height=geometry.width;
2410             (void) RaiseImage(*image,&geometry,*option == '-' ? MagickTrue :
2411               MagickFalse,exception);
2412             break;
2413           }
2414         if (LocaleCompare("random-threshold",option+1) == 0)
2415           {
2416             /*
2417               Threshold image.
2418             */
2419             (void) SyncImageSettings(mogrify_info,*image);
2420             (void) RandomThresholdImage(*image,argv[i+1],exception);
2421             break;
2422           }
2423         if (LocaleCompare("recolor",option+1) == 0)
2424           {
2425             KernelInfo
2426               *kernel;
2427
2428             (void) SyncImageSettings(mogrify_info,*image);
2429             kernel=AcquireKernelInfo(argv[i+1]);
2430             if (kernel == (KernelInfo *) NULL)
2431               break;
2432             mogrify_image=ColorMatrixImage(*image,kernel,exception);
2433             kernel=DestroyKernelInfo(kernel);
2434             break;
2435           }
2436         if (LocaleCompare("region",option+1) == 0)
2437           {
2438             (void) SyncImageSettings(mogrify_info,*image);
2439             if (region_image != (Image *) NULL)
2440               {
2441                 /*
2442                   Composite region.
2443                 */
2444                 (void) CompositeImage(region_image,region_image->matte !=
2445                    MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
2446                    region_geometry.x,region_geometry.y);
2447                 InheritException(exception,&region_image->exception);
2448                 *image=DestroyImage(*image);
2449                 *image=region_image;
2450                 region_image = (Image *) NULL;
2451               }
2452             if (*option == '+')
2453               break;
2454             /*
2455               Apply transformations to a selected region of the image.
2456             */
2457             (void) ParseGravityGeometry(*image,argv[i+1],&region_geometry,
2458               exception);
2459             mogrify_image=CropImage(*image,&region_geometry,exception);
2460             if (mogrify_image == (Image *) NULL)
2461               break;
2462             region_image=(*image);
2463             *image=mogrify_image;
2464             mogrify_image=(Image *) NULL;
2465             break;
2466           }
2467         if (LocaleCompare("render",option+1) == 0)
2468           {
2469             (void) SyncImageSettings(mogrify_info,*image);
2470             draw_info->render=(*option == '+') ? MagickTrue : MagickFalse;
2471             break;
2472           }
2473         if (LocaleCompare("remap",option+1) == 0)
2474           {
2475             Image
2476               *remap_image;
2477
2478             /*
2479               Transform image colors to match this set of colors.
2480             */
2481             (void) SyncImageSettings(mogrify_info,*image);
2482             if (*option == '+')
2483               break;
2484             remap_image=GetImageCache(mogrify_info,argv[i+1],exception);
2485             if (remap_image == (Image *) NULL)
2486               break;
2487             (void) RemapImage(quantize_info,*image,remap_image,exception);
2488             remap_image=DestroyImage(remap_image);
2489             break;
2490           }
2491         if (LocaleCompare("repage",option+1) == 0)
2492           {
2493             if (*option == '+')
2494               {
2495                 (void) ParseAbsoluteGeometry("0x0+0+0",&(*image)->page);
2496                 break;
2497               }
2498             (void) ResetImagePage(*image,argv[i+1]);
2499             InheritException(exception,&(*image)->exception);
2500             break;
2501           }
2502         if (LocaleCompare("resample",option+1) == 0)
2503           {
2504             /*
2505               Resample image.
2506             */
2507             (void) SyncImageSettings(mogrify_info,*image);
2508             flags=ParseGeometry(argv[i+1],&geometry_info);
2509             if ((flags & SigmaValue) == 0)
2510               geometry_info.sigma=geometry_info.rho;
2511             mogrify_image=ResampleImage(*image,geometry_info.rho,
2512               geometry_info.sigma,(*image)->filter,(*image)->blur,exception);
2513             break;
2514           }
2515         if (LocaleCompare("resize",option+1) == 0)
2516           {
2517             /*
2518               Resize image.
2519             */
2520             (void) SyncImageSettings(mogrify_info,*image);
2521             (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2522             mogrify_image=ResizeImage(*image,geometry.width,geometry.height,
2523               (*image)->filter,(*image)->blur,exception);
2524             break;
2525           }
2526         if (LocaleCompare("roll",option+1) == 0)
2527           {
2528             /*
2529               Roll image.
2530             */
2531             (void) SyncImageSettings(mogrify_info,*image);
2532             (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception);
2533             mogrify_image=RollImage(*image,geometry.x,geometry.y,exception);
2534             break;
2535           }
2536         if (LocaleCompare("rotate",option+1) == 0)
2537           {
2538             char
2539               *geometry;
2540
2541             /*
2542               Check for conditional image rotation.
2543             */
2544             (void) SyncImageSettings(mogrify_info,*image);
2545             if (strchr(argv[i+1],'>') != (char *) NULL)
2546               if ((*image)->columns <= (*image)->rows)
2547                 break;
2548             if (strchr(argv[i+1],'<') != (char *) NULL)
2549               if ((*image)->columns >= (*image)->rows)
2550                 break;
2551             /*
2552               Rotate image.
2553             */
2554             geometry=ConstantString(argv[i+1]);
2555             (void) SubstituteString(&geometry,">","");
2556             (void) SubstituteString(&geometry,"<","");
2557             (void) ParseGeometry(geometry,&geometry_info);
2558             geometry=DestroyString(geometry);
2559             mogrify_image=RotateImage(*image,geometry_info.rho,exception);
2560             break;
2561           }
2562         break;
2563       }
2564       case 's':
2565       {
2566         if (LocaleCompare("sample",option+1) == 0)
2567           {
2568             /*
2569               Sample image with pixel replication.
2570             */
2571             (void) SyncImageSettings(mogrify_info,*image);
2572             (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2573             mogrify_image=SampleImage(*image,geometry.width,geometry.height,
2574               exception);
2575             break;
2576           }
2577         if (LocaleCompare("scale",option+1) == 0)
2578           {
2579             /*
2580               Resize image.
2581             */
2582             (void) SyncImageSettings(mogrify_info,*image);
2583             (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2584             mogrify_image=ScaleImage(*image,geometry.width,geometry.height,
2585               exception);
2586             break;
2587           }
2588         if (LocaleCompare("selective-blur",option+1) == 0)
2589           {
2590             /*
2591               Selectively blur pixels within a contrast threshold.
2592             */
2593             (void) SyncImageSettings(mogrify_info,*image);
2594             flags=ParseGeometry(argv[i+1],&geometry_info);
2595             if ((flags & PercentValue) != 0)
2596               geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
2597             mogrify_image=SelectiveBlurImage(*image,geometry_info.rho,
2598               geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
2599             break;
2600           }
2601         if (LocaleCompare("separate",option+1) == 0)
2602           {
2603             /*
2604               Break channels into separate images.
2605             */
2606             (void) SyncImageSettings(mogrify_info,*image);
2607             mogrify_image=SeparateImages(*image,exception);
2608             break;
2609           }
2610         if (LocaleCompare("sepia-tone",option+1) == 0)
2611           {
2612             double
2613               threshold;
2614
2615             /*
2616               Sepia-tone image.
2617             */
2618             (void) SyncImageSettings(mogrify_info,*image);
2619             threshold=SiPrefixToDouble(argv[i+1],QuantumRange);
2620             mogrify_image=SepiaToneImage(*image,threshold,exception);
2621             break;
2622           }
2623         if (LocaleCompare("segment",option+1) == 0)
2624           {
2625             /*
2626               Segment image.
2627             */
2628             (void) SyncImageSettings(mogrify_info,*image);
2629             flags=ParseGeometry(argv[i+1],&geometry_info);
2630             if ((flags & SigmaValue) == 0)
2631               geometry_info.sigma=1.0;
2632             (void) SegmentImage(*image,(*image)->colorspace,
2633               mogrify_info->verbose,geometry_info.rho,geometry_info.sigma,
2634               exception);
2635             break;
2636           }
2637         if (LocaleCompare("set",option+1) == 0)
2638           {
2639             char
2640               *value;
2641
2642             /*
2643               Set image option.
2644             */
2645             if (*option == '+')
2646               {
2647                 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
2648                   (void) DeleteImageRegistry(argv[i+1]+9);
2649                 else
2650                   if (LocaleNCompare(argv[i+1],"option:",7) == 0)
2651                     {
2652                       (void) DeleteImageOption(mogrify_info,argv[i+1]+7);
2653                       (void) DeleteImageArtifact(*image,argv[i+1]+7);
2654                     }
2655                   else
2656                     (void) DeleteImageProperty(*image,argv[i+1]);
2657                 break;
2658               }
2659             value=InterpretImageProperties(mogrify_info,*image,argv[i+2],
2660               exception);
2661             if (value == (char *) NULL)
2662               break;
2663             if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
2664               (void) SetImageRegistry(StringRegistryType,argv[i+1]+9,value,
2665                 exception);
2666             else
2667               if (LocaleNCompare(argv[i+1],"option:",7) == 0)
2668                 {
2669                   (void) SetImageOption(image_info,argv[i+1]+7,value);
2670                   (void) SetImageOption(mogrify_info,argv[i+1]+7,value);
2671                   (void) SetImageArtifact(*image,argv[i+1]+7,value);
2672                 }
2673               else
2674                 (void) SetImageProperty(*image,argv[i+1],value);
2675             value=DestroyString(value);
2676             break;
2677           }
2678         if (LocaleCompare("shade",option+1) == 0)
2679           {
2680             /*
2681               Shade image.
2682             */
2683             (void) SyncImageSettings(mogrify_info,*image);
2684             flags=ParseGeometry(argv[i+1],&geometry_info);
2685             if ((flags & SigmaValue) == 0)
2686               geometry_info.sigma=1.0;
2687             mogrify_image=ShadeImage(*image,(*option == '-') ? MagickTrue :
2688               MagickFalse,geometry_info.rho,geometry_info.sigma,exception);
2689             break;
2690           }
2691         if (LocaleCompare("shadow",option+1) == 0)
2692           {
2693             /*
2694               Shadow image.
2695             */
2696             (void) SyncImageSettings(mogrify_info,*image);
2697             flags=ParseGeometry(argv[i+1],&geometry_info);
2698             if ((flags & SigmaValue) == 0)
2699               geometry_info.sigma=1.0;
2700             if ((flags & XiValue) == 0)
2701               geometry_info.xi=4.0;
2702             if ((flags & PsiValue) == 0)
2703               geometry_info.psi=4.0;
2704             mogrify_image=ShadowImage(*image,geometry_info.rho,
2705               geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
2706               ceil(geometry_info.psi-0.5),exception);
2707             break;
2708           }
2709         if (LocaleCompare("sharpen",option+1) == 0)
2710           {
2711             /*
2712               Sharpen image.
2713             */
2714             (void) SyncImageSettings(mogrify_info,*image);
2715             flags=ParseGeometry(argv[i+1],&geometry_info);
2716             if ((flags & SigmaValue) == 0)
2717               geometry_info.sigma=1.0;
2718             if ((flags & XiValue) == 0)
2719               geometry_info.xi=0.0;
2720             mogrify_image=SharpenImage(*image,geometry_info.rho,
2721               geometry_info.sigma,geometry_info.xi,exception);
2722             break;
2723           }
2724         if (LocaleCompare("shave",option+1) == 0)
2725           {
2726             /*
2727               Shave the image edges.
2728             */
2729             (void) SyncImageSettings(mogrify_info,*image);
2730             flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
2731             mogrify_image=ShaveImage(*image,&geometry,exception);
2732             break;
2733           }
2734         if (LocaleCompare("shear",option+1) == 0)
2735           {
2736             /*
2737               Shear image.
2738             */
2739             (void) SyncImageSettings(mogrify_info,*image);
2740             flags=ParseGeometry(argv[i+1],&geometry_info);
2741             if ((flags & SigmaValue) == 0)
2742               geometry_info.sigma=geometry_info.rho;
2743             mogrify_image=ShearImage(*image,geometry_info.rho,
2744               geometry_info.sigma,exception);
2745             break;
2746           }
2747         if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
2748           {
2749             /*
2750               Sigmoidal non-linearity contrast control.
2751             */
2752             (void) SyncImageSettings(mogrify_info,*image);
2753             flags=ParseGeometry(argv[i+1],&geometry_info);
2754             if ((flags & SigmaValue) == 0)
2755               geometry_info.sigma=(double) QuantumRange/2.0;
2756             if ((flags & PercentValue) != 0)
2757               geometry_info.sigma=(double) QuantumRange*geometry_info.sigma/
2758                 100.0;
2759             (void) SigmoidalContrastImage(*image,(*option == '-') ?
2760               MagickTrue : MagickFalse,geometry_info.rho,geometry_info.sigma,
2761               exception);
2762             break;
2763           }
2764         if (LocaleCompare("sketch",option+1) == 0)
2765           {
2766             /*
2767               Sketch image.
2768             */
2769             (void) SyncImageSettings(mogrify_info,*image);
2770             flags=ParseGeometry(argv[i+1],&geometry_info);
2771             if ((flags & SigmaValue) == 0)
2772               geometry_info.sigma=1.0;
2773             mogrify_image=SketchImage(*image,geometry_info.rho,
2774               geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
2775             break;
2776           }
2777         if (LocaleCompare("solarize",option+1) == 0)
2778           {
2779             double
2780               threshold;
2781
2782             (void) SyncImageSettings(mogrify_info,*image);
2783             threshold=SiPrefixToDouble(argv[i+1],QuantumRange);
2784             (void) SolarizeImage(*image,threshold,exception);
2785             break;
2786           }
2787         if (LocaleCompare("sparse-color",option+1) == 0)
2788           {
2789             SparseColorMethod
2790               method;
2791
2792             char
2793               *arguments;
2794
2795             /*
2796               Sparse Color Interpolated Gradient
2797             */
2798             (void) SyncImageSettings(mogrify_info,*image);
2799             method=(SparseColorMethod) ParseCommandOption(
2800               MagickSparseColorOptions,MagickFalse,argv[i+1]);
2801             arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2],
2802               exception);
2803             if (arguments == (char *) NULL)
2804               break;
2805             mogrify_image=SparseColorOption(*image,method,arguments,
2806               option[0] == '+' ? MagickTrue : MagickFalse,exception);
2807             arguments=DestroyString(arguments);
2808             break;
2809           }
2810         if (LocaleCompare("splice",option+1) == 0)
2811           {
2812             /*
2813               Splice a solid color into the image.
2814             */
2815             (void) SyncImageSettings(mogrify_info,*image);
2816             (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
2817             mogrify_image=SpliceImage(*image,&geometry,exception);
2818             break;
2819           }
2820         if (LocaleCompare("spread",option+1) == 0)
2821           {
2822             /*
2823               Spread an image.
2824             */
2825             (void) SyncImageSettings(mogrify_info,*image);
2826             (void) ParseGeometry(argv[i+1],&geometry_info);
2827             mogrify_image=SpreadImage(*image,geometry_info.rho,
2828               interpolate_method,exception);
2829             break;
2830           }
2831         if (LocaleCompare("statistic",option+1) == 0)
2832           {
2833             StatisticType
2834               type;
2835
2836             (void) SyncImageSettings(mogrify_info,*image);
2837             type=(StatisticType) ParseCommandOption(MagickStatisticOptions,
2838               MagickFalse,argv[i+1]);
2839             (void) ParseGeometry(argv[i+2],&geometry_info);
2840             mogrify_image=StatisticImage(*image,type,(size_t) geometry_info.rho,
2841               (size_t) geometry_info.sigma,exception);
2842             break;
2843           }
2844         if (LocaleCompare("stretch",option+1) == 0)
2845           {
2846             if (*option == '+')
2847               {
2848                 draw_info->stretch=UndefinedStretch;
2849                 break;
2850               }
2851             draw_info->stretch=(StretchType) ParseCommandOption(
2852               MagickStretchOptions,MagickFalse,argv[i+1]);
2853             break;
2854           }
2855         if (LocaleCompare("strip",option+1) == 0)
2856           {
2857             /*
2858               Strip image of profiles and comments.
2859             */
2860             (void) SyncImageSettings(mogrify_info,*image);
2861             (void) StripImage(*image);
2862             InheritException(exception,&(*image)->exception);
2863             break;
2864           }
2865         if (LocaleCompare("stroke",option+1) == 0)
2866           {
2867             ExceptionInfo
2868               *sans;
2869
2870             if (*option == '+')
2871               {
2872                 (void) QueryColorCompliance("none",AllCompliance,
2873                   &draw_info->stroke,exception);
2874                 if (draw_info->stroke_pattern != (Image *) NULL)
2875                   draw_info->stroke_pattern=DestroyImage(
2876                     draw_info->stroke_pattern);
2877                 break;
2878               }
2879             sans=AcquireExceptionInfo();
2880             status=QueryColorCompliance(argv[i+1],AllCompliance,
2881               &draw_info->stroke,sans);
2882             sans=DestroyExceptionInfo(sans);
2883             if (status == MagickFalse)
2884               draw_info->stroke_pattern=GetImageCache(mogrify_info,argv[i+1],
2885                 exception);
2886             break;
2887           }
2888         if (LocaleCompare("strokewidth",option+1) == 0)
2889           {
2890             draw_info->stroke_width=InterpretLocaleValue(argv[i+1],
2891               (char **) NULL);
2892             break;
2893           }
2894         if (LocaleCompare("style",option+1) == 0)
2895           {
2896             if (*option == '+')
2897               {
2898                 draw_info->style=UndefinedStyle;
2899                 break;
2900               }
2901             draw_info->style=(StyleType) ParseCommandOption(MagickStyleOptions,
2902               MagickFalse,argv[i+1]);
2903             break;
2904           }
2905         if (LocaleCompare("swirl",option+1) == 0)
2906           {
2907             /*
2908               Swirl image.
2909             */
2910             (void) SyncImageSettings(mogrify_info,*image);
2911             (void) ParseGeometry(argv[i+1],&geometry_info);
2912             mogrify_image=SwirlImage(*image,geometry_info.rho,
2913               interpolate_method,exception);
2914             break;
2915           }
2916         break;
2917       }
2918       case 't':
2919       {
2920         if (LocaleCompare("threshold",option+1) == 0)
2921           {
2922             double
2923               threshold;
2924
2925             /*
2926               Threshold image.
2927             */
2928             (void) SyncImageSettings(mogrify_info,*image);
2929             if (*option == '+')
2930               threshold=(double) QuantumRange/2;
2931             else
2932               threshold=SiPrefixToDouble(argv[i+1],QuantumRange);
2933             (void) BilevelImage(*image,threshold);
2934             InheritException(exception,&(*image)->exception);
2935             break;
2936           }
2937         if (LocaleCompare("thumbnail",option+1) == 0)
2938           {
2939             /*
2940               Thumbnail image.
2941             */
2942             (void) SyncImageSettings(mogrify_info,*image);
2943             (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2944             mogrify_image=ThumbnailImage(*image,geometry.width,geometry.height,
2945               exception);
2946             break;
2947           }
2948         if (LocaleCompare("tile",option+1) == 0)
2949           {
2950             if (*option == '+')
2951               {
2952                 if (draw_info->fill_pattern != (Image *) NULL)
2953                   draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern);
2954                 break;
2955               }
2956             draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1],
2957               exception);
2958             break;
2959           }
2960         if (LocaleCompare("tint",option+1) == 0)
2961           {
2962             /*
2963               Tint the image.
2964             */
2965             (void) SyncImageSettings(mogrify_info,*image);
2966             mogrify_image=TintImage(*image,argv[i+1],&fill,exception);
2967             break;
2968           }
2969         if (LocaleCompare("transform",option+1) == 0)
2970           {
2971             /*
2972               Affine transform image.
2973             */
2974             (void) SyncImageSettings(mogrify_info,*image);
2975             mogrify_image=AffineTransformImage(*image,&draw_info->affine,
2976               exception);
2977             break;
2978           }
2979         if (LocaleCompare("transparent",option+1) == 0)
2980           {
2981             PixelInfo
2982               target;
2983
2984             (void) SyncImageSettings(mogrify_info,*image);
2985             (void) QueryMagickColorCompliance(argv[i+1],AllCompliance,&target,
2986               exception);
2987             (void) TransparentPaintImage(*image,&target,(Quantum)
2988               TransparentAlpha,*option == '-' ? MagickFalse : MagickTrue,
2989               &(*image)->exception);
2990             break;
2991           }
2992         if (LocaleCompare("transpose",option+1) == 0)
2993           {
2994             /*
2995               Transpose image scanlines.
2996             */
2997             (void) SyncImageSettings(mogrify_info,*image);
2998             mogrify_image=TransposeImage(*image,exception);
2999             break;
3000           }
3001         if (LocaleCompare("transverse",option+1) == 0)
3002           {
3003             /*
3004               Transverse image scanlines.
3005             */
3006             (void) SyncImageSettings(mogrify_info,*image);
3007             mogrify_image=TransverseImage(*image,exception);
3008             break;
3009           }
3010         if (LocaleCompare("treedepth",option+1) == 0)
3011           {
3012             quantize_info->tree_depth=StringToUnsignedLong(argv[i+1]);
3013             break;
3014           }
3015         if (LocaleCompare("trim",option+1) == 0)
3016           {
3017             /*
3018               Trim image.
3019             */
3020             (void) SyncImageSettings(mogrify_info,*image);
3021             mogrify_image=TrimImage(*image,exception);
3022             break;
3023           }
3024         if (LocaleCompare("type",option+1) == 0)
3025           {
3026             ImageType
3027               type;
3028
3029             (void) SyncImageSettings(mogrify_info,*image);
3030             if (*option == '+')
3031               type=UndefinedType;
3032             else
3033               type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
3034                 argv[i+1]);
3035             (*image)->type=UndefinedType;
3036             (void) SetImageType(*image,type,exception);
3037             break;
3038           }
3039         break;
3040       }
3041       case 'u':
3042       {
3043         if (LocaleCompare("undercolor",option+1) == 0)
3044           {
3045             (void) QueryColorCompliance(argv[i+1],AllCompliance,
3046               &draw_info->undercolor,exception);
3047             break;
3048           }
3049         if (LocaleCompare("unique",option+1) == 0)
3050           {
3051             if (*option == '+')
3052               {
3053                 (void) DeleteImageArtifact(*image,"identify:unique-colors");
3054                 break;
3055               }
3056             (void) SetImageArtifact(*image,"identify:unique-colors","true");
3057             (void) SetImageArtifact(*image,"verbose","true");
3058             break;
3059           }
3060         if (LocaleCompare("unique-colors",option+1) == 0)
3061           {
3062             /*
3063               Unique image colors.
3064             */
3065             (void) SyncImageSettings(mogrify_info,*image);
3066             mogrify_image=UniqueImageColors(*image,exception);
3067             break;
3068           }
3069         if (LocaleCompare("unsharp",option+1) == 0)
3070           {
3071             /*
3072               Unsharp mask image.
3073             */
3074             (void) SyncImageSettings(mogrify_info,*image);
3075             flags=ParseGeometry(argv[i+1],&geometry_info);
3076             if ((flags & SigmaValue) == 0)
3077               geometry_info.sigma=1.0;
3078             if ((flags & XiValue) == 0)
3079               geometry_info.xi=1.0;
3080             if ((flags & PsiValue) == 0)
3081               geometry_info.psi=0.05;
3082             mogrify_image=UnsharpMaskImage(*image,geometry_info.rho,
3083               geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
3084             break;
3085           }
3086         break;
3087       }
3088       case 'v':
3089       {
3090         if (LocaleCompare("verbose",option+1) == 0)
3091           {
3092             (void) SetImageArtifact(*image,option+1,
3093               *option == '+' ? "false" : "true");
3094             break;
3095           }
3096         if (LocaleCompare("vignette",option+1) == 0)
3097           {
3098             /*
3099               Vignette image.
3100             */
3101             (void) SyncImageSettings(mogrify_info,*image);
3102             flags=ParseGeometry(argv[i+1],&geometry_info);
3103             if ((flags & SigmaValue) == 0)
3104               geometry_info.sigma=1.0;
3105             if ((flags & XiValue) == 0)
3106               geometry_info.xi=0.1*(*image)->columns;
3107             if ((flags & PsiValue) == 0)
3108               geometry_info.psi=0.1*(*image)->rows;
3109             mogrify_image=VignetteImage(*image,geometry_info.rho,
3110               geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
3111               ceil(geometry_info.psi-0.5),exception);
3112             break;
3113           }
3114         if (LocaleCompare("virtual-pixel",option+1) == 0)
3115           {
3116             if (*option == '+')
3117               {
3118                 (void) SetImageVirtualPixelMethod(*image,
3119                   UndefinedVirtualPixelMethod);
3120                 break;
3121               }
3122             (void) SetImageVirtualPixelMethod(*image,(VirtualPixelMethod)
3123               ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
3124               argv[i+1]));
3125             break;
3126           }
3127         break;
3128       }
3129       case 'w':
3130       {
3131         if (LocaleCompare("wave",option+1) == 0)
3132           {
3133             /*
3134               Wave image.
3135             */
3136             (void) SyncImageSettings(mogrify_info,*image);
3137             flags=ParseGeometry(argv[i+1],&geometry_info);
3138             if ((flags & SigmaValue) == 0)
3139               geometry_info.sigma=1.0;
3140             mogrify_image=WaveImage(*image,geometry_info.rho,
3141               geometry_info.sigma,interpolate_method,exception);
3142             break;
3143           }
3144         if (LocaleCompare("weight",option+1) == 0)
3145           {
3146             draw_info->weight=StringToUnsignedLong(argv[i+1]);
3147             if (LocaleCompare(argv[i+1],"all") == 0)
3148               draw_info->weight=0;
3149             if (LocaleCompare(argv[i+1],"bold") == 0)
3150               draw_info->weight=700;
3151             if (LocaleCompare(argv[i+1],"bolder") == 0)
3152               if (draw_info->weight <= 800)
3153                 draw_info->weight+=100;
3154             if (LocaleCompare(argv[i+1],"lighter") == 0)
3155               if (draw_info->weight >= 100)
3156                 draw_info->weight-=100;
3157             if (LocaleCompare(argv[i+1],"normal") == 0)
3158               draw_info->weight=400;
3159             break;
3160           }
3161         if (LocaleCompare("white-threshold",option+1) == 0)
3162           {
3163             /*
3164               White threshold image.
3165             */
3166             (void) SyncImageSettings(mogrify_info,*image);
3167             (void) WhiteThresholdImage(*image,argv[i+1],exception);
3168             InheritException(exception,&(*image)->exception);
3169             break;
3170           }
3171         break;
3172       }
3173       default:
3174         break;
3175     }
3176     /*
3177        Replace current image with any image that was generated
3178     */
3179     if (mogrify_image != (Image *) NULL)
3180       ReplaceImageInListReturnLast(image,mogrify_image);
3181     i+=count;
3182   }
3183   if (region_image != (Image *) NULL)
3184     {
3185       /*
3186         Composite transformed region onto image.
3187       */
3188       (void) SyncImageSettings(mogrify_info,*image);
3189       (void) CompositeImage(region_image,region_image->matte !=
3190          MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
3191          region_geometry.x,region_geometry.y);
3192       InheritException(exception,&region_image->exception);
3193       *image=DestroyImage(*image);
3194       *image=region_image;
3195       region_image = (Image *) NULL;
3196     }
3197   /*
3198     Free resources.
3199   */
3200   quantize_info=DestroyQuantizeInfo(quantize_info);
3201   draw_info=DestroyDrawInfo(draw_info);
3202   mogrify_info=DestroyImageInfo(mogrify_info);
3203   status=(MagickStatusType) ((*image)->exception.severity ==
3204     UndefinedException ? 1 : 0);
3205   return(status == 0 ? MagickFalse : MagickTrue);
3206 }
3207 \f
3208 /*
3209 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3210 %                                                                             %
3211 %                                                                             %
3212 %                                                                             %
3213 +    M o g r i f y I m a g e C o m m a n d                                    %
3214 %                                                                             %
3215 %                                                                             %
3216 %                                                                             %
3217 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3218 %
3219 %  MogrifyImageCommand() transforms an image or a sequence of images. These
3220 %  transforms include image scaling, image rotation, color reduction, and
3221 %  others. The transmogrified image overwrites the original image.
3222 %
3223 %  The format of the MogrifyImageCommand method is:
3224 %
3225 %      MagickBooleanType MogrifyImageCommand(ImageInfo *image_info,int argc,
3226 %        const char **argv,char **metadata,ExceptionInfo *exception)
3227 %
3228 %  A description of each parameter follows:
3229 %
3230 %    o image_info: the image info.
3231 %
3232 %    o argc: the number of elements in the argument vector.
3233 %
3234 %    o argv: A text array containing the command line arguments.
3235 %
3236 %    o metadata: any metadata is returned here.
3237 %
3238 %    o exception: return any errors or warnings in this structure.
3239 %
3240 */
3241
3242 static MagickBooleanType MogrifyUsage(void)
3243 {
3244   static const char
3245     *miscellaneous[]=
3246     {
3247       "-debug events        display copious debugging information",
3248       "-help                print program options",
3249       "-list type           print a list of supported option arguments",
3250       "-log format          format of debugging information",
3251       "-version             print version information",
3252       (char *) NULL
3253     },
3254     *operators[]=
3255     {
3256       "-adaptive-blur geometry",
3257       "                     adaptively blur pixels; decrease effect near edges",
3258       "-adaptive-resize geometry",
3259       "                     adaptively resize image using 'mesh' interpolation",
3260       "-adaptive-sharpen geometry",
3261       "                     adaptively sharpen pixels; increase effect near edges",
3262       "-alpha option        on, activate, off, deactivate, set, opaque, copy",
3263       "                     transparent, extract, background, or shape",
3264       "-annotate geometry text",
3265       "                     annotate the image with text",
3266       "-auto-gamma          automagically adjust gamma level of image",
3267       "-auto-level          automagically adjust color levels of image",
3268       "-auto-orient         automagically orient (rotate) image",
3269       "-bench iterations    measure performance",
3270       "-black-threshold value",
3271       "                     force all pixels below the threshold into black",
3272       "-blue-shift          simulate a scene at nighttime in the moonlight",
3273       "-blur geometry       reduce image noise and reduce detail levels",
3274       "-border geometry     surround image with a border of color",
3275       "-bordercolor color   border color",
3276       "-brightness-contrast geometry",
3277       "                     improve brightness / contrast of the image",
3278       "-cdl filename        color correct with a color decision list",
3279       "-charcoal geometry   simulate a charcoal drawing",
3280       "-chop geometry       remove pixels from the image interior",
3281       "-clamp               restrict pixel range from 0 to the quantum depth",
3282       "-clip                clip along the first path from the 8BIM profile",
3283       "-clip-mask filename  associate a clip mask with the image",
3284       "-clip-path id        clip along a named path from the 8BIM profile",
3285       "-colorize value      colorize the image with the fill color",
3286       "-color-matrix matrix apply color correction to the image",
3287       "-contrast            enhance or reduce the image contrast",
3288       "-contrast-stretch geometry",
3289       "                     improve contrast by `stretching' the intensity range",
3290       "-convolve coefficients",
3291       "                     apply a convolution kernel to the image",
3292       "-cycle amount        cycle the image colormap",
3293       "-decipher filename   convert cipher pixels to plain pixels",
3294       "-deskew threshold    straighten an image",
3295       "-despeckle           reduce the speckles within an image",
3296       "-distort method args",
3297       "                     distort images according to given method ad args",
3298       "-draw string         annotate the image with a graphic primitive",
3299       "-edge radius         apply a filter to detect edges in the image",
3300       "-encipher filename   convert plain pixels to cipher pixels",
3301       "-emboss radius       emboss an image",
3302       "-enhance             apply a digital filter to enhance a noisy image",
3303       "-equalize            perform histogram equalization to an image",
3304       "-evaluate operator value",
3305       "                     evaluate an arithmetic, relational, or logical expression",
3306       "-extent geometry     set the image size",
3307       "-extract geometry    extract area from image",
3308       "-fft                 implements the discrete Fourier transform (DFT)",
3309       "-flip                flip image vertically",
3310       "-floodfill geometry color",
3311       "                     floodfill the image with color",
3312       "-flop                flop image horizontally",
3313       "-frame geometry      surround image with an ornamental border",
3314       "-function name parameters",
3315       "                     apply function over image values",
3316       "-gamma value         level of gamma correction",
3317       "-gaussian-blur geometry",
3318       "                     reduce image noise and reduce detail levels",
3319       "-geometry geometry   preferred size or location of the image",
3320       "-identify            identify the format and characteristics of the image",
3321       "-ift                 implements the inverse discrete Fourier transform (DFT)",
3322       "-implode amount      implode image pixels about the center",
3323       "-lat geometry        local adaptive thresholding",
3324       "-layers method       optimize, merge,  or compare image layers",
3325       "-level value         adjust the level of image contrast",
3326       "-level-colors color,color",
3327       "                     level image with the given colors",
3328       "-linear-stretch geometry",
3329       "                     improve contrast by `stretching with saturation'",
3330       "-liquid-rescale geometry",
3331       "                     rescale image with seam-carving",
3332       "-median geometry     apply a median filter to the image",
3333       "-mode geometry       make each pixel the 'predominant color' of the neighborhood",
3334       "-modulate value      vary the brightness, saturation, and hue",
3335       "-monochrome          transform image to black and white",
3336       "-morphology method kernel",
3337       "                     apply a morphology method to the image",
3338       "-motion-blur geometry",
3339       "                     simulate motion blur",
3340       "-negate              replace every pixel with its complementary color ",
3341       "-noise geometry      add or reduce noise in an image",
3342       "-normalize           transform image to span the full range of colors",
3343       "-opaque color        change this color to the fill color",
3344       "-ordered-dither NxN",
3345       "                     add a noise pattern to the image with specific",
3346       "                     amplitudes",
3347       "-paint radius        simulate an oil painting",
3348       "-polaroid angle      simulate a Polaroid picture",
3349       "-posterize levels    reduce the image to a limited number of color levels",
3350       "-profile filename    add, delete, or apply an image profile",
3351       "-quantize colorspace reduce colors in this colorspace",
3352       "-radial-blur angle   radial blur the image",
3353       "-raise value         lighten/darken image edges to create a 3-D effect",
3354       "-random-threshold low,high",
3355       "                     random threshold the image",
3356       "-region geometry     apply options to a portion of the image",
3357       "-render              render vector graphics",
3358       "-repage geometry     size and location of an image canvas",
3359       "-resample geometry   change the resolution of an image",
3360       "-resize geometry     resize the image",
3361       "-roll geometry       roll an image vertically or horizontally",
3362       "-rotate degrees      apply Paeth rotation to the image",
3363       "-sample geometry     scale image with pixel sampling",
3364       "-scale geometry      scale the image",
3365       "-segment values      segment an image",
3366       "-selective-blur geometry",
3367       "                     selectively blur pixels within a contrast threshold",
3368       "-sepia-tone threshold",
3369       "                     simulate a sepia-toned photo",
3370       "-set property value  set an image property",
3371       "-shade degrees       shade the image using a distant light source",
3372       "-shadow geometry     simulate an image shadow",
3373       "-sharpen geometry    sharpen the image",
3374       "-shave geometry      shave pixels from the image edges",
3375       "-shear geometry      slide one edge of the image along the X or Y axis",
3376       "-sigmoidal-contrast geometry",
3377       "                     increase the contrast without saturating highlights or shadows",
3378       "-sketch geometry     simulate a pencil sketch",
3379       "-solarize threshold  negate all pixels above the threshold level",
3380       "-sparse-color method args",
3381       "                     fill in a image based on a few color points",
3382       "-splice geometry     splice the background color into the image",
3383       "-spread radius       displace image pixels by a random amount",
3384       "-statistic type radius",
3385       "                     replace each pixel with corresponding statistic from the neighborhood",
3386       "-strip               strip image of all profiles and comments",
3387       "-swirl degrees       swirl image pixels about the center",
3388       "-threshold value     threshold the image",
3389       "-thumbnail geometry  create a thumbnail of the image",
3390       "-tile filename       tile image when filling a graphic primitive",
3391       "-tint value          tint the image with the fill color",
3392       "-transform           affine transform image",
3393       "-transparent color   make this color transparent within the image",
3394       "-transpose           flip image vertically and rotate 90 degrees",
3395       "-transverse          flop image horizontally and rotate 270 degrees",
3396       "-trim                trim image edges",
3397       "-type type           image type",
3398       "-unique-colors       discard all but one of any pixel color",
3399       "-unsharp geometry    sharpen the image",
3400       "-vignette geometry   soften the edges of the image in vignette style",
3401       "-wave geometry       alter an image along a sine wave",
3402       "-white-threshold value",
3403       "                     force all pixels above the threshold into white",
3404       (char *) NULL
3405     },
3406     *sequence_operators[]=
3407     {
3408       "-append              append an image sequence",
3409       "-clut                apply a color lookup table to the image",
3410       "-coalesce            merge a sequence of images",
3411       "-combine             combine a sequence of images",
3412       "-composite           composite image",
3413       "-crop geometry       cut out a rectangular region of the image",
3414       "-deconstruct         break down an image sequence into constituent parts",
3415       "-evaluate-sequence operator",
3416       "                     evaluate an arithmetic, relational, or logical expression",
3417       "-flatten             flatten a sequence of images",
3418       "-fx expression       apply mathematical expression to an image channel(s)",
3419       "-hald-clut           apply a Hald color lookup table to the image",
3420       "-morph value         morph an image sequence",
3421       "-mosaic              create a mosaic from an image sequence",
3422       "-print string        interpret string and print to console",
3423       "-process arguments   process the image with a custom image filter",
3424       "-separate            separate an image channel into a grayscale image",
3425       "-smush geometry      smush an image sequence together",
3426       "-write filename      write images to this file",
3427       (char *) NULL
3428     },
3429     *settings[]=
3430     {
3431       "-adjoin              join images into a single multi-image file",
3432       "-affine matrix       affine transform matrix",
3433       "-alpha option        activate, deactivate, reset, or set the alpha channel",
3434       "-antialias           remove pixel-aliasing",
3435       "-authenticate password",
3436       "                     decipher image with this password",
3437       "-attenuate value     lessen (or intensify) when adding noise to an image",
3438       "-background color    background color",
3439       "-bias value          add bias when convolving an image",
3440       "-black-point-compensation",
3441       "                     use black point compensation",
3442       "-blue-primary point  chromaticity blue primary point",
3443       "-bordercolor color   border color",
3444       "-caption string      assign a caption to an image",
3445       "-channel type        apply option to select image channels",
3446       "-colors value        preferred number of colors in the image",
3447       "-colorspace type     alternate image colorspace",
3448       "-comment string      annotate image with comment",
3449       "-compose operator    set image composite operator",
3450       "-compress type       type of pixel compression when writing the image",
3451       "-define format:option",
3452       "                     define one or more image format options",
3453       "-delay value         display the next image after pausing",
3454       "-density geometry    horizontal and vertical density of the image",
3455       "-depth value         image depth",
3456       "-direction type      render text right-to-left or left-to-right",
3457       "-display server      get image or font from this X server",
3458       "-dispose method      layer disposal method",
3459       "-dither method       apply error diffusion to image",
3460       "-encoding type       text encoding type",
3461       "-endian type         endianness (MSB or LSB) of the image",
3462       "-family name         render text with this font family",
3463       "-fill color          color to use when filling a graphic primitive",
3464       "-filter type         use this filter when resizing an image",
3465       "-font name           render text with this font",
3466       "-format \"string\"     output formatted image characteristics",
3467       "-fuzz distance       colors within this distance are considered equal",
3468       "-gravity type        horizontal and vertical text placement",
3469       "-green-primary point chromaticity green primary point",
3470       "-intent type         type of rendering intent when managing the image color",
3471       "-interlace type      type of image interlacing scheme",
3472       "-interline-spacing value",
3473       "                     set the space between two text lines",
3474       "-interpolate method  pixel color interpolation method",
3475       "-interword-spacing value",
3476       "                     set the space between two words",
3477       "-kerning value       set the space between two letters",
3478       "-label string        assign a label to an image",
3479       "-limit type value    pixel cache resource limit",
3480       "-loop iterations     add Netscape loop extension to your GIF animation",
3481       "-mask filename       associate a mask with the image",
3482       "-mattecolor color    frame color",
3483       "-monitor             monitor progress",
3484       "-orient type         image orientation",
3485       "-page geometry       size and location of an image canvas (setting)",
3486       "-ping                efficiently determine image attributes",
3487       "-pointsize value     font point size",
3488       "-precision value     maximum number of significant digits to print",
3489       "-preview type        image preview type",
3490       "-quality value       JPEG/MIFF/PNG compression level",
3491       "-quiet               suppress all warning messages",
3492       "-red-primary point   chromaticity red primary point",
3493       "-regard-warnings     pay attention to warning messages",
3494       "-remap filename      transform image colors to match this set of colors",
3495       "-respect-parentheses settings remain in effect until parenthesis boundary",
3496       "-sampling-factor geometry",
3497       "                     horizontal and vertical sampling factor",
3498       "-scene value         image scene number",
3499       "-seed value          seed a new sequence of pseudo-random numbers",
3500       "-size geometry       width and height of image",
3501       "-stretch type        render text with this font stretch",
3502       "-stroke color        graphic primitive stroke color",
3503       "-strokewidth value   graphic primitive stroke width",
3504       "-style type          render text with this font style",
3505       "-synchronize         synchronize image to storage device",
3506       "-taint               declare the image as modified",
3507       "-texture filename    name of texture to tile onto the image background",
3508       "-tile-offset geometry",
3509       "                     tile offset",
3510       "-treedepth value     color tree depth",
3511       "-transparent-color color",
3512       "                     transparent color",
3513       "-undercolor color    annotation bounding box color",
3514       "-units type          the units of image resolution",
3515       "-verbose             print detailed information about the image",
3516       "-view                FlashPix viewing transforms",
3517       "-virtual-pixel method",
3518       "                     virtual pixel access method",
3519       "-weight type         render text with this font weight",
3520       "-white-point point   chromaticity white point",
3521       (char *) NULL
3522     },
3523     *stack_operators[]=
3524     {
3525       "-delete indexes      delete the image from the image sequence",
3526       "-duplicate count,indexes",
3527       "                     duplicate an image one or more times",
3528       "-insert index        insert last image into the image sequence",
3529       "-reverse             reverse image sequence",
3530       "-swap indexes        swap two images in the image sequence",
3531       (char *) NULL
3532     };
3533
3534   const char
3535     **p;
3536
3537   (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL));
3538   (void) printf("Copyright: %s\n",GetMagickCopyright());
3539   (void) printf("Features: %s\n\n",GetMagickFeatures());
3540   (void) printf("Usage: %s [options ...] file [ [options ...] file ...]\n",
3541     GetClientName());
3542   (void) printf("\nImage Settings:\n");
3543   for (p=settings; *p != (char *) NULL; p++)
3544     (void) printf("  %s\n",*p);
3545   (void) printf("\nImage Operators:\n");
3546   for (p=operators; *p != (char *) NULL; p++)
3547     (void) printf("  %s\n",*p);
3548   (void) printf("\nImage Sequence Operators:\n");
3549   for (p=sequence_operators; *p != (char *) NULL; p++)
3550     (void) printf("  %s\n",*p);
3551   (void) printf("\nImage Stack Operators:\n");
3552   for (p=stack_operators; *p != (char *) NULL; p++)
3553     (void) printf("  %s\n",*p);
3554   (void) printf("\nMiscellaneous Options:\n");
3555   for (p=miscellaneous; *p != (char *) NULL; p++)
3556     (void) printf("  %s\n",*p);
3557   (void) printf(
3558     "\nBy default, the image format of `file' is determined by its magic\n");
3559   (void) printf(
3560     "number.  To specify a particular image format, precede the filename\n");
3561   (void) printf(
3562     "with an image format name and a colon (i.e. ps:image) or specify the\n");
3563   (void) printf(
3564     "image type as the filename suffix (i.e. image.ps).  Specify 'file' as\n");
3565   (void) printf("'-' for standard input or output.\n");
3566   return(MagickFalse);
3567 }
3568
3569 WandExport MagickBooleanType MogrifyImageCommand(ImageInfo *image_info,
3570   int argc,char **argv,char **wand_unused(metadata),ExceptionInfo *exception)
3571 {
3572 #define DestroyMogrify() \
3573 { \
3574   if (format != (char *) NULL) \
3575     format=DestroyString(format); \
3576   if (path != (char *) NULL) \
3577     path=DestroyString(path); \
3578   DestroyImageStack(); \
3579   for (i=0; i < (ssize_t) argc; i++) \
3580     argv[i]=DestroyString(argv[i]); \
3581   argv=(char **) RelinquishMagickMemory(argv); \
3582 }
3583 #define ThrowMogrifyException(asperity,tag,option) \
3584 { \
3585   (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
3586     option); \
3587   DestroyMogrify(); \
3588   return(MagickFalse); \
3589 }
3590 #define ThrowMogrifyInvalidArgumentException(option,argument) \
3591 { \
3592   (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
3593     "InvalidArgument","`%s': %s",argument,option); \
3594   DestroyMogrify(); \
3595   return(MagickFalse); \
3596 }
3597
3598   char
3599     *format,
3600     *option,
3601     *path;
3602
3603   Image
3604     *image;
3605
3606   ImageStack
3607     image_stack[MaxImageStackDepth+1];
3608
3609   MagickBooleanType
3610     global_colormap;
3611
3612   MagickBooleanType
3613     fire,
3614     pend,
3615     respect_parenthesis;
3616
3617   MagickStatusType
3618     status;
3619
3620   register ssize_t
3621     i;
3622
3623   ssize_t
3624     j,
3625     k;
3626
3627   /*
3628     Set defaults.
3629   */
3630   assert(image_info != (ImageInfo *) NULL);
3631   assert(image_info->signature == MagickSignature);
3632   if (image_info->debug != MagickFalse)
3633     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3634   assert(exception != (ExceptionInfo *) NULL);
3635   if (argc == 2)
3636     {
3637       option=argv[1];
3638       if ((LocaleCompare("version",option+1) == 0) ||
3639           (LocaleCompare("-version",option+1) == 0))
3640         {
3641           (void) FormatLocaleFile(stdout,"Version: %s\n",
3642             GetMagickVersion((size_t *) NULL));
3643           (void) FormatLocaleFile(stdout,"Copyright: %s\n",
3644             GetMagickCopyright());
3645           (void) FormatLocaleFile(stdout,"Features: %s\n\n",
3646             GetMagickFeatures());
3647           return(MagickFalse);
3648         }
3649     }
3650   if (argc < 2)
3651     return(MogrifyUsage());
3652   format=(char *) NULL;
3653   path=(char *) NULL;
3654   global_colormap=MagickFalse;
3655   k=0;
3656   j=1;
3657   NewImageStack();
3658   option=(char *) NULL;
3659   pend=MagickFalse;
3660   respect_parenthesis=MagickFalse;
3661   status=MagickTrue;
3662   /*
3663     Parse command line.
3664   */
3665   ReadCommandlLine(argc,&argv);
3666   status=ExpandFilenames(&argc,&argv);
3667   if (status == MagickFalse)
3668     ThrowMogrifyException(ResourceLimitError,"MemoryAllocationFailed",
3669       GetExceptionMessage(errno));
3670   for (i=1; i < (ssize_t) argc; i++)
3671   {
3672     option=argv[i];
3673     if (LocaleCompare(option,"(") == 0)
3674       {
3675         FireImageStack(MagickFalse,MagickTrue,pend);
3676         if (k == MaxImageStackDepth)
3677           ThrowMogrifyException(OptionError,"ParenthesisNestedTooDeeply",
3678             option);
3679         PushImageStack();
3680         continue;
3681       }
3682     if (LocaleCompare(option,")") == 0)
3683       {
3684         FireImageStack(MagickFalse,MagickTrue,MagickTrue);
3685         if (k == 0)
3686           ThrowMogrifyException(OptionError,"UnableToParseExpression",option);
3687         PopImageStack();
3688         continue;
3689       }
3690     if (IsCommandOption(option) == MagickFalse)
3691       {
3692         char
3693           backup_filename[MaxTextExtent],
3694           *filename;
3695
3696         Image
3697           *images;
3698
3699         /*
3700           Option is a file name: begin by reading image from specified file.
3701         */
3702         FireImageStack(MagickFalse,MagickFalse,pend);
3703         filename=argv[i];
3704         if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
3705           filename=argv[++i];
3706         (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
3707         images=ReadImages(image_info,exception);
3708         status&=(images != (Image *) NULL) &&
3709           (exception->severity < ErrorException);
3710         if (images == (Image *) NULL)
3711           continue;
3712         if (format != (char *) NULL)
3713           (void) CopyMagickString(images->filename,images->magick_filename,
3714             MaxTextExtent);
3715         if (path != (char *) NULL)
3716           {
3717             GetPathComponent(option,TailPath,filename);
3718             (void) FormatLocaleString(images->filename,MaxTextExtent,"%s%c%s",
3719               path,*DirectorySeparator,filename);
3720           }
3721         if (format != (char *) NULL)
3722           AppendImageFormat(format,images->filename);
3723         AppendImageStack(images);
3724         FinalizeImageSettings(image_info,image,MagickFalse);
3725         if (global_colormap != MagickFalse)
3726           {
3727             QuantizeInfo
3728               *quantize_info;
3729
3730             quantize_info=AcquireQuantizeInfo(image_info);
3731             (void) RemapImages(quantize_info,images,(Image *) NULL,exception);
3732             quantize_info=DestroyQuantizeInfo(quantize_info);
3733           }
3734         *backup_filename='\0';
3735         if ((LocaleCompare(image->filename,"-") != 0) &&
3736             (IsPathWritable(image->filename) != MagickFalse))
3737           {
3738             register ssize_t
3739               i;
3740
3741             /*
3742               Rename image file as backup.
3743             */
3744             (void) CopyMagickString(backup_filename,image->filename,
3745               MaxTextExtent);
3746             for (i=0; i < 6; i++)
3747             {
3748               (void) ConcatenateMagickString(backup_filename,"~",MaxTextExtent);
3749               if (IsPathAccessible(backup_filename) == MagickFalse)
3750                 break;
3751             }
3752             if ((IsPathAccessible(backup_filename) != MagickFalse) ||
3753                 (rename_utf8(image->filename,backup_filename) != 0))
3754               *backup_filename='\0';
3755           }
3756         /*
3757           Write transmogrified image to disk.
3758         */
3759         image_info->synchronize=MagickTrue;
3760         status&=WriteImages(image_info,image,image->filename,exception);
3761         if ((status == MagickFalse) && (*backup_filename != '\0'))
3762           (void) remove_utf8(backup_filename);
3763         RemoveAllImageStack();
3764         continue;
3765       }
3766     pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
3767     switch (*(option+1))
3768     {
3769       case 'a':
3770       {
3771         if (LocaleCompare("adaptive-blur",option+1) == 0)
3772           {
3773             i++;
3774             if (i == (ssize_t) argc)
3775               ThrowMogrifyException(OptionError,"MissingArgument",option);
3776             if (IsGeometry(argv[i]) == MagickFalse)
3777               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3778             break;
3779           }
3780         if (LocaleCompare("adaptive-resize",option+1) == 0)
3781           {
3782             i++;
3783             if (i == (ssize_t) argc)
3784               ThrowMogrifyException(OptionError,"MissingArgument",option);
3785             if (IsGeometry(argv[i]) == MagickFalse)
3786               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3787             break;
3788           }
3789         if (LocaleCompare("adaptive-sharpen",option+1) == 0)
3790           {
3791             i++;
3792             if (i == (ssize_t) argc)
3793               ThrowMogrifyException(OptionError,"MissingArgument",option);
3794             if (IsGeometry(argv[i]) == MagickFalse)
3795               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3796             break;
3797           }
3798         if (LocaleCompare("affine",option+1) == 0)
3799           {
3800             if (*option == '+')
3801               break;
3802             i++;
3803             if (i == (ssize_t) argc)
3804               ThrowMogrifyException(OptionError,"MissingArgument",option);
3805             break;
3806           }
3807         if (LocaleCompare("alpha",option+1) == 0)
3808           {
3809             ssize_t
3810               type;
3811
3812             if (*option == '+')
3813               break;
3814             i++;
3815             if (i == (ssize_t) argc)
3816               ThrowMogrifyException(OptionError,"MissingArgument",option);
3817             type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
3818             if (type < 0)
3819               ThrowMogrifyException(OptionError,"UnrecognizedAlphaChannelType",
3820                 argv[i]);
3821             break;
3822           }
3823         if (LocaleCompare("annotate",option+1) == 0)
3824           {
3825             if (*option == '+')
3826               break;
3827             i++;
3828             if (i == (ssize_t) argc)
3829               ThrowMogrifyException(OptionError,"MissingArgument",option);
3830             if (IsGeometry(argv[i]) == MagickFalse)
3831               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3832             if (i == (ssize_t) argc)
3833               ThrowMogrifyException(OptionError,"MissingArgument",option);
3834             i++;
3835             break;
3836           }
3837         if (LocaleCompare("antialias",option+1) == 0)
3838           break;
3839         if (LocaleCompare("append",option+1) == 0)
3840           break;
3841         if (LocaleCompare("attenuate",option+1) == 0)
3842           {
3843             if (*option == '+')
3844               break;
3845             i++;
3846             if (i == (ssize_t) (argc-1))
3847               ThrowMogrifyException(OptionError,"MissingArgument",option);
3848             if (IsGeometry(argv[i]) == MagickFalse)
3849               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3850             break;
3851           }
3852         if (LocaleCompare("authenticate",option+1) == 0)
3853           {
3854             if (*option == '+')
3855               break;
3856             i++;
3857             if (i == (ssize_t) argc)
3858               ThrowMogrifyException(OptionError,"MissingArgument",option);
3859             break;
3860           }
3861         if (LocaleCompare("auto-gamma",option+1) == 0)
3862           break;
3863         if (LocaleCompare("auto-level",option+1) == 0)
3864           break;
3865         if (LocaleCompare("auto-orient",option+1) == 0)
3866           break;
3867         if (LocaleCompare("average",option+1) == 0)
3868           break;
3869         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
3870       }
3871       case 'b':
3872       {
3873         if (LocaleCompare("background",option+1) == 0)
3874           {
3875             if (*option == '+')
3876               break;
3877             i++;
3878             if (i == (ssize_t) argc)
3879               ThrowMogrifyException(OptionError,"MissingArgument",option);
3880             break;
3881           }
3882         if (LocaleCompare("bias",option+1) == 0)
3883           {
3884             if (*option == '+')
3885               break;
3886             i++;
3887             if (i == (ssize_t) (argc-1))
3888               ThrowMogrifyException(OptionError,"MissingArgument",option);
3889             if (IsGeometry(argv[i]) == MagickFalse)
3890               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3891             break;
3892           }
3893         if (LocaleCompare("black-point-compensation",option+1) == 0)
3894           break;
3895         if (LocaleCompare("black-threshold",option+1) == 0)
3896           {
3897             if (*option == '+')
3898               break;
3899             i++;
3900             if (i == (ssize_t) argc)
3901               ThrowMogrifyException(OptionError,"MissingArgument",option);
3902             if (IsGeometry(argv[i]) == MagickFalse)
3903               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3904             break;
3905           }
3906         if (LocaleCompare("blue-primary",option+1) == 0)
3907           {
3908             if (*option == '+')
3909               break;
3910             i++;
3911             if (i == (ssize_t) argc)
3912               ThrowMogrifyException(OptionError,"MissingArgument",option);
3913             if (IsGeometry(argv[i]) == MagickFalse)
3914               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3915             break;
3916           }
3917         if (LocaleCompare("blue-shift",option+1) == 0)
3918           {
3919             i++;
3920             if (i == (ssize_t) argc)
3921               ThrowMogrifyException(OptionError,"MissingArgument",option);
3922             if (IsGeometry(argv[i]) == MagickFalse)
3923               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3924             break;
3925           }
3926         if (LocaleCompare("blur",option+1) == 0)
3927           {
3928             i++;
3929             if (i == (ssize_t) argc)
3930               ThrowMogrifyException(OptionError,"MissingArgument",option);
3931             if (IsGeometry(argv[i]) == MagickFalse)
3932               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3933             break;
3934           }
3935         if (LocaleCompare("border",option+1) == 0)
3936           {
3937             if (*option == '+')
3938               break;
3939             i++;
3940             if (i == (ssize_t) argc)
3941               ThrowMogrifyException(OptionError,"MissingArgument",option);
3942             if (IsGeometry(argv[i]) == MagickFalse)
3943               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3944             break;
3945           }
3946         if (LocaleCompare("bordercolor",option+1) == 0)
3947           {
3948             if (*option == '+')
3949               break;
3950             i++;
3951             if (i == (ssize_t) argc)
3952               ThrowMogrifyException(OptionError,"MissingArgument",option);
3953             break;
3954           }
3955         if (LocaleCompare("box",option+1) == 0)
3956           {
3957             if (*option == '+')
3958               break;
3959             i++;
3960             if (i == (ssize_t) argc)
3961               ThrowMogrifyException(OptionError,"MissingArgument",option);
3962             break;
3963           }
3964         if (LocaleCompare("brightness-contrast",option+1) == 0)
3965           {
3966             i++;
3967             if (i == (ssize_t) argc)
3968               ThrowMogrifyException(OptionError,"MissingArgument",option);
3969             if (IsGeometry(argv[i]) == MagickFalse)
3970               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3971             break;
3972           }
3973         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
3974       }
3975       case 'c':
3976       {
3977         if (LocaleCompare("cache",option+1) == 0)
3978           {
3979             if (*option == '+')
3980               break;
3981             i++;
3982             if (i == (ssize_t) argc)
3983               ThrowMogrifyException(OptionError,"MissingArgument",option);
3984             if (IsGeometry(argv[i]) == MagickFalse)
3985               ThrowMogrifyInvalidArgumentException(option,argv[i]);
3986             break;
3987           }
3988         if (LocaleCompare("caption",option+1) == 0)
3989           {
3990             if (*option == '+')
3991               break;
3992             i++;
3993             if (i == (ssize_t) argc)
3994               ThrowMogrifyException(OptionError,"MissingArgument",option);
3995             break;
3996           }
3997         if (LocaleCompare("channel",option+1) == 0)
3998           {
3999             ssize_t
4000               channel;
4001
4002             if (*option == '+')
4003               break;
4004             i++;
4005             if (i == (ssize_t) (argc-1))
4006               ThrowMogrifyException(OptionError,"MissingArgument",option);
4007             channel=ParseChannelOption(argv[i]);
4008             if (channel < 0)
4009               ThrowMogrifyException(OptionError,"UnrecognizedChannelType",
4010                 argv[i]);
4011             break;
4012           }
4013         if (LocaleCompare("cdl",option+1) == 0)
4014           {
4015             if (*option == '+')
4016               break;
4017             i++;
4018             if (i == (ssize_t) (argc-1))
4019               ThrowMogrifyException(OptionError,"MissingArgument",option);
4020             break;
4021           }
4022         if (LocaleCompare("charcoal",option+1) == 0)
4023           {
4024             if (*option == '+')
4025               break;
4026             i++;
4027             if (i == (ssize_t) argc)
4028               ThrowMogrifyException(OptionError,"MissingArgument",option);
4029             if (IsGeometry(argv[i]) == MagickFalse)
4030               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4031             break;
4032           }
4033         if (LocaleCompare("chop",option+1) == 0)
4034           {
4035             if (*option == '+')
4036               break;
4037             i++;
4038             if (i == (ssize_t) argc)
4039               ThrowMogrifyException(OptionError,"MissingArgument",option);
4040             if (IsGeometry(argv[i]) == MagickFalse)
4041               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4042             break;
4043           }
4044         if (LocaleCompare("clamp",option+1) == 0)
4045           break;
4046         if (LocaleCompare("clip",option+1) == 0)
4047           break;
4048         if (LocaleCompare("clip-mask",option+1) == 0)
4049           {
4050             if (*option == '+')
4051               break;
4052             i++;
4053             if (i == (ssize_t) argc)
4054               ThrowMogrifyException(OptionError,"MissingArgument",option);
4055             break;
4056           }
4057         if (LocaleCompare("clut",option+1) == 0)
4058           break;
4059         if (LocaleCompare("coalesce",option+1) == 0)
4060           break;
4061         if (LocaleCompare("colorize",option+1) == 0)
4062           {
4063             if (*option == '+')
4064               break;
4065             i++;
4066             if (i == (ssize_t) argc)
4067               ThrowMogrifyException(OptionError,"MissingArgument",option);
4068             if (IsGeometry(argv[i]) == MagickFalse)
4069               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4070             break;
4071           }
4072         if (LocaleCompare("color-matrix",option+1) == 0)
4073           {
4074             KernelInfo
4075               *kernel_info;
4076
4077             if (*option == '+')
4078               break;
4079             i++;
4080             if (i == (ssize_t) (argc-1))
4081               ThrowMogrifyException(OptionError,"MissingArgument",option);
4082             kernel_info=AcquireKernelInfo(argv[i]);
4083             if (kernel_info == (KernelInfo *) NULL)
4084               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4085             kernel_info=DestroyKernelInfo(kernel_info);
4086             break;
4087           }
4088         if (LocaleCompare("colors",option+1) == 0)
4089           {
4090             if (*option == '+')
4091               break;
4092             i++;
4093             if (i == (ssize_t) argc)
4094               ThrowMogrifyException(OptionError,"MissingArgument",option);
4095             if (IsGeometry(argv[i]) == MagickFalse)
4096               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4097             break;
4098           }
4099         if (LocaleCompare("colorspace",option+1) == 0)
4100           {
4101             ssize_t
4102               colorspace;
4103
4104             if (*option == '+')
4105               break;
4106             i++;
4107             if (i == (ssize_t) argc)
4108               ThrowMogrifyException(OptionError,"MissingArgument",option);
4109             colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
4110               argv[i]);
4111             if (colorspace < 0)
4112               ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
4113                 argv[i]);
4114             break;
4115           }
4116         if (LocaleCompare("combine",option+1) == 0)
4117           break;
4118         if (LocaleCompare("comment",option+1) == 0)
4119           {
4120             if (*option == '+')
4121               break;
4122             i++;
4123             if (i == (ssize_t) argc)
4124               ThrowMogrifyException(OptionError,"MissingArgument",option);
4125             break;
4126           }
4127         if (LocaleCompare("composite",option+1) == 0)
4128           break;
4129         if (LocaleCompare("compress",option+1) == 0)
4130           {
4131             ssize_t
4132               compress;
4133
4134             if (*option == '+')
4135               break;
4136             i++;
4137             if (i == (ssize_t) argc)
4138               ThrowMogrifyException(OptionError,"MissingArgument",option);
4139             compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
4140               argv[i]);
4141             if (compress < 0)
4142               ThrowMogrifyException(OptionError,"UnrecognizedImageCompression",
4143                 argv[i]);
4144             break;
4145           }
4146         if (LocaleCompare("concurrent",option+1) == 0)
4147           break;
4148         if (LocaleCompare("contrast",option+1) == 0)
4149           break;
4150         if (LocaleCompare("contrast-stretch",option+1) == 0)
4151           {
4152             i++;
4153             if (i == (ssize_t) argc)
4154               ThrowMogrifyException(OptionError,"MissingArgument",option);
4155             if (IsGeometry(argv[i]) == MagickFalse)
4156               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4157             break;
4158           }
4159         if (LocaleCompare("convolve",option+1) == 0)
4160           {
4161             KernelInfo
4162               *kernel_info;
4163
4164             if (*option == '+')
4165               break;
4166             i++;
4167             if (i == (ssize_t) argc)
4168               ThrowMogrifyException(OptionError,"MissingArgument",option);
4169             kernel_info=AcquireKernelInfo(argv[i]);
4170             if (kernel_info == (KernelInfo *) NULL)
4171               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4172             kernel_info=DestroyKernelInfo(kernel_info);
4173             break;
4174           }
4175         if (LocaleCompare("crop",option+1) == 0)
4176           {
4177             if (*option == '+')
4178               break;
4179             i++;
4180             if (i == (ssize_t) argc)
4181               ThrowMogrifyException(OptionError,"MissingArgument",option);
4182             if (IsGeometry(argv[i]) == MagickFalse)
4183               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4184             break;
4185           }
4186         if (LocaleCompare("cycle",option+1) == 0)
4187           {
4188             if (*option == '+')
4189               break;
4190             i++;
4191             if (i == (ssize_t) argc)
4192               ThrowMogrifyException(OptionError,"MissingArgument",option);
4193             if (IsGeometry(argv[i]) == MagickFalse)
4194               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4195             break;
4196           }
4197         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4198       }
4199       case 'd':
4200       {
4201         if (LocaleCompare("decipher",option+1) == 0)
4202           {
4203             if (*option == '+')
4204               break;
4205             i++;
4206             if (i == (ssize_t) (argc-1))
4207               ThrowMogrifyException(OptionError,"MissingArgument",option);
4208             break;
4209           }
4210         if (LocaleCompare("deconstruct",option+1) == 0)
4211           break;
4212         if (LocaleCompare("debug",option+1) == 0)
4213           {
4214             ssize_t
4215               event;
4216
4217             if (*option == '+')
4218               break;
4219             i++;
4220             if (i == (ssize_t) argc)
4221               ThrowMogrifyException(OptionError,"MissingArgument",option);
4222             event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
4223             if (event < 0)
4224               ThrowMogrifyException(OptionError,"UnrecognizedEventType",
4225                 argv[i]);
4226             (void) SetLogEventMask(argv[i]);
4227             break;
4228           }
4229         if (LocaleCompare("define",option+1) == 0)
4230           {
4231             i++;
4232             if (i == (ssize_t) argc)
4233               ThrowMogrifyException(OptionError,"MissingArgument",option);
4234             if (*option == '+')
4235               {
4236                 const char
4237                   *define;
4238
4239                 define=GetImageOption(image_info,argv[i]);
4240                 if (define == (const char *) NULL)
4241                   ThrowMogrifyException(OptionError,"NoSuchOption",argv[i]);
4242                 break;
4243               }
4244             break;
4245           }
4246         if (LocaleCompare("delay",option+1) == 0)
4247           {
4248             if (*option == '+')
4249               break;
4250             i++;
4251             if (i == (ssize_t) argc)
4252               ThrowMogrifyException(OptionError,"MissingArgument",option);
4253             if (IsGeometry(argv[i]) == MagickFalse)
4254               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4255             break;
4256           }
4257         if (LocaleCompare("delete",option+1) == 0)
4258           {
4259             if (*option == '+')
4260               break;
4261             i++;
4262             if (i == (ssize_t) (argc-1))
4263               ThrowMogrifyException(OptionError,"MissingArgument",option);
4264             if (IsGeometry(argv[i]) == MagickFalse)
4265               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4266             break;
4267           }
4268         if (LocaleCompare("density",option+1) == 0)
4269           {
4270             if (*option == '+')
4271               break;
4272             i++;
4273             if (i == (ssize_t) argc)
4274               ThrowMogrifyException(OptionError,"MissingArgument",option);
4275             if (IsGeometry(argv[i]) == MagickFalse)
4276               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4277             break;
4278           }
4279         if (LocaleCompare("depth",option+1) == 0)
4280           {
4281             if (*option == '+')
4282               break;
4283             i++;
4284             if (i == (ssize_t) argc)
4285               ThrowMogrifyException(OptionError,"MissingArgument",option);
4286             if (IsGeometry(argv[i]) == MagickFalse)
4287               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4288             break;
4289           }
4290         if (LocaleCompare("deskew",option+1) == 0)
4291           {
4292             if (*option == '+')
4293               break;
4294             i++;
4295             if (i == (ssize_t) argc)
4296               ThrowMogrifyException(OptionError,"MissingArgument",option);
4297             if (IsGeometry(argv[i]) == MagickFalse)
4298               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4299             break;
4300           }
4301         if (LocaleCompare("despeckle",option+1) == 0)
4302           break;
4303         if (LocaleCompare("dft",option+1) == 0)
4304           break;
4305         if (LocaleCompare("direction",option+1) == 0)
4306           {
4307             ssize_t
4308               direction;
4309
4310             if (*option == '+')
4311               break;
4312             i++;
4313             if (i == (ssize_t) argc)
4314               ThrowMogrifyException(OptionError,"MissingArgument",option);
4315             direction=ParseCommandOption(MagickDirectionOptions,MagickFalse,
4316               argv[i]);
4317             if (direction < 0)
4318               ThrowMogrifyException(OptionError,"UnrecognizedDirectionType",
4319                 argv[i]);
4320             break;
4321           }
4322         if (LocaleCompare("display",option+1) == 0)
4323           {
4324             if (*option == '+')
4325               break;
4326             i++;
4327             if (i == (ssize_t) argc)
4328               ThrowMogrifyException(OptionError,"MissingArgument",option);
4329             break;
4330           }
4331         if (LocaleCompare("dispose",option+1) == 0)
4332           {
4333             ssize_t
4334               dispose;
4335
4336             if (*option == '+')
4337               break;
4338             i++;
4339             if (i == (ssize_t) argc)
4340               ThrowMogrifyException(OptionError,"MissingArgument",option);
4341             dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,argv[i]);
4342             if (dispose < 0)
4343               ThrowMogrifyException(OptionError,"UnrecognizedDisposeMethod",
4344                 argv[i]);
4345             break;
4346           }
4347         if (LocaleCompare("distort",option+1) == 0)
4348           {
4349             ssize_t
4350               op;
4351
4352             i++;
4353             if (i == (ssize_t) argc)
4354               ThrowMogrifyException(OptionError,"MissingArgument",option);
4355             op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
4356             if (op < 0)
4357               ThrowMogrifyException(OptionError,"UnrecognizedDistortMethod",
4358                 argv[i]);
4359             i++;
4360             if (i == (ssize_t) (argc-1))
4361               ThrowMogrifyException(OptionError,"MissingArgument",option);
4362             break;
4363           }
4364         if (LocaleCompare("dither",option+1) == 0)
4365           {
4366             ssize_t
4367               method;
4368
4369             if (*option == '+')
4370               break;
4371             i++;
4372             if (i == (ssize_t) argc)
4373               ThrowMogrifyException(OptionError,"MissingArgument",option);
4374             method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]);
4375             if (method < 0)
4376               ThrowMogrifyException(OptionError,"UnrecognizedDitherMethod",
4377                 argv[i]);
4378             break;
4379           }
4380         if (LocaleCompare("draw",option+1) == 0)
4381           {
4382             if (*option == '+')
4383               break;
4384             i++;
4385             if (i == (ssize_t) argc)
4386               ThrowMogrifyException(OptionError,"MissingArgument",option);
4387             break;
4388           }
4389         if (LocaleCompare("duplicate",option+1) == 0)
4390           {
4391             if (*option == '+')
4392               break;
4393             i++;
4394             if (i == (ssize_t) (argc-1))
4395               ThrowMogrifyException(OptionError,"MissingArgument",option);
4396             if (IsGeometry(argv[i]) == MagickFalse)
4397               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4398             break;
4399           }
4400         if (LocaleCompare("duration",option+1) == 0)
4401           {
4402             if (*option == '+')
4403               break;
4404             i++;
4405             if (i == (ssize_t) (argc-1))
4406               ThrowMogrifyException(OptionError,"MissingArgument",option);
4407             if (IsGeometry(argv[i]) == MagickFalse)
4408               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4409             break;
4410           }
4411         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4412       }
4413       case 'e':
4414       {
4415         if (LocaleCompare("edge",option+1) == 0)
4416           {
4417             if (*option == '+')
4418               break;
4419             i++;
4420             if (i == (ssize_t) argc)
4421               ThrowMogrifyException(OptionError,"MissingArgument",option);
4422             if (IsGeometry(argv[i]) == MagickFalse)
4423               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4424             break;
4425           }
4426         if (LocaleCompare("emboss",option+1) == 0)
4427           {
4428             if (*option == '+')
4429               break;
4430             i++;
4431             if (i == (ssize_t) argc)
4432               ThrowMogrifyException(OptionError,"MissingArgument",option);
4433             if (IsGeometry(argv[i]) == MagickFalse)
4434               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4435             break;
4436           }
4437         if (LocaleCompare("encipher",option+1) == 0)
4438           {
4439             if (*option == '+')
4440               break;
4441             i++;
4442             if (i == (ssize_t) argc)
4443               ThrowMogrifyException(OptionError,"MissingArgument",option);
4444             break;
4445           }
4446         if (LocaleCompare("encoding",option+1) == 0)
4447           {
4448             if (*option == '+')
4449               break;
4450             i++;
4451             if (i == (ssize_t) argc)
4452               ThrowMogrifyException(OptionError,"MissingArgument",option);
4453             break;
4454           }
4455         if (LocaleCompare("endian",option+1) == 0)
4456           {
4457             ssize_t
4458               endian;
4459
4460             if (*option == '+')
4461               break;
4462             i++;
4463             if (i == (ssize_t) argc)
4464               ThrowMogrifyException(OptionError,"MissingArgument",option);
4465             endian=ParseCommandOption(MagickEndianOptions,MagickFalse,argv[i]);
4466             if (endian < 0)
4467               ThrowMogrifyException(OptionError,"UnrecognizedEndianType",
4468                 argv[i]);
4469             break;
4470           }
4471         if (LocaleCompare("enhance",option+1) == 0)
4472           break;
4473         if (LocaleCompare("equalize",option+1) == 0)
4474           break;
4475         if (LocaleCompare("evaluate",option+1) == 0)
4476           {
4477             ssize_t
4478               op;
4479
4480             if (*option == '+')
4481               break;
4482             i++;
4483             if (i == (ssize_t) argc)
4484               ThrowMogrifyException(OptionError,"MissingArgument",option);
4485             op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
4486             if (op < 0)
4487               ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator",
4488                 argv[i]);
4489             i++;
4490             if (i == (ssize_t) (argc-1))
4491               ThrowMogrifyException(OptionError,"MissingArgument",option);
4492             if (IsGeometry(argv[i]) == MagickFalse)
4493               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4494             break;
4495           }
4496         if (LocaleCompare("evaluate-sequence",option+1) == 0)
4497           {
4498             ssize_t
4499               op;
4500
4501             if (*option == '+')
4502               break;
4503             i++;
4504             if (i == (ssize_t) argc)
4505               ThrowMogrifyException(OptionError,"MissingArgument",option);
4506             op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
4507             if (op < 0)
4508               ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator",
4509                 argv[i]);
4510             break;
4511           }
4512         if (LocaleCompare("extent",option+1) == 0)
4513           {
4514             if (*option == '+')
4515               break;
4516             i++;
4517             if (i == (ssize_t) argc)
4518               ThrowMogrifyException(OptionError,"MissingArgument",option);
4519             if (IsGeometry(argv[i]) == MagickFalse)
4520               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4521             break;
4522           }
4523         if (LocaleCompare("extract",option+1) == 0)
4524           {
4525             if (*option == '+')
4526               break;
4527             i++;
4528             if (i == (ssize_t) argc)
4529               ThrowMogrifyException(OptionError,"MissingArgument",option);
4530             if (IsGeometry(argv[i]) == MagickFalse)
4531               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4532             break;
4533           }
4534         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4535       }
4536       case 'f':
4537       {
4538         if (LocaleCompare("family",option+1) == 0)
4539           {
4540             if (*option == '+')
4541               break;
4542             i++;
4543             if (i == (ssize_t) (argc-1))
4544               ThrowMogrifyException(OptionError,"MissingArgument",option);
4545             break;
4546           }
4547         if (LocaleCompare("fill",option+1) == 0)
4548           {
4549             if (*option == '+')
4550               break;
4551             i++;
4552             if (i == (ssize_t) argc)
4553               ThrowMogrifyException(OptionError,"MissingArgument",option);
4554             break;
4555           }
4556         if (LocaleCompare("filter",option+1) == 0)
4557           {
4558             ssize_t
4559               filter;
4560
4561             if (*option == '+')
4562               break;
4563             i++;
4564             if (i == (ssize_t) argc)
4565               ThrowMogrifyException(OptionError,"MissingArgument",option);
4566             filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]);
4567             if (filter < 0)
4568               ThrowMogrifyException(OptionError,"UnrecognizedImageFilter",
4569                 argv[i]);
4570             break;
4571           }
4572         if (LocaleCompare("flatten",option+1) == 0)
4573           break;
4574         if (LocaleCompare("flip",option+1) == 0)
4575           break;
4576         if (LocaleCompare("flop",option+1) == 0)
4577           break;
4578         if (LocaleCompare("floodfill",option+1) == 0)
4579           {
4580             if (*option == '+')
4581               break;
4582             i++;
4583             if (i == (ssize_t) argc)
4584               ThrowMogrifyException(OptionError,"MissingArgument",option);
4585             if (IsGeometry(argv[i]) == MagickFalse)
4586               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4587             i++;
4588             if (i == (ssize_t) argc)
4589               ThrowMogrifyException(OptionError,"MissingArgument",option);
4590             break;
4591           }
4592         if (LocaleCompare("font",option+1) == 0)
4593           {
4594             if (*option == '+')
4595               break;
4596             i++;
4597             if (i == (ssize_t) argc)
4598               ThrowMogrifyException(OptionError,"MissingArgument",option);
4599             break;
4600           }
4601         if (LocaleCompare("format",option+1) == 0)
4602           {
4603             (void) CopyMagickString(argv[i]+1,"sans",MaxTextExtent);
4604             (void) CloneString(&format,(char *) NULL);
4605             if (*option == '+')
4606               break;
4607             i++;
4608             if (i == (ssize_t) argc)
4609               ThrowMogrifyException(OptionError,"MissingArgument",option);
4610             (void) CloneString(&format,argv[i]);
4611             (void) CopyMagickString(image_info->filename,format,MaxTextExtent);
4612             (void) ConcatenateMagickString(image_info->filename,":",
4613               MaxTextExtent);
4614             (void) SetImageInfo(image_info,0,exception);
4615             if (*image_info->magick == '\0')
4616               ThrowMogrifyException(OptionError,"UnrecognizedImageFormat",
4617                 format);
4618             break;
4619           }
4620         if (LocaleCompare("frame",option+1) == 0)
4621           {
4622             if (*option == '+')
4623               break;
4624             i++;
4625             if (i == (ssize_t) argc)
4626               ThrowMogrifyException(OptionError,"MissingArgument",option);
4627             if (IsGeometry(argv[i]) == MagickFalse)
4628               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4629             break;
4630           }
4631         if (LocaleCompare("function",option+1) == 0)
4632           {
4633             ssize_t
4634               op;
4635
4636             if (*option == '+')
4637               break;
4638             i++;
4639             if (i == (ssize_t) argc)
4640               ThrowMogrifyException(OptionError,"MissingArgument",option);
4641             op=ParseCommandOption(MagickFunctionOptions,MagickFalse,argv[i]);
4642             if (op < 0)
4643               ThrowMogrifyException(OptionError,"UnrecognizedFunction",argv[i]);
4644              i++;
4645              if (i == (ssize_t) (argc-1))
4646                ThrowMogrifyException(OptionError,"MissingArgument",option);
4647             break;
4648           }
4649         if (LocaleCompare("fuzz",option+1) == 0)
4650           {
4651             if (*option == '+')
4652               break;
4653             i++;
4654             if (i == (ssize_t) argc)
4655               ThrowMogrifyException(OptionError,"MissingArgument",option);
4656             if (IsGeometry(argv[i]) == MagickFalse)
4657               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4658             break;
4659           }
4660         if (LocaleCompare("fx",option+1) == 0)
4661           {
4662             if (*option == '+')
4663               break;
4664             i++;
4665             if (i == (ssize_t) (argc-1))
4666               ThrowMogrifyException(OptionError,"MissingArgument",option);
4667             break;
4668           }
4669         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4670       }
4671       case 'g':
4672       {
4673         if (LocaleCompare("gamma",option+1) == 0)
4674           {
4675             i++;
4676             if (i == (ssize_t) argc)
4677               ThrowMogrifyException(OptionError,"MissingArgument",option);
4678             if (IsGeometry(argv[i]) == MagickFalse)
4679               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4680             break;
4681           }
4682         if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
4683             (LocaleCompare("gaussian",option+1) == 0))
4684           {
4685             i++;
4686             if (i == (ssize_t) argc)
4687               ThrowMogrifyException(OptionError,"MissingArgument",option);
4688             if (IsGeometry(argv[i]) == MagickFalse)
4689               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4690             break;
4691           }
4692         if (LocaleCompare("geometry",option+1) == 0)
4693           {
4694             if (*option == '+')
4695               break;
4696             i++;
4697             if (i == (ssize_t) argc)
4698               ThrowMogrifyException(OptionError,"MissingArgument",option);
4699             if (IsGeometry(argv[i]) == MagickFalse)
4700               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4701             break;
4702           }
4703         if (LocaleCompare("gravity",option+1) == 0)
4704           {
4705             ssize_t
4706               gravity;
4707
4708             if (*option == '+')
4709               break;
4710             i++;
4711             if (i == (ssize_t) argc)
4712               ThrowMogrifyException(OptionError,"MissingArgument",option);
4713             gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,argv[i]);
4714             if (gravity < 0)
4715               ThrowMogrifyException(OptionError,"UnrecognizedGravityType",
4716                 argv[i]);
4717             break;
4718           }
4719         if (LocaleCompare("green-primary",option+1) == 0)
4720           {
4721             if (*option == '+')
4722               break;
4723             i++;
4724             if (i == (ssize_t) argc)
4725               ThrowMogrifyException(OptionError,"MissingArgument",option);
4726             if (IsGeometry(argv[i]) == MagickFalse)
4727               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4728             break;
4729           }
4730         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4731       }
4732       case 'h':
4733       {
4734         if (LocaleCompare("hald-clut",option+1) == 0)
4735           break;
4736         if ((LocaleCompare("help",option+1) == 0) ||
4737             (LocaleCompare("-help",option+1) == 0))
4738           return(MogrifyUsage());
4739         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4740       }
4741       case 'i':
4742       {
4743         if (LocaleCompare("identify",option+1) == 0)
4744           break;
4745         if (LocaleCompare("idft",option+1) == 0)
4746           break;
4747         if (LocaleCompare("implode",option+1) == 0)
4748           {
4749             if (*option == '+')
4750               break;
4751             i++;
4752             if (i == (ssize_t) argc)
4753               ThrowMogrifyException(OptionError,"MissingArgument",option);
4754             if (IsGeometry(argv[i]) == MagickFalse)
4755               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4756             break;
4757           }
4758         if (LocaleCompare("intent",option+1) == 0)
4759           {
4760             ssize_t
4761               intent;
4762
4763             if (*option == '+')
4764               break;
4765             i++;
4766             if (i == (ssize_t) (argc-1))
4767               ThrowMogrifyException(OptionError,"MissingArgument",option);
4768             intent=ParseCommandOption(MagickIntentOptions,MagickFalse,argv[i]);
4769             if (intent < 0)
4770               ThrowMogrifyException(OptionError,"UnrecognizedIntentType",
4771                 argv[i]);
4772             break;
4773           }
4774         if (LocaleCompare("interlace",option+1) == 0)
4775           {
4776             ssize_t
4777               interlace;
4778
4779             if (*option == '+')
4780               break;
4781             i++;
4782             if (i == (ssize_t) argc)
4783               ThrowMogrifyException(OptionError,"MissingArgument",option);
4784             interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
4785               argv[i]);
4786             if (interlace < 0)
4787               ThrowMogrifyException(OptionError,"UnrecognizedInterlaceType",
4788                 argv[i]);
4789             break;
4790           }
4791         if (LocaleCompare("interline-spacing",option+1) == 0)
4792           {
4793             if (*option == '+')
4794               break;
4795             i++;
4796             if (i == (ssize_t) (argc-1))
4797               ThrowMogrifyException(OptionError,"MissingArgument",option);
4798             if (IsGeometry(argv[i]) == MagickFalse)
4799               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4800             break;
4801           }
4802         if (LocaleCompare("interpolate",option+1) == 0)
4803           {
4804             ssize_t
4805               interpolate;
4806
4807             if (*option == '+')
4808               break;
4809             i++;
4810             if (i == (ssize_t) argc)
4811               ThrowMogrifyException(OptionError,"MissingArgument",option);
4812             interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
4813               argv[i]);
4814             if (interpolate < 0)
4815               ThrowMogrifyException(OptionError,"UnrecognizedInterpolateMethod",
4816                 argv[i]);
4817             break;
4818           }
4819         if (LocaleCompare("interword-spacing",option+1) == 0)
4820           {
4821             if (*option == '+')
4822               break;
4823             i++;
4824             if (i == (ssize_t) (argc-1))
4825               ThrowMogrifyException(OptionError,"MissingArgument",option);
4826             if (IsGeometry(argv[i]) == MagickFalse)
4827               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4828             break;
4829           }
4830         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4831       }
4832       case 'k':
4833       {
4834         if (LocaleCompare("kerning",option+1) == 0)
4835           {
4836             if (*option == '+')
4837               break;
4838             i++;
4839             if (i == (ssize_t) (argc-1))
4840               ThrowMogrifyException(OptionError,"MissingArgument",option);
4841             if (IsGeometry(argv[i]) == MagickFalse)
4842               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4843             break;
4844           }
4845         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4846       }
4847       case 'l':
4848       {
4849         if (LocaleCompare("label",option+1) == 0)
4850           {
4851             if (*option == '+')
4852               break;
4853             i++;
4854             if (i == (ssize_t) argc)
4855               ThrowMogrifyException(OptionError,"MissingArgument",option);
4856             break;
4857           }
4858         if (LocaleCompare("lat",option+1) == 0)
4859           {
4860             if (*option == '+')
4861               break;
4862             i++;
4863             if (i == (ssize_t) argc)
4864               ThrowMogrifyException(OptionError,"MissingArgument",option);
4865             if (IsGeometry(argv[i]) == MagickFalse)
4866               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4867           }
4868         if (LocaleCompare("layers",option+1) == 0)
4869           {
4870             ssize_t
4871               type;
4872
4873             if (*option == '+')
4874               break;
4875             i++;
4876             if (i == (ssize_t) (argc-1))
4877               ThrowMogrifyException(OptionError,"MissingArgument",option);
4878             type=ParseCommandOption(MagickLayerOptions,MagickFalse,argv[i]);
4879             if (type < 0)
4880               ThrowMogrifyException(OptionError,"UnrecognizedLayerMethod",
4881                 argv[i]);
4882             break;
4883           }
4884         if (LocaleCompare("level",option+1) == 0)
4885           {
4886             i++;
4887             if (i == (ssize_t) argc)
4888               ThrowMogrifyException(OptionError,"MissingArgument",option);
4889             if (IsGeometry(argv[i]) == MagickFalse)
4890               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4891             break;
4892           }
4893         if (LocaleCompare("level-colors",option+1) == 0)
4894           {
4895             i++;
4896             if (i == (ssize_t) argc)
4897               ThrowMogrifyException(OptionError,"MissingArgument",option);
4898             break;
4899           }
4900         if (LocaleCompare("linewidth",option+1) == 0)
4901           {
4902             if (*option == '+')
4903               break;
4904             i++;
4905             if (i == (ssize_t) argc)
4906               ThrowMogrifyException(OptionError,"MissingArgument",option);
4907             if (IsGeometry(argv[i]) == MagickFalse)
4908               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4909             break;
4910           }
4911         if (LocaleCompare("limit",option+1) == 0)
4912           {
4913             char
4914               *p;
4915
4916             double
4917               value;
4918
4919             ssize_t
4920               resource;
4921
4922             if (*option == '+')
4923               break;
4924             i++;
4925             if (i == (ssize_t) argc)
4926               ThrowMogrifyException(OptionError,"MissingArgument",option);
4927             resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
4928               argv[i]);
4929             if (resource < 0)
4930               ThrowMogrifyException(OptionError,"UnrecognizedResourceType",
4931                 argv[i]);
4932             i++;
4933             if (i == (ssize_t) argc)
4934               ThrowMogrifyException(OptionError,"MissingArgument",option);
4935             value=InterpretLocaleValue(argv[i],&p);
4936             (void) value;
4937             if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
4938               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4939             break;
4940           }
4941         if (LocaleCompare("liquid-rescale",option+1) == 0)
4942           {
4943             i++;
4944             if (i == (ssize_t) argc)
4945               ThrowMogrifyException(OptionError,"MissingArgument",option);
4946             if (IsGeometry(argv[i]) == MagickFalse)
4947               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4948             break;
4949           }
4950         if (LocaleCompare("list",option+1) == 0)
4951           {
4952             ssize_t
4953               list;
4954
4955             if (*option == '+')
4956               break;
4957             i++;
4958             if (i == (ssize_t) argc)
4959               ThrowMogrifyException(OptionError,"MissingArgument",option);
4960             list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
4961             if (list < 0)
4962               ThrowMogrifyException(OptionError,"UnrecognizedListType",argv[i]);
4963             status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
4964               argv+j,exception);
4965             return(status != 0 ? MagickFalse : MagickTrue);
4966           }
4967         if (LocaleCompare("log",option+1) == 0)
4968           {
4969             if (*option == '+')
4970               break;
4971             i++;
4972             if ((i == (ssize_t) argc) ||
4973                 (strchr(argv[i],'%') == (char *) NULL))
4974               ThrowMogrifyException(OptionError,"MissingArgument",option);
4975             break;
4976           }
4977         if (LocaleCompare("loop",option+1) == 0)
4978           {
4979             if (*option == '+')
4980               break;
4981             i++;
4982             if (i == (ssize_t) argc)
4983               ThrowMogrifyException(OptionError,"MissingArgument",option);
4984             if (IsGeometry(argv[i]) == MagickFalse)
4985               ThrowMogrifyInvalidArgumentException(option,argv[i]);
4986             break;
4987           }
4988         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4989       }
4990       case 'm':
4991       {
4992         if (LocaleCompare("map",option+1) == 0)
4993           {
4994             global_colormap=(*option == '+') ? MagickTrue : MagickFalse;
4995             if (*option == '+')
4996               break;
4997             i++;
4998             if (i == (ssize_t) argc)
4999               ThrowMogrifyException(OptionError,"MissingArgument",option);
5000             break;
5001           }
5002         if (LocaleCompare("mask",option+1) == 0)
5003           {
5004             if (*option == '+')
5005               break;
5006             i++;
5007             if (i == (ssize_t) argc)
5008               ThrowMogrifyException(OptionError,"MissingArgument",option);
5009             break;
5010           }
5011         if (LocaleCompare("matte",option+1) == 0)
5012           break;
5013         if (LocaleCompare("mattecolor",option+1) == 0)
5014           {
5015             if (*option == '+')
5016               break;
5017             i++;
5018             if (i == (ssize_t) argc)
5019               ThrowMogrifyException(OptionError,"MissingArgument",option);
5020             break;
5021           }
5022         if (LocaleCompare("maximum",option+1) == 0)
5023           break;
5024         if (LocaleCompare("minimum",option+1) == 0)
5025           break;
5026         if (LocaleCompare("modulate",option+1) == 0)
5027           {
5028             if (*option == '+')
5029               break;
5030             i++;
5031             if (i == (ssize_t) argc)
5032               ThrowMogrifyException(OptionError,"MissingArgument",option);
5033             if (IsGeometry(argv[i]) == MagickFalse)
5034               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5035             break;
5036           }
5037         if (LocaleCompare("median",option+1) == 0)
5038           {
5039             if (*option == '+')
5040               break;
5041             i++;
5042             if (i == (ssize_t) argc)
5043               ThrowMogrifyException(OptionError,"MissingArgument",option);
5044             if (IsGeometry(argv[i]) == MagickFalse)
5045               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5046             break;
5047           }
5048         if (LocaleCompare("mode",option+1) == 0)
5049           {
5050             if (*option == '+')
5051               break;
5052             i++;
5053             if (i == (ssize_t) argc)
5054               ThrowMogrifyException(OptionError,"MissingArgument",option);
5055             if (IsGeometry(argv[i]) == MagickFalse)
5056               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5057             break;
5058           }
5059         if (LocaleCompare("monitor",option+1) == 0)
5060           break;
5061         if (LocaleCompare("monochrome",option+1) == 0)
5062           break;
5063         if (LocaleCompare("morph",option+1) == 0)
5064           {
5065             if (*option == '+')
5066               break;
5067             i++;
5068             if (i == (ssize_t) (argc-1))
5069               ThrowMogrifyException(OptionError,"MissingArgument",option);
5070             if (IsGeometry(argv[i]) == MagickFalse)
5071               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5072             break;
5073           }
5074         if (LocaleCompare("morphology",option+1) == 0)
5075           {
5076             char
5077               token[MaxTextExtent];
5078
5079             KernelInfo
5080               *kernel_info;
5081
5082             ssize_t
5083               op;
5084
5085             i++;
5086             if (i == (ssize_t) argc)
5087               ThrowMogrifyException(OptionError,"MissingArgument",option);
5088             GetMagickToken(argv[i],NULL,token);
5089             op=ParseCommandOption(MagickMorphologyOptions,MagickFalse,token);
5090             if (op < 0)
5091               ThrowMogrifyException(OptionError,"UnrecognizedMorphologyMethod",
5092                 token);
5093             i++;
5094             if (i == (ssize_t) (argc-1))
5095               ThrowMogrifyException(OptionError,"MissingArgument",option);
5096             kernel_info=AcquireKernelInfo(argv[i]);
5097             if (kernel_info == (KernelInfo *) NULL)
5098               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5099             kernel_info=DestroyKernelInfo(kernel_info);
5100             break;
5101           }
5102         if (LocaleCompare("mosaic",option+1) == 0)
5103           break;
5104         if (LocaleCompare("motion-blur",option+1) == 0)
5105           {
5106             if (*option == '+')
5107               break;
5108             i++;
5109             if (i == (ssize_t) argc)
5110               ThrowMogrifyException(OptionError,"MissingArgument",option);
5111             if (IsGeometry(argv[i]) == MagickFalse)
5112               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5113             break;
5114           }
5115         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5116       }
5117       case 'n':
5118       {
5119         if (LocaleCompare("negate",option+1) == 0)
5120           break;
5121         if (LocaleCompare("noise",option+1) == 0)
5122           {
5123             i++;
5124             if (i == (ssize_t) argc)
5125               ThrowMogrifyException(OptionError,"MissingArgument",option);
5126             if (*option == '+')
5127               {
5128                 ssize_t
5129                   noise;
5130
5131                 noise=ParseCommandOption(MagickNoiseOptions,MagickFalse,argv[i]);
5132                 if (noise < 0)
5133                   ThrowMogrifyException(OptionError,"UnrecognizedNoiseType",
5134                     argv[i]);
5135                 break;
5136               }
5137             if (IsGeometry(argv[i]) == MagickFalse)
5138               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5139             break;
5140           }
5141         if (LocaleCompare("noop",option+1) == 0)
5142           break;
5143         if (LocaleCompare("normalize",option+1) == 0)
5144           break;
5145         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5146       }
5147       case 'o':
5148       {
5149         if (LocaleCompare("opaque",option+1) == 0)
5150           {
5151             i++;
5152             if (i == (ssize_t) argc)
5153               ThrowMogrifyException(OptionError,"MissingArgument",option);
5154             break;
5155           }
5156         if (LocaleCompare("ordered-dither",option+1) == 0)
5157           {
5158             if (*option == '+')
5159               break;
5160             i++;
5161             if (i == (ssize_t) argc)
5162               ThrowMogrifyException(OptionError,"MissingArgument",option);
5163             break;
5164           }
5165         if (LocaleCompare("orient",option+1) == 0)
5166           {
5167             ssize_t
5168               orientation;
5169
5170             orientation=UndefinedOrientation;
5171             if (*option == '+')
5172               break;
5173             i++;
5174             if (i == (ssize_t) (argc-1))
5175               ThrowMogrifyException(OptionError,"MissingArgument",option);
5176             orientation=ParseCommandOption(MagickOrientationOptions,MagickFalse,
5177               argv[i]);
5178             if (orientation < 0)
5179               ThrowMogrifyException(OptionError,"UnrecognizedImageOrientation",
5180                 argv[i]);
5181             break;
5182           }
5183         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5184       }
5185       case 'p':
5186       {
5187         if (LocaleCompare("page",option+1) == 0)
5188           {
5189             if (*option == '+')
5190               break;
5191             i++;
5192             if (i == (ssize_t) argc)
5193               ThrowMogrifyException(OptionError,"MissingArgument",option);
5194             break;
5195           }
5196         if (LocaleCompare("paint",option+1) == 0)
5197           {
5198             if (*option == '+')
5199               break;
5200             i++;
5201             if (i == (ssize_t) argc)
5202               ThrowMogrifyException(OptionError,"MissingArgument",option);
5203             if (IsGeometry(argv[i]) == MagickFalse)
5204               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5205             break;
5206           }
5207         if (LocaleCompare("path",option+1) == 0)
5208           {
5209             (void) CloneString(&path,(char *) NULL);
5210             if (*option == '+')
5211               break;
5212             i++;
5213             if (i == (ssize_t) argc)
5214               ThrowMogrifyException(OptionError,"MissingArgument",option);
5215             (void) CloneString(&path,argv[i]);
5216             break;
5217           }
5218         if (LocaleCompare("pointsize",option+1) == 0)
5219           {
5220             if (*option == '+')
5221               break;
5222             i++;
5223             if (i == (ssize_t) argc)
5224               ThrowMogrifyException(OptionError,"MissingArgument",option);
5225             if (IsGeometry(argv[i]) == MagickFalse)
5226               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5227             break;
5228           }
5229         if (LocaleCompare("polaroid",option+1) == 0)
5230           {
5231             if (*option == '+')
5232               break;
5233             i++;
5234             if (i == (ssize_t) argc)
5235               ThrowMogrifyException(OptionError,"MissingArgument",option);
5236             if (IsGeometry(argv[i]) == MagickFalse)
5237               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5238             break;
5239           }
5240         if (LocaleCompare("posterize",option+1) == 0)
5241           {
5242             if (*option == '+')
5243               break;
5244             i++;
5245             if (i == (ssize_t) argc)
5246               ThrowMogrifyException(OptionError,"MissingArgument",option);
5247             if (IsGeometry(argv[i]) == MagickFalse)
5248               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5249             break;
5250           }
5251         if (LocaleCompare("precision",option+1) == 0)
5252           {
5253             if (*option == '+')
5254               break;
5255             i++;
5256             if (i == (ssize_t) argc)
5257               ThrowMogrifyException(OptionError,"MissingArgument",option);
5258             if (IsGeometry(argv[i]) == MagickFalse)
5259               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5260             break;
5261           }
5262         if (LocaleCompare("print",option+1) == 0)
5263           {
5264             if (*option == '+')
5265               break;
5266             i++;
5267             if (i == (ssize_t) argc)
5268               ThrowMogrifyException(OptionError,"MissingArgument",option);
5269             break;
5270           }
5271         if (LocaleCompare("process",option+1) == 0)
5272           {
5273             if (*option == '+')
5274               break;
5275             i++;
5276             if (i == (ssize_t) (argc-1))
5277               ThrowMogrifyException(OptionError,"MissingArgument",option);
5278             break;
5279           }
5280         if (LocaleCompare("profile",option+1) == 0)
5281           {
5282             i++;
5283             if (i == (ssize_t) argc)
5284               ThrowMogrifyException(OptionError,"MissingArgument",option);
5285             break;
5286           }
5287         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5288       }
5289       case 'q':
5290       {
5291         if (LocaleCompare("quality",option+1) == 0)
5292           {
5293             if (*option == '+')
5294               break;
5295             i++;
5296             if (i == (ssize_t) argc)
5297               ThrowMogrifyException(OptionError,"MissingArgument",option);
5298             if (IsGeometry(argv[i]) == MagickFalse)
5299               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5300             break;
5301           }
5302         if (LocaleCompare("quantize",option+1) == 0)
5303           {
5304             ssize_t
5305               colorspace;
5306
5307             if (*option == '+')
5308               break;
5309             i++;
5310             if (i == (ssize_t) (argc-1))
5311               ThrowMogrifyException(OptionError,"MissingArgument",option);
5312             colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
5313               argv[i]);
5314             if (colorspace < 0)
5315               ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
5316                 argv[i]);
5317             break;
5318           }
5319         if (LocaleCompare("quiet",option+1) == 0)
5320           break;
5321         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5322       }
5323       case 'r':
5324       {
5325         if (LocaleCompare("radial-blur",option+1) == 0)
5326           {
5327             i++;
5328             if (i == (ssize_t) argc)
5329               ThrowMogrifyException(OptionError,"MissingArgument",option);
5330             if (IsGeometry(argv[i]) == MagickFalse)
5331               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5332             break;
5333           }
5334         if (LocaleCompare("raise",option+1) == 0)
5335           {
5336             i++;
5337             if (i == (ssize_t) argc)
5338               ThrowMogrifyException(OptionError,"MissingArgument",option);
5339             if (IsGeometry(argv[i]) == MagickFalse)
5340               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5341             break;
5342           }
5343         if (LocaleCompare("random-threshold",option+1) == 0)
5344           {
5345             if (*option == '+')
5346               break;
5347             i++;
5348             if (i == (ssize_t) argc)
5349               ThrowMogrifyException(OptionError,"MissingArgument",option);
5350             if (IsGeometry(argv[i]) == MagickFalse)
5351               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5352             break;
5353           }
5354         if (LocaleCompare("recolor",option+1) == 0)
5355           {
5356             if (*option == '+')
5357               break;
5358             i++;
5359             if (i == (ssize_t) (argc-1))
5360               ThrowMogrifyException(OptionError,"MissingArgument",option);
5361             if (IsGeometry(argv[i]) == MagickFalse)
5362               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5363             break;
5364           }
5365         if (LocaleCompare("red-primary",option+1) == 0)
5366           {
5367             if (*option == '+')
5368               break;
5369             i++;
5370             if (i == (ssize_t) argc)
5371               ThrowMogrifyException(OptionError,"MissingArgument",option);
5372             if (IsGeometry(argv[i]) == MagickFalse)
5373               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5374           }
5375         if (LocaleCompare("regard-warnings",option+1) == 0)
5376           break;
5377         if (LocaleCompare("region",option+1) == 0)
5378           {
5379             if (*option == '+')
5380               break;
5381             i++;
5382             if (i == (ssize_t) argc)
5383               ThrowMogrifyException(OptionError,"MissingArgument",option);
5384             if (IsGeometry(argv[i]) == MagickFalse)
5385               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5386             break;
5387           }
5388         if (LocaleCompare("remap",option+1) == 0)
5389           {
5390             if (*option == '+')
5391               break;
5392             i++;
5393             if (i == (ssize_t) (argc-1))
5394               ThrowMogrifyException(OptionError,"MissingArgument",option);
5395             break;
5396           }
5397         if (LocaleCompare("render",option+1) == 0)
5398           break;
5399         if (LocaleCompare("repage",option+1) == 0)
5400           {
5401             if (*option == '+')
5402               break;
5403             i++;
5404             if (i == (ssize_t) argc)
5405               ThrowMogrifyException(OptionError,"MissingArgument",option);
5406             if (IsGeometry(argv[i]) == MagickFalse)
5407               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5408             break;
5409           }
5410         if (LocaleCompare("resample",option+1) == 0)
5411           {
5412             if (*option == '+')
5413               break;
5414             i++;
5415             if (i == (ssize_t) argc)
5416               ThrowMogrifyException(OptionError,"MissingArgument",option);
5417             if (IsGeometry(argv[i]) == MagickFalse)
5418               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5419             break;
5420           }
5421         if (LocaleCompare("resize",option+1) == 0)
5422           {
5423             if (*option == '+')
5424               break;
5425             i++;
5426             if (i == (ssize_t) argc)
5427               ThrowMogrifyException(OptionError,"MissingArgument",option);
5428             if (IsGeometry(argv[i]) == MagickFalse)
5429               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5430             break;
5431           }
5432         if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
5433           {
5434             respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
5435             break;
5436           }
5437         if (LocaleCompare("reverse",option+1) == 0)
5438           break;
5439         if (LocaleCompare("roll",option+1) == 0)
5440           {
5441             if (*option == '+')
5442               break;
5443             i++;
5444             if (i == (ssize_t) argc)
5445               ThrowMogrifyException(OptionError,"MissingArgument",option);
5446             if (IsGeometry(argv[i]) == MagickFalse)
5447               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5448             break;
5449           }
5450         if (LocaleCompare("rotate",option+1) == 0)
5451           {
5452             i++;
5453             if (i == (ssize_t) argc)
5454               ThrowMogrifyException(OptionError,"MissingArgument",option);
5455             if (IsGeometry(argv[i]) == MagickFalse)
5456               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5457             break;
5458           }
5459         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5460       }
5461       case 's':
5462       {
5463         if (LocaleCompare("sample",option+1) == 0)
5464           {
5465             if (*option == '+')
5466               break;
5467             i++;
5468             if (i == (ssize_t) argc)
5469               ThrowMogrifyException(OptionError,"MissingArgument",option);
5470             if (IsGeometry(argv[i]) == MagickFalse)
5471               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5472             break;
5473           }
5474         if (LocaleCompare("sampling-factor",option+1) == 0)
5475           {
5476             if (*option == '+')
5477               break;
5478             i++;
5479             if (i == (ssize_t) argc)
5480               ThrowMogrifyException(OptionError,"MissingArgument",option);
5481             if (IsGeometry(argv[i]) == MagickFalse)
5482               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5483             break;
5484           }
5485         if (LocaleCompare("scale",option+1) == 0)
5486           {
5487             if (*option == '+')
5488               break;
5489             i++;
5490             if (i == (ssize_t) argc)
5491               ThrowMogrifyException(OptionError,"MissingArgument",option);
5492             if (IsGeometry(argv[i]) == MagickFalse)
5493               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5494             break;
5495           }
5496         if (LocaleCompare("scene",option+1) == 0)
5497           {
5498             if (*option == '+')
5499               break;
5500             i++;
5501             if (i == (ssize_t) argc)
5502               ThrowMogrifyException(OptionError,"MissingArgument",option);
5503             if (IsGeometry(argv[i]) == MagickFalse)
5504               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5505             break;
5506           }
5507         if (LocaleCompare("seed",option+1) == 0)
5508           {
5509             if (*option == '+')
5510               break;
5511             i++;
5512             if (i == (ssize_t) argc)
5513               ThrowMogrifyException(OptionError,"MissingArgument",option);
5514             if (IsGeometry(argv[i]) == MagickFalse)
5515               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5516             break;
5517           }
5518         if (LocaleCompare("segment",option+1) == 0)
5519           {
5520             if (*option == '+')
5521               break;
5522             i++;
5523             if (i == (ssize_t) argc)
5524               ThrowMogrifyException(OptionError,"MissingArgument",option);
5525             if (IsGeometry(argv[i]) == MagickFalse)
5526               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5527             break;
5528           }
5529         if (LocaleCompare("selective-blur",option+1) == 0)
5530           {
5531             i++;
5532             if (i == (ssize_t) argc)
5533               ThrowMogrifyException(OptionError,"MissingArgument",option);
5534             if (IsGeometry(argv[i]) == MagickFalse)
5535               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5536             break;
5537           }
5538         if (LocaleCompare("separate",option+1) == 0)
5539           break;
5540         if (LocaleCompare("sepia-tone",option+1) == 0)
5541           {
5542             if (*option == '+')
5543               break;
5544             i++;
5545             if (i == (ssize_t) argc)
5546               ThrowMogrifyException(OptionError,"MissingArgument",option);
5547             if (IsGeometry(argv[i]) == MagickFalse)
5548               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5549             break;
5550           }
5551         if (LocaleCompare("set",option+1) == 0)
5552           {
5553             i++;
5554             if (i == (ssize_t) argc)
5555               ThrowMogrifyException(OptionError,"MissingArgument",option);
5556             if (*option == '+')
5557               break;
5558             i++;
5559             if (i == (ssize_t) argc)
5560               ThrowMogrifyException(OptionError,"MissingArgument",option);
5561             break;
5562           }
5563         if (LocaleCompare("shade",option+1) == 0)
5564           {
5565             i++;
5566             if (i == (ssize_t) argc)
5567               ThrowMogrifyException(OptionError,"MissingArgument",option);
5568             if (IsGeometry(argv[i]) == MagickFalse)
5569               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5570             break;
5571           }
5572         if (LocaleCompare("shadow",option+1) == 0)
5573           {
5574             if (*option == '+')
5575               break;
5576             i++;
5577             if (i == (ssize_t) argc)
5578               ThrowMogrifyException(OptionError,"MissingArgument",option);
5579             if (IsGeometry(argv[i]) == MagickFalse)
5580               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5581             break;
5582           }
5583         if (LocaleCompare("sharpen",option+1) == 0)
5584           {
5585             i++;
5586             if (i == (ssize_t) argc)
5587               ThrowMogrifyException(OptionError,"MissingArgument",option);
5588             if (IsGeometry(argv[i]) == MagickFalse)
5589               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5590             break;
5591           }
5592         if (LocaleCompare("shave",option+1) == 0)
5593           {
5594             if (*option == '+')
5595               break;
5596             i++;
5597             if (i == (ssize_t) argc)
5598               ThrowMogrifyException(OptionError,"MissingArgument",option);
5599             if (IsGeometry(argv[i]) == MagickFalse)
5600               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5601             break;
5602           }
5603         if (LocaleCompare("shear",option+1) == 0)
5604           {
5605             i++;
5606             if (i == (ssize_t) argc)
5607               ThrowMogrifyException(OptionError,"MissingArgument",option);
5608             if (IsGeometry(argv[i]) == MagickFalse)
5609               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5610             break;
5611           }
5612         if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
5613           {
5614             i++;
5615             if (i == (ssize_t) (argc-1))
5616               ThrowMogrifyException(OptionError,"MissingArgument",option);
5617             if (IsGeometry(argv[i]) == MagickFalse)
5618               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5619             break;
5620           }
5621         if (LocaleCompare("size",option+1) == 0)
5622           {
5623             if (*option == '+')
5624               break;
5625             i++;
5626             if (i == (ssize_t) argc)
5627               ThrowMogrifyException(OptionError,"MissingArgument",option);
5628             if (IsGeometry(argv[i]) == MagickFalse)
5629               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5630             break;
5631           }
5632         if (LocaleCompare("sketch",option+1) == 0)
5633           {
5634             if (*option == '+')
5635               break;
5636             i++;
5637             if (i == (ssize_t) argc)
5638               ThrowMogrifyException(OptionError,"MissingArgument",option);
5639             if (IsGeometry(argv[i]) == MagickFalse)
5640               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5641             break;
5642           }
5643         if (LocaleCompare("smush",option+1) == 0)
5644           {
5645             i++;
5646             if (i == (ssize_t) argc)
5647               ThrowMogrifyException(OptionError,"MissingArgument",option);
5648             if (IsGeometry(argv[i]) == MagickFalse)
5649               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5650             i++;
5651             break;
5652           }
5653         if (LocaleCompare("solarize",option+1) == 0)
5654           {
5655             if (*option == '+')
5656               break;
5657             i++;
5658             if (i == (ssize_t) argc)
5659               ThrowMogrifyException(OptionError,"MissingArgument",option);
5660             if (IsGeometry(argv[i]) == MagickFalse)
5661               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5662             break;
5663           }
5664         if (LocaleCompare("sparse-color",option+1) == 0)
5665           {
5666             ssize_t
5667               op;
5668
5669             i++;
5670             if (i == (ssize_t) argc)
5671               ThrowMogrifyException(OptionError,"MissingArgument",option);
5672             op=ParseCommandOption(MagickSparseColorOptions,MagickFalse,argv[i]);
5673             if (op < 0)
5674               ThrowMogrifyException(OptionError,"UnrecognizedSparseColorMethod",
5675                 argv[i]);
5676             i++;
5677             if (i == (ssize_t) (argc-1))
5678               ThrowMogrifyException(OptionError,"MissingArgument",option);
5679             break;
5680           }
5681         if (LocaleCompare("spread",option+1) == 0)
5682           {
5683             if (*option == '+')
5684               break;
5685             i++;
5686             if (i == (ssize_t) argc)
5687               ThrowMogrifyException(OptionError,"MissingArgument",option);
5688             if (IsGeometry(argv[i]) == MagickFalse)
5689               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5690             break;
5691           }
5692         if (LocaleCompare("statistic",option+1) == 0)
5693           {
5694             ssize_t
5695               op;
5696
5697             if (*option == '+')
5698               break;
5699             i++;
5700             if (i == (ssize_t) argc)
5701               ThrowMogrifyException(OptionError,"MissingArgument",option);
5702             op=ParseCommandOption(MagickStatisticOptions,MagickFalse,argv[i]);
5703             if (op < 0)
5704               ThrowMogrifyException(OptionError,"UnrecognizedStatisticType",
5705                 argv[i]);
5706             i++;
5707             if (i == (ssize_t) (argc-1))
5708               ThrowMogrifyException(OptionError,"MissingArgument",option);
5709             if (IsGeometry(argv[i]) == MagickFalse)
5710               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5711             break;
5712           }
5713         if (LocaleCompare("stretch",option+1) == 0)
5714           {
5715             ssize_t
5716               stretch;
5717
5718             if (*option == '+')
5719               break;
5720             i++;
5721             if (i == (ssize_t) (argc-1))
5722               ThrowMogrifyException(OptionError,"MissingArgument",option);
5723             stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,argv[i]);
5724             if (stretch < 0)
5725               ThrowMogrifyException(OptionError,"UnrecognizedStyleType",
5726                 argv[i]);
5727             break;
5728           }
5729         if (LocaleCompare("strip",option+1) == 0)
5730           break;
5731         if (LocaleCompare("stroke",option+1) == 0)
5732           {
5733             if (*option == '+')
5734               break;
5735             i++;
5736             if (i == (ssize_t) argc)
5737               ThrowMogrifyException(OptionError,"MissingArgument",option);
5738             break;
5739           }
5740         if (LocaleCompare("strokewidth",option+1) == 0)
5741           {
5742             if (*option == '+')
5743               break;
5744             i++;
5745             if (i == (ssize_t) argc)
5746               ThrowMogrifyException(OptionError,"MissingArgument",option);
5747             if (IsGeometry(argv[i]) == MagickFalse)
5748               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5749             break;
5750           }
5751         if (LocaleCompare("style",option+1) == 0)
5752           {
5753             ssize_t
5754               style;
5755
5756             if (*option == '+')
5757               break;
5758             i++;
5759             if (i == (ssize_t) (argc-1))
5760               ThrowMogrifyException(OptionError,"MissingArgument",option);
5761             style=ParseCommandOption(MagickStyleOptions,MagickFalse,argv[i]);
5762             if (style < 0)
5763               ThrowMogrifyException(OptionError,"UnrecognizedStyleType",
5764                 argv[i]);
5765             break;
5766           }
5767         if (LocaleCompare("swap",option+1) == 0)
5768           {
5769             if (*option == '+')
5770               break;
5771             i++;
5772             if (i == (ssize_t) (argc-1))
5773               ThrowMogrifyException(OptionError,"MissingArgument",option);
5774             if (IsGeometry(argv[i]) == MagickFalse)
5775               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5776             break;
5777           }
5778         if (LocaleCompare("swirl",option+1) == 0)
5779           {
5780             if (*option == '+')
5781               break;
5782             i++;
5783             if (i == (ssize_t) argc)
5784               ThrowMogrifyException(OptionError,"MissingArgument",option);
5785             if (IsGeometry(argv[i]) == MagickFalse)
5786               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5787             break;
5788           }
5789         if (LocaleCompare("synchronize",option+1) == 0)
5790           break;
5791         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5792       }
5793       case 't':
5794       {
5795         if (LocaleCompare("taint",option+1) == 0)
5796           break;
5797         if (LocaleCompare("texture",option+1) == 0)
5798           {
5799             if (*option == '+')
5800               break;
5801             i++;
5802             if (i == (ssize_t) argc)
5803               ThrowMogrifyException(OptionError,"MissingArgument",option);
5804             break;
5805           }
5806         if (LocaleCompare("tile",option+1) == 0)
5807           {
5808             if (*option == '+')
5809               break;
5810             i++;
5811             if (i == (ssize_t) (argc-1))
5812               ThrowMogrifyException(OptionError,"MissingArgument",option);
5813             break;
5814           }
5815         if (LocaleCompare("tile-offset",option+1) == 0)
5816           {
5817             if (*option == '+')
5818               break;
5819             i++;
5820             if (i == (ssize_t) argc)
5821               ThrowMogrifyException(OptionError,"MissingArgument",option);
5822             if (IsGeometry(argv[i]) == MagickFalse)
5823               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5824             break;
5825           }
5826         if (LocaleCompare("tint",option+1) == 0)
5827           {
5828             if (*option == '+')
5829               break;
5830             i++;
5831             if (i == (ssize_t) (argc-1))
5832               ThrowMogrifyException(OptionError,"MissingArgument",option);
5833             if (IsGeometry(argv[i]) == MagickFalse)
5834               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5835             break;
5836           }
5837         if (LocaleCompare("transform",option+1) == 0)
5838           break;
5839         if (LocaleCompare("transpose",option+1) == 0)
5840           break;
5841         if (LocaleCompare("transverse",option+1) == 0)
5842           break;
5843         if (LocaleCompare("threshold",option+1) == 0)
5844           {
5845             if (*option == '+')
5846               break;
5847             i++;
5848             if (i == (ssize_t) argc)
5849               ThrowMogrifyException(OptionError,"MissingArgument",option);
5850             if (IsGeometry(argv[i]) == MagickFalse)
5851               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5852             break;
5853           }
5854         if (LocaleCompare("thumbnail",option+1) == 0)
5855           {
5856             if (*option == '+')
5857               break;
5858             i++;
5859             if (i == (ssize_t) argc)
5860               ThrowMogrifyException(OptionError,"MissingArgument",option);
5861             if (IsGeometry(argv[i]) == MagickFalse)
5862               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5863             break;
5864           }
5865         if (LocaleCompare("transparent",option+1) == 0)
5866           {
5867             i++;
5868             if (i == (ssize_t) argc)
5869               ThrowMogrifyException(OptionError,"MissingArgument",option);
5870             break;
5871           }
5872         if (LocaleCompare("transparent-color",option+1) == 0)
5873           {
5874             if (*option == '+')
5875               break;
5876             i++;
5877             if (i == (ssize_t) (argc-1))
5878               ThrowMogrifyException(OptionError,"MissingArgument",option);
5879             break;
5880           }
5881         if (LocaleCompare("treedepth",option+1) == 0)
5882           {
5883             if (*option == '+')
5884               break;
5885             i++;
5886             if (i == (ssize_t) argc)
5887               ThrowMogrifyException(OptionError,"MissingArgument",option);
5888             if (IsGeometry(argv[i]) == MagickFalse)
5889               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5890             break;
5891           }
5892         if (LocaleCompare("trim",option+1) == 0)
5893           break;
5894         if (LocaleCompare("type",option+1) == 0)
5895           {
5896             ssize_t
5897               type;
5898
5899             if (*option == '+')
5900               break;
5901             i++;
5902             if (i == (ssize_t) argc)
5903               ThrowMogrifyException(OptionError,"MissingArgument",option);
5904             type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
5905             if (type < 0)
5906               ThrowMogrifyException(OptionError,"UnrecognizedImageType",
5907                 argv[i]);
5908             break;
5909           }
5910         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5911       }
5912       case 'u':
5913       {
5914         if (LocaleCompare("undercolor",option+1) == 0)
5915           {
5916             if (*option == '+')
5917               break;
5918             i++;
5919             if (i == (ssize_t) argc)
5920               ThrowMogrifyException(OptionError,"MissingArgument",option);
5921             break;
5922           }
5923         if (LocaleCompare("unique-colors",option+1) == 0)
5924           break;
5925         if (LocaleCompare("units",option+1) == 0)
5926           {
5927             ssize_t
5928               units;
5929
5930             if (*option == '+')
5931               break;
5932             i++;
5933             if (i == (ssize_t) argc)
5934               ThrowMogrifyException(OptionError,"MissingArgument",option);
5935             units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
5936               argv[i]);
5937             if (units < 0)
5938               ThrowMogrifyException(OptionError,"UnrecognizedUnitsType",
5939                 argv[i]);
5940             break;
5941           }
5942         if (LocaleCompare("unsharp",option+1) == 0)
5943           {
5944             i++;
5945             if (i == (ssize_t) argc)
5946               ThrowMogrifyException(OptionError,"MissingArgument",option);
5947             if (IsGeometry(argv[i]) == MagickFalse)
5948               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5949             break;
5950           }
5951         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5952       }
5953       case 'v':
5954       {
5955         if (LocaleCompare("verbose",option+1) == 0)
5956           {
5957             image_info->verbose=(*option == '-') ? MagickTrue : MagickFalse;
5958             break;
5959           }
5960         if ((LocaleCompare("version",option+1) == 0) ||
5961             (LocaleCompare("-version",option+1) == 0))
5962           {
5963             (void) FormatLocaleFile(stdout,"Version: %s\n",
5964               GetMagickVersion((size_t *) NULL));
5965             (void) FormatLocaleFile(stdout,"Copyright: %s\n",
5966               GetMagickCopyright());
5967             (void) FormatLocaleFile(stdout,"Features: %s\n\n",
5968               GetMagickFeatures());
5969             break;
5970           }
5971         if (LocaleCompare("view",option+1) == 0)
5972           {
5973             if (*option == '+')
5974               break;
5975             i++;
5976             if (i == (ssize_t) argc)
5977               ThrowMogrifyException(OptionError,"MissingArgument",option);
5978             break;
5979           }
5980         if (LocaleCompare("vignette",option+1) == 0)
5981           {
5982             if (*option == '+')
5983               break;
5984             i++;
5985             if (i == (ssize_t) argc)
5986               ThrowMogrifyException(OptionError,"MissingArgument",option);
5987             if (IsGeometry(argv[i]) == MagickFalse)
5988               ThrowMogrifyInvalidArgumentException(option,argv[i]);
5989             break;
5990           }
5991         if (LocaleCompare("virtual-pixel",option+1) == 0)
5992           {
5993             ssize_t
5994               method;
5995
5996             if (*option == '+')
5997               break;
5998             i++;
5999             if (i == (ssize_t) argc)
6000               ThrowMogrifyException(OptionError,"MissingArgument",option);
6001             method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
6002               argv[i]);
6003             if (method < 0)
6004               ThrowMogrifyException(OptionError,
6005                 "UnrecognizedVirtualPixelMethod",argv[i]);
6006             break;
6007           }
6008         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6009       }
6010       case 'w':
6011       {
6012         if (LocaleCompare("wave",option+1) == 0)
6013           {
6014             i++;
6015             if (i == (ssize_t) argc)
6016               ThrowMogrifyException(OptionError,"MissingArgument",option);
6017             if (IsGeometry(argv[i]) == MagickFalse)
6018               ThrowMogrifyInvalidArgumentException(option,argv[i]);
6019             break;
6020           }
6021         if (LocaleCompare("weight",option+1) == 0)
6022           {
6023             if (*option == '+')
6024               break;
6025             i++;
6026             if (i == (ssize_t) (argc-1))
6027               ThrowMogrifyException(OptionError,"MissingArgument",option);
6028             break;
6029           }
6030         if (LocaleCompare("white-point",option+1) == 0)
6031           {
6032             if (*option == '+')
6033               break;
6034             i++;
6035             if (i == (ssize_t) argc)
6036               ThrowMogrifyException(OptionError,"MissingArgument",option);
6037             if (IsGeometry(argv[i]) == MagickFalse)
6038               ThrowMogrifyInvalidArgumentException(option,argv[i]);
6039             break;
6040           }
6041         if (LocaleCompare("white-threshold",option+1) == 0)
6042           {
6043             if (*option == '+')
6044               break;
6045             i++;
6046             if (i == (ssize_t) argc)
6047               ThrowMogrifyException(OptionError,"MissingArgument",option);
6048             if (IsGeometry(argv[i]) == MagickFalse)
6049               ThrowMogrifyInvalidArgumentException(option,argv[i]);
6050             break;
6051           }
6052         if (LocaleCompare("write",option+1) == 0)
6053           {
6054             i++;
6055             if (i == (ssize_t) (argc-1))
6056               ThrowMogrifyException(OptionError,"MissingArgument",option);
6057             break;
6058           }
6059         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6060       }
6061       case '?':
6062         break;
6063       default:
6064         ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6065     }
6066     fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
6067       FireOptionFlag) == 0 ?  MagickFalse : MagickTrue;
6068     if (fire != MagickFalse)
6069       FireImageStack(MagickFalse,MagickTrue,MagickTrue);
6070   }
6071   if (k != 0)
6072     ThrowMogrifyException(OptionError,"UnbalancedParenthesis",argv[i]);
6073   if (i != (ssize_t) argc)
6074     ThrowMogrifyException(OptionError,"MissingAnImageFilename",argv[i]);
6075   DestroyMogrify();
6076   return(status != 0 ? MagickTrue : MagickFalse);
6077 }
6078 \f
6079 /*
6080 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6081 %                                                                             %
6082 %                                                                             %
6083 %                                                                             %
6084 +     M o g r i f y I m a g e I n f o                                         %
6085 %                                                                             %
6086 %                                                                             %
6087 %                                                                             %
6088 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6089 %
6090 %  MogrifyImageInfo() applies image processing settings to the image as
6091 %  prescribed by command line options.
6092 %
6093 %  The format of the MogrifyImageInfo method is:
6094 %
6095 %      MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,const int argc,
6096 %        const char **argv,ExceptionInfo *exception)
6097 %
6098 %  A description of each parameter follows:
6099 %
6100 %    o image_info: the image info..
6101 %
6102 %    o argc: Specifies a pointer to an integer describing the number of
6103 %      elements in the argument vector.
6104 %
6105 %    o argv: Specifies a pointer to a text array containing the command line
6106 %      arguments.
6107 %
6108 %    o exception: return any errors or warnings in this structure.
6109 %
6110 */
6111 WandExport MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,
6112   const int argc,const char **argv,ExceptionInfo *exception)
6113 {
6114   const char
6115     *option;
6116
6117   GeometryInfo
6118     geometry_info;
6119
6120   ssize_t
6121     count;
6122
6123   register ssize_t
6124     i;
6125
6126   /*
6127     Initialize method variables.
6128   */
6129   assert(image_info != (ImageInfo *) NULL);
6130   assert(image_info->signature == MagickSignature);
6131   if (image_info->debug != MagickFalse)
6132     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
6133       image_info->filename);
6134   if (argc < 0)
6135     return(MagickTrue);
6136   /*
6137     Set the image settings.
6138   */
6139   for (i=0; i < (ssize_t) argc; i++)
6140   {
6141     option=argv[i];
6142     if (IsCommandOption(option) == MagickFalse)
6143       continue;
6144     count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
6145     count=MagickMax(count,0L);
6146     if ((i+count) >= (ssize_t) argc)
6147       break;
6148     switch (*(option+1))
6149     {
6150       case 'a':
6151       {
6152         if (LocaleCompare("adjoin",option+1) == 0)
6153           {
6154             image_info->adjoin=(*option == '-') ? MagickTrue : MagickFalse;
6155             break;
6156           }
6157         if (LocaleCompare("antialias",option+1) == 0)
6158           {
6159             image_info->antialias=(*option == '-') ? MagickTrue : MagickFalse;
6160             break;
6161           }
6162         if (LocaleCompare("attenuate",option+1) == 0)
6163           {
6164             if (*option == '+')
6165               {
6166                 (void) DeleteImageOption(image_info,option+1);
6167                 break;
6168               }
6169             (void) SetImageOption(image_info,option+1,argv[i+1]);
6170             break;
6171           }
6172         if (LocaleCompare("authenticate",option+1) == 0)
6173           {
6174             if (*option == '+')
6175               (void) CloneString(&image_info->authenticate,(char *) NULL);
6176             else
6177               (void) CloneString(&image_info->authenticate,argv[i+1]);
6178             break;
6179           }
6180         break;
6181       }
6182       case 'b':
6183       {
6184         if (LocaleCompare("background",option+1) == 0)
6185           {
6186             if (*option == '+')
6187               {
6188                 (void) DeleteImageOption(image_info,option+1);
6189                 (void) QueryColorCompliance(MogrifyBackgroundColor,
6190                   AllCompliance,&image_info->background_color,exception);
6191                 break;
6192               }
6193             (void) SetImageOption(image_info,option+1,argv[i+1]);
6194             (void) QueryColorCompliance(argv[i+1],AllCompliance,
6195               &image_info->background_color,exception);
6196             break;
6197           }
6198         if (LocaleCompare("bias",option+1) == 0)
6199           {
6200             if (*option == '+')
6201               {
6202                 (void) SetImageOption(image_info,option+1,"0.0");
6203                 break;
6204               }
6205             (void) SetImageOption(image_info,option+1,argv[i+1]);
6206             break;
6207           }
6208         if (LocaleCompare("black-point-compensation",option+1) == 0)
6209           {
6210             if (*option == '+')
6211               {
6212                 (void) SetImageOption(image_info,option+1,"false");
6213                 break;
6214               }
6215             (void) SetImageOption(image_info,option+1,"true");
6216             break;
6217           }
6218         if (LocaleCompare("blue-primary",option+1) == 0)
6219           {
6220             if (*option == '+')
6221               {
6222                 (void) SetImageOption(image_info,option+1,"0.0");
6223                 break;
6224               }
6225             (void) SetImageOption(image_info,option+1,argv[i+1]);
6226             break;
6227           }
6228         if (LocaleCompare("bordercolor",option+1) == 0)
6229           {
6230             if (*option == '+')
6231               {
6232                 (void) DeleteImageOption(image_info,option+1);
6233                 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance,
6234                   &image_info->border_color,exception);
6235                 break;
6236               }
6237             (void) QueryColorCompliance(argv[i+1],AllCompliance,
6238               &image_info->border_color,exception);
6239             (void) SetImageOption(image_info,option+1,argv[i+1]);
6240             break;
6241           }
6242         if (LocaleCompare("box",option+1) == 0)
6243           {
6244             if (*option == '+')
6245               {
6246                 (void) SetImageOption(image_info,"undercolor","none");
6247                 break;
6248               }
6249             (void) SetImageOption(image_info,"undercolor",argv[i+1]);
6250             break;
6251           }
6252         break;
6253       }
6254       case 'c':
6255       {
6256         if (LocaleCompare("cache",option+1) == 0)
6257           {
6258             MagickSizeType
6259               limit;
6260
6261             limit=MagickResourceInfinity;
6262             if (LocaleCompare("unlimited",argv[i+1]) != 0)
6263               limit=(MagickSizeType) SiPrefixToDouble(argv[i+1],100.0);
6264             (void) SetMagickResourceLimit(MemoryResource,limit);
6265             (void) SetMagickResourceLimit(MapResource,2*limit);
6266             break;
6267           }
6268         if (LocaleCompare("caption",option+1) == 0)
6269           {
6270             if (*option == '+')
6271               {
6272                 (void) DeleteImageOption(image_info,option+1);
6273                 break;
6274               }
6275             (void) SetImageOption(image_info,option+1,argv[i+1]);
6276             break;
6277           }
6278         if (LocaleCompare("channel",option+1) == 0)
6279           {
6280             if (*option == '+')
6281               {
6282                 image_info->channel=DefaultChannels;
6283                 break;
6284               }
6285             image_info->channel=(ChannelType) ParseChannelOption(argv[i+1]);
6286             break;
6287           }
6288         if (LocaleCompare("colors",option+1) == 0)
6289           {
6290             image_info->colors=StringToUnsignedLong(argv[i+1]);
6291             break;
6292           }
6293         if (LocaleCompare("colorspace",option+1) == 0)
6294           {
6295             if (*option == '+')
6296               {
6297                 image_info->colorspace=UndefinedColorspace;
6298                 (void) SetImageOption(image_info,option+1,"undefined");
6299                 break;
6300               }
6301             image_info->colorspace=(ColorspaceType) ParseCommandOption(
6302               MagickColorspaceOptions,MagickFalse,argv[i+1]);
6303             (void) SetImageOption(image_info,option+1,argv[i+1]);
6304             break;
6305           }
6306         if (LocaleCompare("comment",option+1) == 0)
6307           {
6308             if (*option == '+')
6309               {
6310                 (void) DeleteImageOption(image_info,option+1);
6311                 break;
6312               }
6313             (void) SetImageOption(image_info,option+1,argv[i+1]);
6314             break;
6315           }
6316         if (LocaleCompare("compose",option+1) == 0)
6317           {
6318             if (*option == '+')
6319               {
6320                 (void) SetImageOption(image_info,option+1,"undefined");
6321                 break;
6322               }
6323             (void) SetImageOption(image_info,option+1,argv[i+1]);
6324             break;
6325           }
6326         if (LocaleCompare("compress",option+1) == 0)
6327           {
6328             if (*option == '+')
6329               {
6330                 image_info->compression=UndefinedCompression;
6331                 (void) SetImageOption(image_info,option+1,"undefined");
6332                 break;
6333               }
6334             image_info->compression=(CompressionType) ParseCommandOption(
6335               MagickCompressOptions,MagickFalse,argv[i+1]);
6336             (void) SetImageOption(image_info,option+1,argv[i+1]);
6337             break;
6338           }
6339         break;
6340       }
6341       case 'd':
6342       {
6343         if (LocaleCompare("debug",option+1) == 0)
6344           {
6345             if (*option == '+')
6346               (void) SetLogEventMask("none");
6347             else
6348               (void) SetLogEventMask(argv[i+1]);
6349             image_info->debug=IsEventLogging();
6350             break;
6351           }
6352         if (LocaleCompare("define",option+1) == 0)
6353           {
6354             if (*option == '+')
6355               {
6356                 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6357                   (void) DeleteImageRegistry(argv[i+1]+9);
6358                 else
6359                   (void) DeleteImageOption(image_info,argv[i+1]);
6360                 break;
6361               }
6362             if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6363               {
6364                 (void) DefineImageRegistry(StringRegistryType,argv[i+1]+9,
6365                   exception);
6366                 break;
6367               }
6368             (void) DefineImageOption(image_info,argv[i+1]);
6369             break;
6370           }
6371         if (LocaleCompare("delay",option+1) == 0)
6372           {
6373             if (*option == '+')
6374               {
6375                 (void) SetImageOption(image_info,option+1,"0");
6376                 break;
6377               }
6378             (void) SetImageOption(image_info,option+1,argv[i+1]);
6379             break;
6380           }
6381         if (LocaleCompare("density",option+1) == 0)
6382           {
6383             /*
6384               Set image density.
6385             */
6386             if (*option == '+')
6387               {
6388                 if (image_info->density != (char *) NULL)
6389                   image_info->density=DestroyString(image_info->density);
6390                 (void) SetImageOption(image_info,option+1,"72");
6391                 break;
6392               }
6393             (void) CloneString(&image_info->density,argv[i+1]);
6394             (void) SetImageOption(image_info,option+1,argv[i+1]);
6395             break;
6396           }
6397         if (LocaleCompare("depth",option+1) == 0)
6398           {
6399             if (*option == '+')
6400               {
6401                 image_info->depth=MAGICKCORE_QUANTUM_DEPTH;
6402                 break;
6403               }
6404             image_info->depth=StringToUnsignedLong(argv[i+1]);
6405             break;
6406           }
6407         if (LocaleCompare("direction",option+1) == 0)
6408           {
6409             if (*option == '+')
6410               {
6411                 (void) SetImageOption(image_info,option+1,"undefined");
6412                 break;
6413               }
6414             (void) SetImageOption(image_info,option+1,argv[i+1]);
6415             break;
6416           }
6417         if (LocaleCompare("display",option+1) == 0)
6418           {
6419             if (*option == '+')
6420               {
6421                 if (image_info->server_name != (char *) NULL)
6422                   image_info->server_name=DestroyString(
6423                     image_info->server_name);
6424                 break;
6425               }
6426             (void) CloneString(&image_info->server_name,argv[i+1]);
6427             break;
6428           }
6429         if (LocaleCompare("dispose",option+1) == 0)
6430           {
6431             if (*option == '+')
6432               {
6433                 (void) SetImageOption(image_info,option+1,"undefined");
6434                 break;
6435               }
6436             (void) SetImageOption(image_info,option+1,argv[i+1]);
6437             break;
6438           }
6439         if (LocaleCompare("dither",option+1) == 0)
6440           {
6441             if (*option == '+')
6442               {
6443                 image_info->dither=MagickFalse;
6444                 (void) SetImageOption(image_info,option+1,"none");
6445                 break;
6446               }
6447             (void) SetImageOption(image_info,option+1,argv[i+1]);
6448             image_info->dither=MagickTrue;
6449             break;
6450           }
6451         break;
6452       }
6453       case 'e':
6454       {
6455         if (LocaleCompare("encoding",option+1) == 0)
6456           {
6457             if (*option == '+')
6458               {
6459                 (void) SetImageOption(image_info,option+1,"undefined");
6460                 break;
6461               }
6462             (void) SetImageOption(image_info,option+1,argv[i+1]);
6463             break;
6464           }
6465         if (LocaleCompare("endian",option+1) == 0)
6466           {
6467             if (*option == '+')
6468               {
6469                 image_info->endian=UndefinedEndian;
6470                 (void) SetImageOption(image_info,option+1,"undefined");
6471                 break;
6472               }
6473             image_info->endian=(EndianType) ParseCommandOption(
6474               MagickEndianOptions,MagickFalse,argv[i+1]);
6475             (void) SetImageOption(image_info,option+1,argv[i+1]);
6476             break;
6477           }
6478         if (LocaleCompare("extract",option+1) == 0)
6479           {
6480             /*
6481               Set image extract geometry.
6482             */
6483             if (*option == '+')
6484               {
6485                 if (image_info->extract != (char *) NULL)
6486                   image_info->extract=DestroyString(image_info->extract);
6487                 break;
6488               }
6489             (void) CloneString(&image_info->extract,argv[i+1]);
6490             break;
6491           }
6492         break;
6493       }
6494       case 'f':
6495       {
6496         if (LocaleCompare("fill",option+1) == 0)
6497           {
6498             if (*option == '+')
6499               {
6500                 (void) SetImageOption(image_info,option+1,"none");
6501                 break;
6502               }
6503             (void) SetImageOption(image_info,option+1,argv[i+1]);
6504             break;
6505           }
6506         if (LocaleCompare("filter",option+1) == 0)
6507           {
6508             if (*option == '+')
6509               {
6510                 (void) SetImageOption(image_info,option+1,"undefined");
6511                 break;
6512               }
6513             (void) SetImageOption(image_info,option+1,argv[i+1]);
6514             break;
6515           }
6516         if (LocaleCompare("font",option+1) == 0)
6517           {
6518             if (*option == '+')
6519               {
6520                 if (image_info->font != (char *) NULL)
6521                   image_info->font=DestroyString(image_info->font);
6522                 break;
6523               }
6524             (void) CloneString(&image_info->font,argv[i+1]);
6525             break;
6526           }
6527         if (LocaleCompare("format",option+1) == 0)
6528           {
6529             register const char
6530               *q;
6531
6532             for (q=strchr(argv[i+1],'%'); q != (char *) NULL; q=strchr(q+1,'%'))
6533               if (strchr("Agkrz@[#",*(q+1)) != (char *) NULL)
6534                 image_info->ping=MagickFalse;
6535             (void) SetImageOption(image_info,option+1,argv[i+1]);
6536             break;
6537           }
6538         if (LocaleCompare("fuzz",option+1) == 0)
6539           {
6540             if (*option == '+')
6541               {
6542                 image_info->fuzz=0.0;
6543                 (void) SetImageOption(image_info,option+1,"0");
6544                 break;
6545               }
6546             image_info->fuzz=SiPrefixToDouble(argv[i+1],(double) QuantumRange+
6547               1.0);
6548             (void) SetImageOption(image_info,option+1,argv[i+1]);
6549             break;
6550           }
6551         break;
6552       }
6553       case 'g':
6554       {
6555         if (LocaleCompare("gravity",option+1) == 0)
6556           {
6557             if (*option == '+')
6558               {
6559                 (void) SetImageOption(image_info,option+1,"undefined");
6560                 break;
6561               }
6562             (void) SetImageOption(image_info,option+1,argv[i+1]);
6563             break;
6564           }
6565         if (LocaleCompare("green-primary",option+1) == 0)
6566           {
6567             if (*option == '+')
6568               {
6569                 (void) SetImageOption(image_info,option+1,"0.0");
6570                 break;
6571               }
6572             (void) SetImageOption(image_info,option+1,argv[i+1]);
6573             break;
6574           }
6575         break;
6576       }
6577       case 'i':
6578       {
6579         if (LocaleCompare("intent",option+1) == 0)
6580           {
6581             if (*option == '+')
6582               {
6583                 (void) SetImageOption(image_info,option+1,"undefined");
6584                 break;
6585               }
6586             (void) SetImageOption(image_info,option+1,argv[i+1]);
6587             break;
6588           }
6589         if (LocaleCompare("interlace",option+1) == 0)
6590           {
6591             if (*option == '+')
6592               {
6593                 image_info->interlace=UndefinedInterlace;
6594                 (void) SetImageOption(image_info,option+1,"undefined");
6595                 break;
6596               }
6597             image_info->interlace=(InterlaceType) ParseCommandOption(
6598               MagickInterlaceOptions,MagickFalse,argv[i+1]);
6599             (void) SetImageOption(image_info,option+1,argv[i+1]);
6600             break;
6601           }
6602         if (LocaleCompare("interline-spacing",option+1) == 0)
6603           {
6604             if (*option == '+')
6605               {
6606                 (void) SetImageOption(image_info,option+1,"undefined");
6607                 break;
6608               }
6609             (void) SetImageOption(image_info,option+1,argv[i+1]);
6610             break;
6611           }
6612         if (LocaleCompare("interpolate",option+1) == 0)
6613           {
6614             if (*option == '+')
6615               {
6616                 (void) SetImageOption(image_info,option+1,"undefined");
6617                 break;
6618               }
6619             (void) SetImageOption(image_info,option+1,argv[i+1]);
6620             break;
6621           }
6622         if (LocaleCompare("interword-spacing",option+1) == 0)
6623           {
6624             if (*option == '+')
6625               {
6626                 (void) SetImageOption(image_info,option+1,"undefined");
6627                 break;
6628               }
6629             (void) SetImageOption(image_info,option+1,argv[i+1]);
6630             break;
6631           }
6632         break;
6633       }
6634       case 'k':
6635       {
6636         if (LocaleCompare("kerning",option+1) == 0)
6637           {
6638             if (*option == '+')
6639               {
6640                 (void) SetImageOption(image_info,option+1,"undefined");
6641                 break;
6642               }
6643             (void) SetImageOption(image_info,option+1,argv[i+1]);
6644             break;
6645           }
6646         break;
6647       }
6648       case 'l':
6649       {
6650         if (LocaleCompare("label",option+1) == 0)
6651           {
6652             if (*option == '+')
6653               {
6654                 (void) DeleteImageOption(image_info,option+1);
6655                 break;
6656               }
6657             (void) SetImageOption(image_info,option+1,argv[i+1]);
6658             break;
6659           }
6660         if (LocaleCompare("limit",option+1) == 0)
6661           {
6662             MagickSizeType
6663               limit;
6664
6665             ResourceType
6666               type;
6667
6668             if (*option == '+')
6669               break;
6670             type=(ResourceType) ParseCommandOption(MagickResourceOptions,
6671               MagickFalse,argv[i+1]);
6672             limit=MagickResourceInfinity;
6673             if (LocaleCompare("unlimited",argv[i+2]) != 0)
6674               limit=(MagickSizeType) SiPrefixToDouble(argv[i+2],100.0);
6675             (void) SetMagickResourceLimit(type,limit);
6676             break;
6677           }
6678         if (LocaleCompare("list",option+1) == 0)
6679           {
6680             ssize_t
6681               list;
6682
6683             /*
6684               Display configuration list.
6685             */
6686             list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i+1]);
6687             switch (list)
6688             {
6689               case MagickCoderOptions:
6690               {
6691                 (void) ListCoderInfo((FILE *) NULL,exception);
6692                 break;
6693               }
6694               case MagickColorOptions:
6695               {
6696                 (void) ListColorInfo((FILE *) NULL,exception);
6697                 break;
6698               }
6699               case MagickConfigureOptions:
6700               {
6701                 (void) ListConfigureInfo((FILE *) NULL,exception);
6702                 break;
6703               }
6704               case MagickDelegateOptions:
6705               {
6706                 (void) ListDelegateInfo((FILE *) NULL,exception);
6707                 break;
6708               }
6709               case MagickFontOptions:
6710               {
6711                 (void) ListTypeInfo((FILE *) NULL,exception);
6712                 break;
6713               }
6714               case MagickFormatOptions:
6715               {
6716                 (void) ListMagickInfo((FILE *) NULL,exception);
6717                 break;
6718               }
6719               case MagickLocaleOptions:
6720               {
6721                 (void) ListLocaleInfo((FILE *) NULL,exception);
6722                 break;
6723               }
6724               case MagickLogOptions:
6725               {
6726                 (void) ListLogInfo((FILE *) NULL,exception);
6727                 break;
6728               }
6729               case MagickMagicOptions:
6730               {
6731                 (void) ListMagicInfo((FILE *) NULL,exception);
6732                 break;
6733               }
6734               case MagickMimeOptions:
6735               {
6736                 (void) ListMimeInfo((FILE *) NULL,exception);
6737                 break;
6738               }
6739               case MagickModuleOptions:
6740               {
6741                 (void) ListModuleInfo((FILE *) NULL,exception);
6742                 break;
6743               }
6744               case MagickPolicyOptions:
6745               {
6746                 (void) ListPolicyInfo((FILE *) NULL,exception);
6747                 break;
6748               }
6749               case MagickResourceOptions:
6750               {
6751                 (void) ListMagickResourceInfo((FILE *) NULL,exception);
6752                 break;
6753               }
6754               case MagickThresholdOptions:
6755               {
6756                 (void) ListThresholdMaps((FILE *) NULL,exception);
6757                 break;
6758               }
6759               default:
6760               {
6761                 (void) ListCommandOptions((FILE *) NULL,(CommandOption) list,
6762                   exception);
6763                 break;
6764               }
6765             }
6766             break;
6767           }
6768         if (LocaleCompare("log",option+1) == 0)
6769           {
6770             if (*option == '+')
6771               break;
6772             (void) SetLogFormat(argv[i+1]);
6773             break;
6774           }
6775         if (LocaleCompare("loop",option+1) == 0)
6776           {
6777             if (*option == '+')
6778               {
6779                 (void) SetImageOption(image_info,option+1,"0");
6780                 break;
6781               }
6782             (void) SetImageOption(image_info,option+1,argv[i+1]);
6783             break;
6784           }
6785         break;
6786       }
6787       case 'm':
6788       {
6789         if (LocaleCompare("matte",option+1) == 0)
6790           {
6791             if (*option == '+')
6792               {
6793                 (void) SetImageOption(image_info,option+1,"false");
6794                 break;
6795               }
6796             (void) SetImageOption(image_info,option+1,"true");
6797             break;
6798           }
6799         if (LocaleCompare("mattecolor",option+1) == 0)
6800           {
6801             if (*option == '+')
6802               {
6803                 (void) SetImageOption(image_info,option+1,argv[i+1]);
6804                 (void) QueryColorCompliance(MogrifyMatteColor,AllCompliance,
6805                   &image_info->matte_color,exception);
6806                 break;
6807               }
6808             (void) SetImageOption(image_info,option+1,argv[i+1]);
6809             (void) QueryColorCompliance(argv[i+1],AllCompliance,
6810               &image_info->matte_color,exception);
6811             break;
6812           }
6813         if (LocaleCompare("monitor",option+1) == 0)
6814           {
6815             (void) SetImageInfoProgressMonitor(image_info,MonitorProgress,
6816               (void *) NULL);
6817             break;
6818           }
6819         if (LocaleCompare("monochrome",option+1) == 0)
6820           {
6821             image_info->monochrome=(*option == '-') ? MagickTrue : MagickFalse;
6822             break;
6823           }
6824         break;
6825       }
6826       case 'o':
6827       {
6828         if (LocaleCompare("orient",option+1) == 0)
6829           {
6830             if (*option == '+')
6831               {
6832                 image_info->orientation=UndefinedOrientation;
6833                 (void) SetImageOption(image_info,option+1,"undefined");
6834                 break;
6835               }
6836             image_info->orientation=(OrientationType) ParseCommandOption(
6837               MagickOrientationOptions,MagickFalse,argv[i+1]);
6838             (void) SetImageOption(image_info,option+1,argv[i+1]);
6839             break;
6840           }
6841       }
6842       case 'p':
6843       {
6844         if (LocaleCompare("page",option+1) == 0)
6845           {
6846             char
6847               *canonical_page,
6848               page[MaxTextExtent];
6849
6850             const char
6851               *image_option;
6852
6853             MagickStatusType
6854               flags;
6855
6856             RectangleInfo
6857               geometry;
6858
6859             if (*option == '+')
6860               {
6861                 (void) DeleteImageOption(image_info,option+1);
6862                 (void) CloneString(&image_info->page,(char *) NULL);
6863                 break;
6864               }
6865             (void) ResetMagickMemory(&geometry,0,sizeof(geometry));
6866             image_option=GetImageOption(image_info,"page");
6867             if (image_option != (const char *) NULL)
6868               flags=ParseAbsoluteGeometry(image_option,&geometry);
6869             canonical_page=GetPageGeometry(argv[i+1]);
6870             flags=ParseAbsoluteGeometry(canonical_page,&geometry);
6871             canonical_page=DestroyString(canonical_page);
6872             (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu",
6873               (unsigned long) geometry.width,(unsigned long) geometry.height);
6874             if (((flags & XValue) != 0) || ((flags & YValue) != 0))
6875               (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu%+ld%+ld",
6876                 (unsigned long) geometry.width,(unsigned long) geometry.height,
6877                 (long) geometry.x,(long) geometry.y);
6878             (void) SetImageOption(image_info,option+1,page);
6879             (void) CloneString(&image_info->page,page);
6880             break;
6881           }
6882         if (LocaleCompare("pen",option+1) == 0)
6883           {
6884             if (*option == '+')
6885               {
6886                 (void) SetImageOption(image_info,option+1,"none");
6887                 break;
6888               }
6889             (void) SetImageOption(image_info,option+1,argv[i+1]);
6890             break;
6891           }
6892         if (LocaleCompare("ping",option+1) == 0)
6893           {
6894             image_info->ping=(*option == '-') ? MagickTrue : MagickFalse;
6895             break;
6896           }
6897         if (LocaleCompare("pointsize",option+1) == 0)
6898           {
6899             if (*option == '+')
6900               geometry_info.rho=0.0;
6901             else
6902               (void) ParseGeometry(argv[i+1],&geometry_info);
6903             image_info->pointsize=geometry_info.rho;
6904             break;
6905           }
6906         if (LocaleCompare("precision",option+1) == 0)
6907           {
6908             (void) SetMagickPrecision(StringToInteger(argv[i+1]));
6909             break;
6910           }
6911         if (LocaleCompare("preview",option+1) == 0)
6912           {
6913             /*
6914               Preview image.
6915             */
6916             if (*option == '+')
6917               {
6918                 image_info->preview_type=UndefinedPreview;
6919                 break;
6920               }
6921             image_info->preview_type=(PreviewType) ParseCommandOption(
6922               MagickPreviewOptions,MagickFalse,argv[i+1]);
6923             break;
6924           }
6925         break;
6926       }
6927       case 'q':
6928       {
6929         if (LocaleCompare("quality",option+1) == 0)
6930           {
6931             /*
6932               Set image compression quality.
6933             */
6934             if (*option == '+')
6935               {
6936                 image_info->quality=UndefinedCompressionQuality;
6937                 (void) SetImageOption(image_info,option+1,"0");
6938                 break;
6939               }
6940             image_info->quality=StringToUnsignedLong(argv[i+1]);
6941             (void) SetImageOption(image_info,option+1,argv[i+1]);
6942             break;
6943           }
6944         if (LocaleCompare("quiet",option+1) == 0)
6945           {
6946             static WarningHandler
6947               warning_handler = (WarningHandler) NULL;
6948
6949             if (*option == '+')
6950               {
6951                 /*
6952                   Restore error or warning messages.
6953                 */
6954                 warning_handler=SetWarningHandler(warning_handler);
6955                 break;
6956               }
6957             /*
6958               Suppress error or warning messages.
6959             */
6960             warning_handler=SetWarningHandler((WarningHandler) NULL);
6961             break;
6962           }
6963         break;
6964       }
6965       case 'r':
6966       {
6967         if (LocaleCompare("red-primary",option+1) == 0)
6968           {
6969             if (*option == '+')
6970               {
6971                 (void) SetImageOption(image_info,option+1,"0.0");
6972                 break;
6973               }
6974             (void) SetImageOption(image_info,option+1,argv[i+1]);
6975             break;
6976           }
6977         break;
6978       }
6979       case 's':
6980       {
6981         if (LocaleCompare("sampling-factor",option+1) == 0)
6982           {
6983             /*
6984               Set image sampling factor.
6985             */
6986             if (*option == '+')
6987               {
6988                 if (image_info->sampling_factor != (char *) NULL)
6989                   image_info->sampling_factor=DestroyString(
6990                     image_info->sampling_factor);
6991                 break;
6992               }
6993             (void) CloneString(&image_info->sampling_factor,argv[i+1]);
6994             break;
6995           }
6996         if (LocaleCompare("scene",option+1) == 0)
6997           {
6998             /*
6999               Set image scene.
7000             */
7001             if (*option == '+')
7002               {
7003                 image_info->scene=0;
7004                 (void) SetImageOption(image_info,option+1,"0");
7005                 break;
7006               }
7007             image_info->scene=StringToUnsignedLong(argv[i+1]);
7008             (void) SetImageOption(image_info,option+1,argv[i+1]);
7009             break;
7010           }
7011         if (LocaleCompare("seed",option+1) == 0)
7012           {
7013             size_t
7014               seed;
7015
7016             if (*option == '+')
7017               {
7018                 seed=(size_t) time((time_t *) NULL);
7019                 SeedPseudoRandomGenerator(seed);
7020                 break;
7021               }
7022             seed=StringToUnsignedLong(argv[i+1]);
7023             SeedPseudoRandomGenerator(seed);
7024             break;
7025           }
7026         if (LocaleCompare("size",option+1) == 0)
7027           {
7028             if (*option == '+')
7029               {
7030                 if (image_info->size != (char *) NULL)
7031                   image_info->size=DestroyString(image_info->size);
7032                 break;
7033               }
7034             (void) CloneString(&image_info->size,argv[i+1]);
7035             break;
7036           }
7037         if (LocaleCompare("stroke",option+1) == 0)
7038           {
7039             if (*option == '+')
7040               {
7041                 (void) SetImageOption(image_info,option+1,"none");
7042                 break;
7043               }
7044             (void) SetImageOption(image_info,option+1,argv[i+1]);
7045             break;
7046           }
7047         if (LocaleCompare("strokewidth",option+1) == 0)
7048           {
7049             if (*option == '+')
7050               {
7051                 (void) SetImageOption(image_info,option+1,"0");
7052                 break;
7053               }
7054             (void) SetImageOption(image_info,option+1,argv[i+1]);
7055             break;
7056           }
7057         if (LocaleCompare("synchronize",option+1) == 0)
7058           {
7059             if (*option == '+')
7060               {
7061                 image_info->synchronize=MagickFalse;
7062                 break;
7063               }
7064             image_info->synchronize=MagickTrue;
7065             break;
7066           }
7067         break;
7068       }
7069       case 't':
7070       {
7071         if (LocaleCompare("taint",option+1) == 0)
7072           {
7073             if (*option == '+')
7074               {
7075                 (void) SetImageOption(image_info,option+1,"false");
7076                 break;
7077               }
7078             (void) SetImageOption(image_info,option+1,"true");
7079             break;
7080           }
7081         if (LocaleCompare("texture",option+1) == 0)
7082           {
7083             if (*option == '+')
7084               {
7085                 if (image_info->texture != (char *) NULL)
7086                   image_info->texture=DestroyString(image_info->texture);
7087                 break;
7088               }
7089             (void) CloneString(&image_info->texture,argv[i+1]);
7090             break;
7091           }
7092         if (LocaleCompare("tile-offset",option+1) == 0)
7093           {
7094             if (*option == '+')
7095               {
7096                 (void) SetImageOption(image_info,option+1,"0");
7097                 break;
7098               }
7099             (void) SetImageOption(image_info,option+1,argv[i+1]);
7100             break;
7101           }
7102         if (LocaleCompare("transparent-color",option+1) == 0)
7103           {
7104             if (*option == '+')
7105               {
7106                 (void) QueryColorCompliance("none",AllCompliance,
7107                   &image_info->transparent_color,exception);
7108                 (void) SetImageOption(image_info,option+1,"none");
7109                 break;
7110               }
7111             (void) QueryColorCompliance(argv[i+1],AllCompliance,
7112               &image_info->transparent_color,exception);
7113             (void) SetImageOption(image_info,option+1,argv[i+1]);
7114             break;
7115           }
7116         if (LocaleCompare("type",option+1) == 0)
7117           {
7118             if (*option == '+')
7119               {
7120                 image_info->type=UndefinedType;
7121                 (void) SetImageOption(image_info,option+1,"undefined");
7122                 break;
7123               }
7124             image_info->type=(ImageType) ParseCommandOption(MagickTypeOptions,
7125               MagickFalse,argv[i+1]);
7126             (void) SetImageOption(image_info,option+1,argv[i+1]);
7127             break;
7128           }
7129         break;
7130       }
7131       case 'u':
7132       {
7133         if (LocaleCompare("undercolor",option+1) == 0)
7134           {
7135             if (*option == '+')
7136               {
7137                 (void) DeleteImageOption(image_info,option+1);
7138                 break;
7139               }
7140             (void) SetImageOption(image_info,option+1,argv[i+1]);
7141             break;
7142           }
7143         if (LocaleCompare("units",option+1) == 0)
7144           {
7145             if (*option == '+')
7146               {
7147                 image_info->units=UndefinedResolution;
7148                 (void) SetImageOption(image_info,option+1,"undefined");
7149                 break;
7150               }
7151             image_info->units=(ResolutionType) ParseCommandOption(
7152               MagickResolutionOptions,MagickFalse,argv[i+1]);
7153             (void) SetImageOption(image_info,option+1,argv[i+1]);
7154             break;
7155           }
7156         break;
7157       }
7158       case 'v':
7159       {
7160         if (LocaleCompare("verbose",option+1) == 0)
7161           {
7162             if (*option == '+')
7163               {
7164                 image_info->verbose=MagickFalse;
7165                 break;
7166               }
7167             image_info->verbose=MagickTrue;
7168             image_info->ping=MagickFalse;
7169             break;
7170           }
7171         if (LocaleCompare("view",option+1) == 0)
7172           {
7173             if (*option == '+')
7174               {
7175                 if (image_info->view != (char *) NULL)
7176                   image_info->view=DestroyString(image_info->view);
7177                 break;
7178               }
7179             (void) CloneString(&image_info->view,argv[i+1]);
7180             break;
7181           }
7182         if (LocaleCompare("virtual-pixel",option+1) == 0)
7183           {
7184             if (*option == '+')
7185               {
7186                 image_info->virtual_pixel_method=UndefinedVirtualPixelMethod;
7187                 (void) SetImageOption(image_info,option+1,"undefined");
7188                 break;
7189               }
7190             image_info->virtual_pixel_method=(VirtualPixelMethod)
7191               ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
7192               argv[i+1]);
7193             (void) SetImageOption(image_info,option+1,argv[i+1]);
7194             break;
7195           }
7196         break;
7197       }
7198       case 'w':
7199       {
7200         if (LocaleCompare("white-point",option+1) == 0)
7201           {
7202             if (*option == '+')
7203               {
7204                 (void) SetImageOption(image_info,option+1,"0.0");
7205                 break;
7206               }
7207             (void) SetImageOption(image_info,option+1,argv[i+1]);
7208             break;
7209           }
7210         break;
7211       }
7212       default:
7213         break;
7214     }
7215     i+=count;
7216   }
7217   return(MagickTrue);
7218 }
7219 \f
7220 /*
7221 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7222 %                                                                             %
7223 %                                                                             %
7224 %                                                                             %
7225 +     M o g r i f y I m a g e L i s t                                         %
7226 %                                                                             %
7227 %                                                                             %
7228 %                                                                             %
7229 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7230 %
7231 %  MogrifyImageList() applies any command line options that might affect the
7232 %  entire image list (e.g. -append, -coalesce, etc.).
7233 %
7234 %  The format of the MogrifyImage method is:
7235 %
7236 %      MagickBooleanType MogrifyImageList(ImageInfo *image_info,const int argc,
7237 %        const char **argv,Image **images,ExceptionInfo *exception)
7238 %
7239 %  A description of each parameter follows:
7240 %
7241 %    o image_info: the image info..
7242 %
7243 %    o argc: Specifies a pointer to an integer describing the number of
7244 %      elements in the argument vector.
7245 %
7246 %    o argv: Specifies a pointer to a text array containing the command line
7247 %      arguments.
7248 %
7249 %    o images: pointer to pointer of the first image in image list.
7250 %
7251 %    o exception: return any errors or warnings in this structure.
7252 %
7253 */
7254 WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
7255   const int argc,const char **argv,Image **images,ExceptionInfo *exception)
7256 {
7257   const char
7258     *option;
7259
7260   ImageInfo
7261     *mogrify_info;
7262
7263   MagickStatusType
7264     status;
7265
7266   PixelInterpolateMethod
7267    interpolate_method;
7268
7269   QuantizeInfo
7270     *quantize_info;
7271
7272   register ssize_t
7273     i;
7274
7275   ssize_t
7276     count,
7277     index;
7278
7279   /*
7280     Apply options to the image list.
7281   */
7282   assert(image_info != (ImageInfo *) NULL);
7283   assert(image_info->signature == MagickSignature);
7284   assert(images != (Image **) NULL);
7285   assert((*images)->previous == (Image *) NULL);
7286   assert((*images)->signature == MagickSignature);
7287   if ((*images)->debug != MagickFalse)
7288     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
7289       (*images)->filename);
7290   if ((argc <= 0) || (*argv == (char *) NULL))
7291     return(MagickTrue);
7292   interpolate_method=UndefinedInterpolatePixel;
7293   mogrify_info=CloneImageInfo(image_info);
7294   quantize_info=AcquireQuantizeInfo(mogrify_info);
7295   status=MagickTrue;
7296   for (i=0; i < (ssize_t) argc; i++)
7297   {
7298     if (*images == (Image *) NULL)
7299       break;
7300     option=argv[i];
7301     if (IsCommandOption(option) == MagickFalse)
7302       continue;
7303     count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
7304     count=MagickMax(count,0L);
7305     if ((i+count) >= (ssize_t) argc)
7306       break;
7307     status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception);
7308     switch (*(option+1))
7309     {
7310       case 'a':
7311       {
7312         if (LocaleCompare("affinity",option+1) == 0)
7313           {
7314             (void) SyncImagesSettings(mogrify_info,*images);
7315             if (*option == '+')
7316               {
7317                 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7318                   exception);
7319                 break;
7320               }
7321             i++;
7322             break;
7323           }
7324         if (LocaleCompare("append",option+1) == 0)
7325           {
7326             Image
7327               *append_image;
7328
7329             (void) SyncImagesSettings(mogrify_info,*images);
7330             append_image=AppendImages(*images,*option == '-' ? MagickTrue :
7331               MagickFalse,exception);
7332             if (append_image == (Image *) NULL)
7333               {
7334                 status=MagickFalse;
7335                 break;
7336               }
7337             *images=DestroyImageList(*images);
7338             *images=append_image;
7339             break;
7340           }
7341         if (LocaleCompare("average",option+1) == 0)
7342           {
7343             Image
7344               *average_image;
7345
7346             /*
7347               Average an image sequence (deprecated).
7348             */
7349             (void) SyncImagesSettings(mogrify_info,*images);
7350             average_image=EvaluateImages(*images,MeanEvaluateOperator,
7351               exception);
7352             if (average_image == (Image *) NULL)
7353               {
7354                 status=MagickFalse;
7355                 break;
7356               }
7357             *images=DestroyImageList(*images);
7358             *images=average_image;
7359             break;
7360           }
7361         break;
7362       }
7363       case 'c':
7364       {
7365         if (LocaleCompare("channel",option+1) == 0)
7366           {
7367             ChannelType
7368               channel;
7369
7370             if (*option == '+')
7371               {
7372                 channel=DefaultChannels;
7373                 break;
7374               }
7375             channel=(ChannelType) ParseChannelOption(argv[i+1]);
7376             SetPixelChannelMap(*images,channel);
7377             break;
7378           }
7379         if (LocaleCompare("clut",option+1) == 0)
7380           {
7381             Image
7382               *clut_image,
7383               *image;
7384
7385             (void) SyncImagesSettings(mogrify_info,*images);
7386             image=RemoveFirstImageFromList(images);
7387             clut_image=RemoveFirstImageFromList(images);
7388             if (clut_image == (Image *) NULL)
7389               {
7390                 status=MagickFalse;
7391                 break;
7392               }
7393             (void) ClutImage(image,clut_image,interpolate_method,exception);
7394             clut_image=DestroyImage(clut_image);
7395             *images=DestroyImageList(*images);
7396             *images=image;
7397             break;
7398           }
7399         if (LocaleCompare("coalesce",option+1) == 0)
7400           {
7401             Image
7402               *coalesce_image;
7403
7404             (void) SyncImagesSettings(mogrify_info,*images);
7405             coalesce_image=CoalesceImages(*images,exception);
7406             if (coalesce_image == (Image *) NULL)
7407               {
7408                 status=MagickFalse;
7409                 break;
7410               }
7411             *images=DestroyImageList(*images);
7412             *images=coalesce_image;
7413             break;
7414           }
7415         if (LocaleCompare("combine",option+1) == 0)
7416           {
7417             Image
7418               *combine_image;
7419
7420             (void) SyncImagesSettings(mogrify_info,*images);
7421             combine_image=CombineImages(*images,exception);
7422             if (combine_image == (Image *) NULL)
7423               {
7424                 status=MagickFalse;
7425                 break;
7426               }
7427             *images=DestroyImageList(*images);
7428             *images=combine_image;
7429             break;
7430           }
7431         if (LocaleCompare("composite",option+1) == 0)
7432           {
7433             Image
7434               *mask_image,
7435               *composite_image,
7436               *image;
7437
7438             RectangleInfo
7439               geometry;
7440
7441             (void) SyncImagesSettings(mogrify_info,*images);
7442             image=RemoveFirstImageFromList(images);
7443             composite_image=RemoveFirstImageFromList(images);
7444             if (composite_image == (Image *) NULL)
7445               {
7446                 status=MagickFalse;
7447                 break;
7448               }
7449             (void) TransformImage(&composite_image,(char *) NULL,
7450               composite_image->geometry);
7451             SetGeometry(composite_image,&geometry);
7452             (void) ParseAbsoluteGeometry(composite_image->geometry,&geometry);
7453             GravityAdjustGeometry(image->columns,image->rows,image->gravity,
7454               &geometry);
7455             mask_image=RemoveFirstImageFromList(images);
7456             if (mask_image != (Image *) NULL)
7457               {
7458                 if ((image->compose == DisplaceCompositeOp) ||
7459                     (image->compose == DistortCompositeOp))
7460                   {
7461                     /*
7462                       Merge Y displacement into X displacement image.
7463                     */
7464                     (void) CompositeImage(composite_image,CopyGreenCompositeOp,
7465                       mask_image,0,0);
7466                     mask_image=DestroyImage(mask_image);
7467                   }
7468                 else
7469                   {
7470                     /*
7471                       Set a blending mask for the composition.
7472                       Posible error, what if image->mask already set.
7473                     */
7474                     image->mask=mask_image;
7475                     (void) NegateImage(image->mask,MagickFalse,exception);
7476                   }
7477               }
7478             (void) CompositeImage(image,image->compose,composite_image,
7479               geometry.x,geometry.y);
7480             if (mask_image != (Image *) NULL)
7481               mask_image=image->mask=DestroyImage(image->mask);
7482             composite_image=DestroyImage(composite_image);
7483             InheritException(exception,&image->exception);
7484             *images=DestroyImageList(*images);
7485             *images=image;
7486             break;
7487           }
7488         break;
7489       }
7490       case 'd':
7491       {
7492         if (LocaleCompare("deconstruct",option+1) == 0)
7493           {
7494             Image
7495               *deconstruct_image;
7496
7497             (void) SyncImagesSettings(mogrify_info,*images);
7498             deconstruct_image=CompareImagesLayers(*images,CompareAnyLayer,
7499               exception);
7500             if (deconstruct_image == (Image *) NULL)
7501               {
7502                 status=MagickFalse;
7503                 break;
7504               }
7505             *images=DestroyImageList(*images);
7506             *images=deconstruct_image;
7507             break;
7508           }
7509         if (LocaleCompare("delete",option+1) == 0)
7510           {
7511             if (*option == '+')
7512               DeleteImages(images,"-1",exception);
7513             else
7514               DeleteImages(images,argv[i+1],exception);
7515             break;
7516           }
7517         if (LocaleCompare("dither",option+1) == 0)
7518           {
7519             if (*option == '+')
7520               {
7521                 quantize_info->dither=MagickFalse;
7522                 break;
7523               }
7524             quantize_info->dither=MagickTrue;
7525             quantize_info->dither_method=(DitherMethod) ParseCommandOption(
7526               MagickDitherOptions,MagickFalse,argv[i+1]);
7527             break;
7528           }
7529         if (LocaleCompare("duplicate",option+1) == 0)
7530           {
7531             Image
7532               *duplicate_images;
7533
7534             if (*option == '+')
7535               duplicate_images=DuplicateImages(*images,1,"-1",exception);
7536             else
7537               {
7538                 const char
7539                   *p;
7540
7541                 size_t
7542                   number_duplicates;
7543
7544                 number_duplicates=(size_t) StringToLong(argv[i+1]);
7545                 p=strchr(argv[i+1],',');
7546                 if (p == (const char *) NULL)
7547                   duplicate_images=DuplicateImages(*images,number_duplicates,
7548                     "-1",exception);
7549                 else
7550                   duplicate_images=DuplicateImages(*images,number_duplicates,p,
7551                     exception);
7552               }
7553             AppendImageToList(images, duplicate_images);
7554             (void) SyncImagesSettings(mogrify_info,*images);
7555             break;
7556           }
7557         break;
7558       }
7559       case 'e':
7560       {
7561         if (LocaleCompare("evaluate-sequence",option+1) == 0)
7562           {
7563             Image
7564               *evaluate_image;
7565
7566             MagickEvaluateOperator
7567               op;
7568
7569             (void) SyncImageSettings(mogrify_info,*images);
7570             op=(MagickEvaluateOperator) ParseCommandOption(
7571               MagickEvaluateOptions,MagickFalse,argv[i+1]);
7572             evaluate_image=EvaluateImages(*images,op,exception);
7573             if (evaluate_image == (Image *) NULL)
7574               {
7575                 status=MagickFalse;
7576                 break;
7577               }
7578             *images=DestroyImageList(*images);
7579             *images=evaluate_image;
7580             break;
7581           }
7582         break;
7583       }
7584       case 'f':
7585       {
7586         if (LocaleCompare("fft",option+1) == 0)
7587           {
7588             Image
7589               *fourier_image;
7590
7591             /*
7592               Implements the discrete Fourier transform (DFT).
7593             */
7594             (void) SyncImageSettings(mogrify_info,*images);
7595             fourier_image=ForwardFourierTransformImage(*images,*option == '-' ?
7596               MagickTrue : MagickFalse,exception);
7597             if (fourier_image == (Image *) NULL)
7598               break;
7599             *images=DestroyImage(*images);
7600             *images=fourier_image;
7601             break;
7602           }
7603         if (LocaleCompare("flatten",option+1) == 0)
7604           {
7605             Image
7606               *flatten_image;
7607
7608             (void) SyncImagesSettings(mogrify_info,*images);
7609             flatten_image=MergeImageLayers(*images,FlattenLayer,exception);
7610             if (flatten_image == (Image *) NULL)
7611               break;
7612             *images=DestroyImageList(*images);
7613             *images=flatten_image;
7614             break;
7615           }
7616         if (LocaleCompare("fx",option+1) == 0)
7617           {
7618             Image
7619               *fx_image;
7620
7621             (void) SyncImagesSettings(mogrify_info,*images);
7622             fx_image=FxImage(*images,argv[i+1],exception);
7623             if (fx_image == (Image *) NULL)
7624               {
7625                 status=MagickFalse;
7626                 break;
7627               }
7628             *images=DestroyImageList(*images);
7629             *images=fx_image;
7630             break;
7631           }
7632         break;
7633       }
7634       case 'h':
7635       {
7636         if (LocaleCompare("hald-clut",option+1) == 0)
7637           {
7638             Image
7639               *hald_image,
7640               *image;
7641
7642             (void) SyncImagesSettings(mogrify_info,*images);
7643             image=RemoveFirstImageFromList(images);
7644             hald_image=RemoveFirstImageFromList(images);
7645             if (hald_image == (Image *) NULL)
7646               {
7647                 status=MagickFalse;
7648                 break;
7649               }
7650             (void) HaldClutImage(image,hald_image,exception);
7651             hald_image=DestroyImage(hald_image);
7652             if (*images != (Image *) NULL)
7653               *images=DestroyImageList(*images);
7654             *images=image;
7655             break;
7656           }
7657         break;
7658       }
7659       case 'i':
7660       {
7661         if (LocaleCompare("ift",option+1) == 0)
7662           {
7663             Image
7664               *fourier_image,
7665               *magnitude_image,
7666               *phase_image;
7667
7668             /*
7669               Implements the inverse fourier discrete Fourier transform (DFT).
7670             */
7671             (void) SyncImagesSettings(mogrify_info,*images);
7672             magnitude_image=RemoveFirstImageFromList(images);
7673             phase_image=RemoveFirstImageFromList(images);
7674             if (phase_image == (Image *) NULL)
7675               {
7676                 status=MagickFalse;
7677                 break;
7678               }
7679             fourier_image=InverseFourierTransformImage(magnitude_image,
7680               phase_image,*option == '-' ? MagickTrue : MagickFalse,exception);
7681             if (fourier_image == (Image *) NULL)
7682               break;
7683             if (*images != (Image *) NULL)
7684               *images=DestroyImage(*images);
7685             *images=fourier_image;
7686             break;
7687           }
7688         if (LocaleCompare("insert",option+1) == 0)
7689           {
7690             Image
7691               *p,
7692               *q;
7693
7694             index=0;
7695             if (*option != '+')
7696               index=(ssize_t) StringToLong(argv[i+1]);
7697             p=RemoveLastImageFromList(images);
7698             if (p == (Image *) NULL)
7699               {
7700                 (void) ThrowMagickException(exception,GetMagickModule(),
7701                   OptionError,"NoSuchImage","`%s'",argv[i+1]);
7702                 status=MagickFalse;
7703                 break;
7704               }
7705             q=p;
7706             if (index == 0)
7707               PrependImageToList(images,q);
7708             else
7709               if (index == (ssize_t) GetImageListLength(*images))
7710                 AppendImageToList(images,q);
7711               else
7712                 {
7713                    q=GetImageFromList(*images,index-1);
7714                    if (q == (Image *) NULL)
7715                      {
7716                        (void) ThrowMagickException(exception,GetMagickModule(),
7717                          OptionError,"NoSuchImage","`%s'",argv[i+1]);
7718                        status=MagickFalse;
7719                        break;
7720                      }
7721                   InsertImageInList(&q,p);
7722                 }
7723             *images=GetFirstImageInList(q);
7724             break;
7725           }
7726         if (LocaleCompare("interpolate",option+1) == 0)
7727           {
7728             interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
7729               MagickInterpolateOptions,MagickFalse,argv[i+1]);
7730             break;
7731           }
7732         break;
7733       }
7734       case 'l':
7735       {
7736         if (LocaleCompare("layers",option+1) == 0)
7737           {
7738             Image
7739               *layers;
7740
7741             ImageLayerMethod
7742               method;
7743
7744             (void) SyncImagesSettings(mogrify_info,*images);
7745             layers=(Image *) NULL;
7746             method=(ImageLayerMethod) ParseCommandOption(MagickLayerOptions,
7747               MagickFalse,argv[i+1]);
7748             switch (method)
7749             {
7750               case CoalesceLayer:
7751               {
7752                 layers=CoalesceImages(*images,exception);
7753                 break;
7754               }
7755               case CompareAnyLayer:
7756               case CompareClearLayer:
7757               case CompareOverlayLayer:
7758               default:
7759               {
7760                 layers=CompareImagesLayers(*images,method,exception);
7761                 break;
7762               }
7763               case MergeLayer:
7764               case FlattenLayer:
7765               case MosaicLayer:
7766               case TrimBoundsLayer:
7767               {
7768                 layers=MergeImageLayers(*images,method,exception);
7769                 break;
7770               }
7771               case DisposeLayer:
7772               {
7773                 layers=DisposeImages(*images,exception);
7774                 break;
7775               }
7776               case OptimizeImageLayer:
7777               {
7778                 layers=OptimizeImageLayers(*images,exception);
7779                 break;
7780               }
7781               case OptimizePlusLayer:
7782               {
7783                 layers=OptimizePlusImageLayers(*images,exception);
7784                 break;
7785               }
7786               case OptimizeTransLayer:
7787               {
7788                 OptimizeImageTransparency(*images,exception);
7789                 break;
7790               }
7791               case RemoveDupsLayer:
7792               {
7793                 RemoveDuplicateLayers(images,exception);
7794                 break;
7795               }
7796               case RemoveZeroLayer:
7797               {
7798                 RemoveZeroDelayLayers(images,exception);
7799                 break;
7800               }
7801               case OptimizeLayer:
7802               {
7803                 /*
7804                   General Purpose, GIF Animation Optimizer.
7805                 */
7806                 layers=CoalesceImages(*images,exception);
7807                 if (layers == (Image *) NULL)
7808                   {
7809                     status=MagickFalse;
7810                     break;
7811                   }
7812                 *images=DestroyImageList(*images);
7813                 *images=layers;
7814                 layers=OptimizeImageLayers(*images,exception);
7815                 if (layers == (Image *) NULL)
7816                   {
7817                     status=MagickFalse;
7818                     break;
7819                   }
7820                 *images=DestroyImageList(*images);
7821                 *images=layers;
7822                 layers=(Image *) NULL;
7823                 OptimizeImageTransparency(*images,exception);
7824                 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7825                   exception);
7826                 break;
7827               }
7828               case CompositeLayer:
7829               {
7830                 CompositeOperator
7831                   compose;
7832
7833                 Image
7834                   *source;
7835
7836                 RectangleInfo
7837                   geometry;
7838
7839                 /*
7840                   Split image sequence at the first 'NULL:' image.
7841                 */
7842                 source=(*images);
7843                 while (source != (Image *) NULL)
7844                 {
7845                   source=GetNextImageInList(source);
7846                   if ((source != (Image *) NULL) &&
7847                       (LocaleCompare(source->magick,"NULL") == 0))
7848                     break;
7849                 }
7850                 if (source != (Image *) NULL)
7851                   {
7852                     if ((GetPreviousImageInList(source) == (Image *) NULL) ||
7853                         (GetNextImageInList(source) == (Image *) NULL))
7854                       source=(Image *) NULL;
7855                     else
7856                       {
7857                         /*
7858                           Separate the two lists, junk the null: image.
7859                         */
7860                         source=SplitImageList(source->previous);
7861                         DeleteImageFromList(&source);
7862                       }
7863                   }
7864                 if (source == (Image *) NULL)
7865                   {
7866                     (void) ThrowMagickException(exception,GetMagickModule(),
7867                       OptionError,"MissingNullSeparator","layers Composite");
7868                     status=MagickFalse;
7869                     break;
7870                   }
7871                 /*
7872                   Adjust offset with gravity and virtual canvas.
7873                 */
7874                 SetGeometry(*images,&geometry);
7875                 (void) ParseAbsoluteGeometry((*images)->geometry,&geometry);
7876                 geometry.width=source->page.width != 0 ?
7877                   source->page.width : source->columns;
7878                 geometry.height=source->page.height != 0 ?
7879                  source->page.height : source->rows;
7880                 GravityAdjustGeometry((*images)->page.width != 0 ?
7881                   (*images)->page.width : (*images)->columns,
7882                   (*images)->page.height != 0 ? (*images)->page.height :
7883                   (*images)->rows,(*images)->gravity,&geometry);
7884                 compose=OverCompositeOp;
7885                 option=GetImageOption(mogrify_info,"compose");
7886                 if (option != (const char *) NULL)
7887                   compose=(CompositeOperator) ParseCommandOption(
7888                     MagickComposeOptions,MagickFalse,option);
7889                 CompositeLayers(*images,compose,source,geometry.x,geometry.y,
7890                   exception);
7891                 source=DestroyImageList(source);
7892                 break;
7893               }
7894             }
7895             if (layers == (Image *) NULL)
7896               break;
7897             InheritException(exception,&layers->exception);
7898             *images=DestroyImageList(*images);
7899             *images=layers;
7900             break;
7901           }
7902         break;
7903       }
7904       case 'm':
7905       {
7906         if (LocaleCompare("map",option+1) == 0)
7907           {
7908             (void) SyncImagesSettings(mogrify_info,*images);
7909             if (*option == '+')
7910               {
7911                 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7912                   exception);
7913                 break;
7914               }
7915             i++;
7916             break;
7917           }
7918         if (LocaleCompare("maximum",option+1) == 0)
7919           {
7920             Image
7921               *maximum_image;
7922
7923             /*
7924               Maximum image sequence (deprecated).
7925             */
7926             (void) SyncImagesSettings(mogrify_info,*images);
7927             maximum_image=EvaluateImages(*images,MaxEvaluateOperator,exception);
7928             if (maximum_image == (Image *) NULL)
7929               {
7930                 status=MagickFalse;
7931                 break;
7932               }
7933             *images=DestroyImageList(*images);
7934             *images=maximum_image;
7935             break;
7936           }
7937         if (LocaleCompare("minimum",option+1) == 0)
7938           {
7939             Image
7940               *minimum_image;
7941
7942             /*
7943               Minimum image sequence (deprecated).
7944             */
7945             (void) SyncImagesSettings(mogrify_info,*images);
7946             minimum_image=EvaluateImages(*images,MinEvaluateOperator,exception);
7947             if (minimum_image == (Image *) NULL)
7948               {
7949                 status=MagickFalse;
7950                 break;
7951               }
7952             *images=DestroyImageList(*images);
7953             *images=minimum_image;
7954             break;
7955           }
7956         if (LocaleCompare("morph",option+1) == 0)
7957           {
7958             Image
7959               *morph_image;
7960
7961             (void) SyncImagesSettings(mogrify_info,*images);
7962             morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]),
7963               exception);
7964             if (morph_image == (Image *) NULL)
7965               {
7966                 status=MagickFalse;
7967                 break;
7968               }
7969             *images=DestroyImageList(*images);
7970             *images=morph_image;
7971             break;
7972           }
7973         if (LocaleCompare("mosaic",option+1) == 0)
7974           {
7975             Image
7976               *mosaic_image;
7977
7978             (void) SyncImagesSettings(mogrify_info,*images);
7979             mosaic_image=MergeImageLayers(*images,MosaicLayer,exception);
7980             if (mosaic_image == (Image *) NULL)
7981               {
7982                 status=MagickFalse;
7983                 break;
7984               }
7985             *images=DestroyImageList(*images);
7986             *images=mosaic_image;
7987             break;
7988           }
7989         break;
7990       }
7991       case 'p':
7992       {
7993         if (LocaleCompare("print",option+1) == 0)
7994           {
7995             char
7996               *string;
7997
7998             (void) SyncImagesSettings(mogrify_info,*images);
7999             string=InterpretImageProperties(mogrify_info,*images,argv[i+1],
8000               exception);
8001             if (string == (char *) NULL)
8002               break;
8003             (void) FormatLocaleFile(stdout,"%s",string);
8004             string=DestroyString(string);
8005           }
8006         if (LocaleCompare("process",option+1) == 0)
8007           {
8008             char
8009               **arguments;
8010
8011             int
8012               j,
8013               number_arguments;
8014
8015             (void) SyncImagesSettings(mogrify_info,*images);
8016             arguments=StringToArgv(argv[i+1],&number_arguments);
8017             if (arguments == (char **) NULL)
8018               break;
8019             if ((argc > 1) && (strchr(arguments[1],'=') != (char *) NULL))
8020               {
8021                 char
8022                   breaker,
8023                   quote,
8024                   *token;
8025
8026                 const char
8027                   *arguments;
8028
8029                 int
8030                   next,
8031                   status;
8032
8033                 size_t
8034                   length;
8035
8036                 TokenInfo
8037                   *token_info;
8038
8039                 /*
8040                   Support old style syntax, filter="-option arg".
8041                 */
8042                 length=strlen(argv[i+1]);
8043                 token=(char *) NULL;
8044                 if (~length >= (MaxTextExtent-1))
8045                   token=(char *) AcquireQuantumMemory(length+MaxTextExtent,
8046                     sizeof(*token));
8047                 if (token == (char *) NULL)
8048                   break;
8049                 next=0;
8050                 arguments=argv[i+1];
8051                 token_info=AcquireTokenInfo();
8052                 status=Tokenizer(token_info,0,token,length,arguments,"","=",
8053                   "\"",'\0',&breaker,&next,&quote);
8054                 token_info=DestroyTokenInfo(token_info);
8055                 if (status == 0)
8056                   {
8057                     const char
8058                       *argv;
8059
8060                     argv=(&(arguments[next]));
8061                     (void) InvokeDynamicImageFilter(token,&(*images),1,&argv,
8062                       exception);
8063                   }
8064                 token=DestroyString(token);
8065                 break;
8066               }
8067             (void) SubstituteString(&arguments[1],"-","");
8068             (void) InvokeDynamicImageFilter(arguments[1],&(*images),
8069               number_arguments-2,(const char **) arguments+2,exception);
8070             for (j=0; j < number_arguments; j++)
8071               arguments[j]=DestroyString(arguments[j]);
8072             arguments=(char **) RelinquishMagickMemory(arguments);
8073             break;
8074           }
8075         break;
8076       }
8077       case 'r':
8078       {
8079         if (LocaleCompare("reverse",option+1) == 0)
8080           {
8081             ReverseImageList(images);
8082             InheritException(exception,&(*images)->exception);
8083             break;
8084           }
8085         break;
8086       }
8087       case 's':
8088       {
8089         if (LocaleCompare("smush",option+1) == 0)
8090           {
8091             Image
8092               *smush_image;
8093
8094             ssize_t
8095               offset;
8096
8097             (void) SyncImagesSettings(mogrify_info,*images);
8098             offset=(ssize_t) StringToLong(argv[i+1]);
8099             smush_image=SmushImages(*images,*option == '-' ? MagickTrue :
8100               MagickFalse,offset,exception);
8101             if (smush_image == (Image *) NULL)
8102               {
8103                 status=MagickFalse;
8104                 break;
8105               }
8106             *images=DestroyImageList(*images);
8107             *images=smush_image;
8108             break;
8109           }
8110         if (LocaleCompare("swap",option+1) == 0)
8111           {
8112             Image
8113               *p,
8114               *q,
8115               *swap;
8116
8117             ssize_t
8118               swap_index;
8119
8120             index=(-1);
8121             swap_index=(-2);
8122             if (*option != '+')
8123               {
8124                 GeometryInfo
8125                   geometry_info;
8126
8127                 MagickStatusType
8128                   flags;
8129
8130                 swap_index=(-1);
8131                 flags=ParseGeometry(argv[i+1],&geometry_info);
8132                 index=(ssize_t) geometry_info.rho;
8133                 if ((flags & SigmaValue) != 0)
8134                   swap_index=(ssize_t) geometry_info.sigma;
8135               }
8136             p=GetImageFromList(*images,index);
8137             q=GetImageFromList(*images,swap_index);
8138             if ((p == (Image *) NULL) || (q == (Image *) NULL))
8139               {
8140                 (void) ThrowMagickException(exception,GetMagickModule(),
8141                   OptionError,"NoSuchImage","`%s'",(*images)->filename);
8142                 status=MagickFalse;
8143                 break;
8144               }
8145             if (p == q)
8146               break;
8147             swap=CloneImage(p,0,0,MagickTrue,exception);
8148             ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,exception));
8149             ReplaceImageInList(&q,swap);
8150             *images=GetFirstImageInList(q);
8151             break;
8152           }
8153         break;
8154       }
8155       case 'w':
8156       {
8157         if (LocaleCompare("write",option+1) == 0)
8158           {
8159             char
8160               key[MaxTextExtent];
8161
8162             Image
8163               *write_images;
8164
8165             ImageInfo
8166               *write_info;
8167
8168             (void) SyncImagesSettings(mogrify_info,*images);
8169             (void) FormatLocaleString(key,MaxTextExtent,"cache:%s",argv[i+1]);
8170             (void) DeleteImageRegistry(key);
8171             write_images=(*images);
8172             if (*option == '+')
8173               write_images=CloneImageList(*images,exception);
8174             write_info=CloneImageInfo(mogrify_info);
8175             status&=WriteImages(write_info,write_images,argv[i+1],exception);
8176             write_info=DestroyImageInfo(write_info);
8177             if (*option == '+')
8178               write_images=DestroyImageList(write_images);
8179             break;
8180           }
8181         break;
8182       }
8183       default:
8184         break;
8185     }
8186     i+=count;
8187   }
8188   quantize_info=DestroyQuantizeInfo(quantize_info);
8189   mogrify_info=DestroyImageInfo(mogrify_info);
8190   status&=MogrifyImageInfo(image_info,argc,argv,exception);
8191   return(status != 0 ? MagickTrue : MagickFalse);
8192 }
8193 \f
8194 /*
8195 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8196 %                                                                             %
8197 %                                                                             %
8198 %                                                                             %
8199 +     M o g r i f y I m a g e s                                               %
8200 %                                                                             %
8201 %                                                                             %
8202 %                                                                             %
8203 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8204 %
8205 %  MogrifyImages() applies image processing options to a sequence of images as
8206 %  prescribed by command line options.
8207 %
8208 %  The format of the MogrifyImage method is:
8209 %
8210 %      MagickBooleanType MogrifyImages(ImageInfo *image_info,
8211 %        const MagickBooleanType post,const int argc,const char **argv,
8212 %        Image **images,Exceptioninfo *exception)
8213 %
8214 %  A description of each parameter follows:
8215 %
8216 %    o image_info: the image info..
8217 %
8218 %    o post: If true, post process image list operators otherwise pre-process.
8219 %
8220 %    o argc: Specifies a pointer to an integer describing the number of
8221 %      elements in the argument vector.
8222 %
8223 %    o argv: Specifies a pointer to a text array containing the command line
8224 %      arguments.
8225 %
8226 %    o images: pointer to a pointer of the first image in image list.
8227 %
8228 %    o exception: return any errors or warnings in this structure.
8229 %
8230 */
8231 WandExport MagickBooleanType MogrifyImages(ImageInfo *image_info,
8232   const MagickBooleanType post,const int argc,const char **argv,
8233   Image **images,ExceptionInfo *exception)
8234 {
8235 #define MogrifyImageTag  "Mogrify/Image"
8236
8237   MagickStatusType
8238     status;
8239
8240   MagickBooleanType
8241     proceed;
8242
8243   size_t
8244     n;
8245
8246   register ssize_t
8247     i;
8248
8249   assert(image_info != (ImageInfo *) NULL);
8250   assert(image_info->signature == MagickSignature);
8251   if (images == (Image **) NULL)
8252     return(MogrifyImage(image_info,argc,argv,images,exception));
8253   assert((*images)->previous == (Image *) NULL);
8254   assert((*images)->signature == MagickSignature);
8255   if ((*images)->debug != MagickFalse)
8256     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
8257       (*images)->filename);
8258   if ((argc <= 0) || (*argv == (char *) NULL))
8259     return(MagickTrue);
8260   (void) SetImageInfoProgressMonitor(image_info,(MagickProgressMonitor) NULL,
8261     (void *) NULL);
8262   status=0;
8263
8264 #if 0
8265   (void) FormatLocaleFile(stderr, "mogrify start %s %d (%s)\n",argv[0],argc,
8266     post?"post":"pre");
8267 #endif
8268
8269   /*
8270     Pre-process multi-image sequence operators
8271   */
8272   if (post == MagickFalse)
8273     status&=MogrifyImageList(image_info,argc,argv,images,exception);
8274   /*
8275     For each image, process simple single image operators
8276   */
8277   i=0;
8278   n=GetImageListLength(*images);
8279   for ( ; ; )
8280   {
8281 #if 0
8282   (void) FormatLocaleFile(stderr,"mogrify %ld of %ld\n",(long)
8283     GetImageIndexInList(*images),(long)GetImageListLength(*images));
8284 #endif
8285     status&=MogrifyImage(image_info,argc,argv,images,exception);
8286     proceed=SetImageProgress(*images,MogrifyImageTag,(MagickOffsetType) i, n);
8287     if (proceed == MagickFalse)
8288       break;
8289     if ( (*images)->next == (Image *) NULL )
8290       break;
8291     *images=(*images)->next;
8292     i++;
8293   }
8294   assert( *images != (Image *) NULL );
8295 #if 0
8296   (void) FormatLocaleFile(stderr,"mogrify end %ld of %ld\n",(long)
8297     GetImageIndexInList(*images),(long)GetImageListLength(*images));
8298 #endif
8299
8300   /*
8301     Post-process, multi-image sequence operators
8302   */
8303   *images=GetFirstImageInList(*images);
8304   if (post != MagickFalse)
8305     status&=MogrifyImageList(image_info,argc,argv,images,exception);
8306   return(status != 0 ? MagickTrue : MagickFalse);
8307 }