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   /*
 389     SparseColorOption() parses the complex -sparse-color argument into an
 390     an array of floating point values then calls SparseColorImage().
 391     Argument is a complex mix of floating-point pixel coodinates, and color
 392     specifications (or direct floating point numbers).  The number of floats
 393     needed to represent a color varies depending on the current channel
 394     setting.
 395   */
 396 static Image *SparseColorOption(const Image *image,
 397   const SparseColorMethod method,const char *arguments,
 398   const MagickBooleanType color_from_image,ExceptionInfo *exception)
 399 {
 400   char
 401     token[MaxTextExtent];
 402
 403   const char
 404     *p;
 405
 406   double
 407     *sparse_arguments;
 408
 409   Image
 410     *sparse_image;
 411
 412   PixelInfo
 413     color;
 414
 415   MagickBooleanType
 416     error;
 417
 418   register size_t
 419     x;
 420
 421   size_t
 422     number_arguments,
 423     number_colors;
 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               (void) DeleteImageOption(image_info,option+1);
6166             else
6167               (void) SetImageOption(image_info,option+1,argv[i+1]);
6168             break;
6169           }
6170         if (LocaleCompare("authenticate",option+1) == 0)
6171           {
6172             if (*option == '+')
6173               (void) DeleteImageOption(image_info,option+1);
6174             else
6175               (void) SetImageOption(image_info,option+1,argv[i+1]);
6176             break;
6177           }
6178         break;
6179       }
6180       case 'b':
6181       {
6182         if (LocaleCompare("background",option+1) == 0)
6183           {
6184             if (*option == '+')
6185               {
6186                 (void) DeleteImageOption(image_info,option+1);
6187                 (void) QueryColorCompliance(MogrifyBackgroundColor,
6188                   AllCompliance,&image_info->background_color,exception);
6189                 break;
6190               }
6191             (void) SetImageOption(image_info,option+1,argv[i+1]);
6192             (void) QueryColorCompliance(argv[i+1],AllCompliance,
6193               &image_info->background_color,exception);
6194             break;
6195           }
6196         if (LocaleCompare("bias",option+1) == 0)
6197           {
6198             if (*option == '+')
6199               {
6200                 (void) SetImageOption(image_info,option+1,"0.0");
6201                 break;
6202               }
6203             (void) SetImageOption(image_info,option+1,argv[i+1]);
6204             break;
6205           }
6206         if (LocaleCompare("black-point-compensation",option+1) == 0)
6207           {
6208             if (*option == '+')
6209               {
6210                 (void) SetImageOption(image_info,option+1,"false");
6211                 break;
6212               }
6213             (void) SetImageOption(image_info,option+1,"true");
6214             break;
6215           }
6216         if (LocaleCompare("blue-primary",option+1) == 0)
6217           {
6218             if (*option == '+')
6219               {
6220                 (void) SetImageOption(image_info,option+1,"0.0");
6221                 break;
6222               }
6223             (void) SetImageOption(image_info,option+1,argv[i+1]);
6224             break;
6225           }
6226         if (LocaleCompare("bordercolor",option+1) == 0)
6227           {
6228             if (*option == '+')
6229               {
6230                 (void) DeleteImageOption(image_info,option+1);
6231                 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance,
6232                   &image_info->border_color,exception);
6233                 break;
6234               }
6235             (void) QueryColorCompliance(argv[i+1],AllCompliance,
6236               &image_info->border_color,exception);
6237             (void) SetImageOption(image_info,option+1,argv[i+1]);
6238             break;
6239           }
6240         if (LocaleCompare("box",option+1) == 0)
6241           {
6242             if (*option == '+')
6243               {
6244                 (void) SetImageOption(image_info,"undercolor","none");
6245                 break;
6246               }
6247             (void) SetImageOption(image_info,"undercolor",argv[i+1]);
6248             break;
6249           }
6250         break;
6251       }
6252       case 'c':
6253       {
6254         if (LocaleCompare("cache",option+1) == 0)
6255           {
6256             MagickSizeType
6257               limit;
6258
6259             limit=MagickResourceInfinity;
6260             if (LocaleCompare("unlimited",argv[i+1]) != 0)
6261               limit=(MagickSizeType) SiPrefixToDouble(argv[i+1],100.0);
6262             (void) SetMagickResourceLimit(MemoryResource,limit);
6263             (void) SetMagickResourceLimit(MapResource,2*limit);
6264             break;
6265           }
6266         if (LocaleCompare("caption",option+1) == 0)
6267           {
6268             if (*option == '+')
6269               {
6270                 (void) DeleteImageOption(image_info,option+1);
6271                 break;
6272               }
6273             (void) SetImageOption(image_info,option+1,argv[i+1]);
6274             break;
6275           }
6276         if (LocaleCompare("channel",option+1) == 0)
6277           {
6278             if (*option == '+')
6279               {
6280                 image_info->channel=DefaultChannels;
6281                 break;
6282               }
6283             image_info->channel=(ChannelType) ParseChannelOption(argv[i+1]);
6284             break;
6285           }
6286         if (LocaleCompare("colorspace",option+1) == 0)
6287           {
6288             if (*option == '+')
6289               {
6290                 image_info->colorspace=UndefinedColorspace;
6291                 (void) SetImageOption(image_info,option+1,"undefined");
6292                 break;
6293               }
6294             image_info->colorspace=(ColorspaceType) ParseCommandOption(
6295               MagickColorspaceOptions,MagickFalse,argv[i+1]);
6296             (void) SetImageOption(image_info,option+1,argv[i+1]);
6297             break;
6298           }
6299         if (LocaleCompare("comment",option+1) == 0)
6300           {
6301             if (*option == '+')
6302               {
6303                 (void) DeleteImageOption(image_info,option+1);
6304                 break;
6305               }
6306             (void) SetImageOption(image_info,option+1,argv[i+1]);
6307             break;
6308           }
6309         if (LocaleCompare("compose",option+1) == 0)
6310           {
6311             if (*option == '+')
6312               {
6313                 (void) SetImageOption(image_info,option+1,"undefined");
6314                 break;
6315               }
6316             (void) SetImageOption(image_info,option+1,argv[i+1]);
6317             break;
6318           }
6319         if (LocaleCompare("compress",option+1) == 0)
6320           {
6321             if (*option == '+')
6322               {
6323                 image_info->compression=UndefinedCompression;
6324                 (void) SetImageOption(image_info,option+1,"undefined");
6325                 break;
6326               }
6327             image_info->compression=(CompressionType) ParseCommandOption(
6328               MagickCompressOptions,MagickFalse,argv[i+1]);
6329             (void) SetImageOption(image_info,option+1,argv[i+1]);
6330             break;
6331           }
6332         break;
6333       }
6334       case 'd':
6335       {
6336         if (LocaleCompare("debug",option+1) == 0)
6337           {
6338             if (*option == '+')
6339               (void) SetLogEventMask("none");
6340             else
6341               (void) SetLogEventMask(argv[i+1]);
6342             image_info->debug=IsEventLogging();
6343             break;
6344           }
6345         if (LocaleCompare("define",option+1) == 0)
6346           {
6347             if (*option == '+')
6348               {
6349                 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6350                   (void) DeleteImageRegistry(argv[i+1]+9);
6351                 else
6352                   (void) DeleteImageOption(image_info,argv[i+1]);
6353                 break;
6354               }
6355             if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6356               {
6357                 (void) DefineImageRegistry(StringRegistryType,argv[i+1]+9,
6358                   exception);
6359                 break;
6360               }
6361             (void) DefineImageOption(image_info,argv[i+1]);
6362             break;
6363           }
6364         if (LocaleCompare("delay",option+1) == 0)
6365           {
6366             if (*option == '+')
6367               {
6368                 (void) SetImageOption(image_info,option+1,"0");
6369                 break;
6370               }
6371             (void) SetImageOption(image_info,option+1,argv[i+1]);
6372             break;
6373           }
6374         if (LocaleCompare("density",option+1) == 0)
6375           {
6376             /*
6377               Set image density.
6378             */
6379             if (*option == '+')
6380               {
6381                 if (image_info->density != (char *) NULL)
6382                   image_info->density=DestroyString(image_info->density);
6383                 (void) SetImageOption(image_info,option+1,"72");
6384                 break;
6385               }
6386             (void) CloneString(&image_info->density,argv[i+1]);
6387             (void) SetImageOption(image_info,option+1,argv[i+1]);
6388             break;
6389           }
6390         if (LocaleCompare("depth",option+1) == 0)
6391           {
6392             if (*option == '+')
6393               {
6394                 image_info->depth=MAGICKCORE_QUANTUM_DEPTH;
6395                 break;
6396               }
6397             image_info->depth=StringToUnsignedLong(argv[i+1]);
6398             break;
6399           }
6400         if (LocaleCompare("direction",option+1) == 0)
6401           {
6402             if (*option == '+')
6403               {
6404                 (void) SetImageOption(image_info,option+1,"undefined");
6405                 break;
6406               }
6407             (void) SetImageOption(image_info,option+1,argv[i+1]);
6408             break;
6409           }
6410         if (LocaleCompare("display",option+1) == 0)
6411           {
6412             if (*option == '+')
6413               {
6414                 if (image_info->server_name != (char *) NULL)
6415                   image_info->server_name=DestroyString(
6416                     image_info->server_name);
6417                 break;
6418               }
6419             (void) CloneString(&image_info->server_name,argv[i+1]);
6420             break;
6421           }
6422         if (LocaleCompare("dispose",option+1) == 0)
6423           {
6424             if (*option == '+')
6425               {
6426                 (void) SetImageOption(image_info,option+1,"undefined");
6427                 break;
6428               }
6429             (void) SetImageOption(image_info,option+1,argv[i+1]);
6430             break;
6431           }
6432         if (LocaleCompare("dither",option+1) == 0)
6433           {
6434             if (*option == '+')
6435               {
6436                 image_info->dither=MagickFalse;
6437                 (void) SetImageOption(image_info,option+1,"none");
6438                 break;
6439               }
6440             (void) SetImageOption(image_info,option+1,argv[i+1]);
6441             image_info->dither=MagickTrue;
6442             break;
6443           }
6444         break;
6445       }
6446       case 'e':
6447       {
6448         if (LocaleCompare("encoding",option+1) == 0)
6449           {
6450             if (*option == '+')
6451               {
6452                 (void) SetImageOption(image_info,option+1,"undefined");
6453                 break;
6454               }
6455             (void) SetImageOption(image_info,option+1,argv[i+1]);
6456             break;
6457           }
6458         if (LocaleCompare("endian",option+1) == 0)
6459           {
6460             if (*option == '+')
6461               {
6462                 image_info->endian=UndefinedEndian;
6463                 (void) SetImageOption(image_info,option+1,"undefined");
6464                 break;
6465               }
6466             image_info->endian=(EndianType) ParseCommandOption(
6467               MagickEndianOptions,MagickFalse,argv[i+1]);
6468             (void) SetImageOption(image_info,option+1,argv[i+1]);
6469             break;
6470           }
6471         if (LocaleCompare("extract",option+1) == 0)
6472           {
6473             /*
6474               Set image extract geometry.
6475             */
6476             if (*option == '+')
6477               {
6478                 if (image_info->extract != (char *) NULL)
6479                   image_info->extract=DestroyString(image_info->extract);
6480                 break;
6481               }
6482             (void) CloneString(&image_info->extract,argv[i+1]);
6483             break;
6484           }
6485         break;
6486       }
6487       case 'f':
6488       {
6489         if (LocaleCompare("fill",option+1) == 0)
6490           {
6491             if (*option == '+')
6492               {
6493                 (void) SetImageOption(image_info,option+1,"none");
6494                 break;
6495               }
6496             (void) SetImageOption(image_info,option+1,argv[i+1]);
6497             break;
6498           }
6499         if (LocaleCompare("filter",option+1) == 0)
6500           {
6501             if (*option == '+')
6502               {
6503                 (void) SetImageOption(image_info,option+1,"undefined");
6504                 break;
6505               }
6506             (void) SetImageOption(image_info,option+1,argv[i+1]);
6507             break;
6508           }
6509         if (LocaleCompare("font",option+1) == 0)
6510           {
6511             if (*option == '+')
6512               {
6513                 if (image_info->font != (char *) NULL)
6514                   image_info->font=DestroyString(image_info->font);
6515                 break;
6516               }
6517             (void) CloneString(&image_info->font,argv[i+1]);
6518             break;
6519           }
6520         if (LocaleCompare("format",option+1) == 0)
6521           {
6522             register const char
6523               *q;
6524
6525             for (q=strchr(argv[i+1],'%'); q != (char *) NULL; q=strchr(q+1,'%'))
6526               if (strchr("Agkrz@[#",*(q+1)) != (char *) NULL)
6527                 image_info->ping=MagickFalse;
6528             (void) SetImageOption(image_info,option+1,argv[i+1]);
6529             break;
6530           }
6531         if (LocaleCompare("fuzz",option+1) == 0)
6532           {
6533             if (*option == '+')
6534               {
6535                 image_info->fuzz=0.0;
6536                 (void) SetImageOption(image_info,option+1,"0");
6537                 break;
6538               }
6539             image_info->fuzz=SiPrefixToDouble(argv[i+1],(double) QuantumRange+
6540               1.0);
6541             (void) SetImageOption(image_info,option+1,argv[i+1]);
6542             break;
6543           }
6544         break;
6545       }
6546       case 'g':
6547       {
6548         if (LocaleCompare("gravity",option+1) == 0)
6549           {
6550             if (*option == '+')
6551               {
6552                 (void) SetImageOption(image_info,option+1,"undefined");
6553                 break;
6554               }
6555             (void) SetImageOption(image_info,option+1,argv[i+1]);
6556             break;
6557           }
6558         if (LocaleCompare("green-primary",option+1) == 0)
6559           {
6560             if (*option == '+')
6561               {
6562                 (void) SetImageOption(image_info,option+1,"0.0");
6563                 break;
6564               }
6565             (void) SetImageOption(image_info,option+1,argv[i+1]);
6566             break;
6567           }
6568         break;
6569       }
6570       case 'i':
6571       {
6572         if (LocaleCompare("intent",option+1) == 0)
6573           {
6574             if (*option == '+')
6575               {
6576                 (void) SetImageOption(image_info,option+1,"undefined");
6577                 break;
6578               }
6579             (void) SetImageOption(image_info,option+1,argv[i+1]);
6580             break;
6581           }
6582         if (LocaleCompare("interlace",option+1) == 0)
6583           {
6584             if (*option == '+')
6585               {
6586                 image_info->interlace=UndefinedInterlace;
6587                 (void) SetImageOption(image_info,option+1,"undefined");
6588                 break;
6589               }
6590             image_info->interlace=(InterlaceType) ParseCommandOption(
6591               MagickInterlaceOptions,MagickFalse,argv[i+1]);
6592             (void) SetImageOption(image_info,option+1,argv[i+1]);
6593             break;
6594           }
6595         if (LocaleCompare("interline-spacing",option+1) == 0)
6596           {
6597             if (*option == '+')
6598               {
6599                 (void) SetImageOption(image_info,option+1,"undefined");
6600                 break;
6601               }
6602             (void) SetImageOption(image_info,option+1,argv[i+1]);
6603             break;
6604           }
6605         if (LocaleCompare("interpolate",option+1) == 0)
6606           {
6607             if (*option == '+')
6608               {
6609                 (void) SetImageOption(image_info,option+1,"undefined");
6610                 break;
6611               }
6612             (void) SetImageOption(image_info,option+1,argv[i+1]);
6613             break;
6614           }
6615         if (LocaleCompare("interword-spacing",option+1) == 0)
6616           {
6617             if (*option == '+')
6618               {
6619                 (void) SetImageOption(image_info,option+1,"undefined");
6620                 break;
6621               }
6622             (void) SetImageOption(image_info,option+1,argv[i+1]);
6623             break;
6624           }
6625         break;
6626       }
6627       case 'k':
6628       {
6629         if (LocaleCompare("kerning",option+1) == 0)
6630           {
6631             if (*option == '+')
6632               {
6633                 (void) SetImageOption(image_info,option+1,"undefined");
6634                 break;
6635               }
6636             (void) SetImageOption(image_info,option+1,argv[i+1]);
6637             break;
6638           }
6639         break;
6640       }
6641       case 'l':
6642       {
6643         if (LocaleCompare("label",option+1) == 0)
6644           {
6645             if (*option == '+')
6646               {
6647                 (void) DeleteImageOption(image_info,option+1);
6648                 break;
6649               }
6650             (void) SetImageOption(image_info,option+1,argv[i+1]);
6651             break;
6652           }
6653         if (LocaleCompare("limit",option+1) == 0)
6654           {
6655             MagickSizeType
6656               limit;
6657
6658             ResourceType
6659               type;
6660
6661             if (*option == '+')
6662               break;
6663             type=(ResourceType) ParseCommandOption(MagickResourceOptions,
6664               MagickFalse,argv[i+1]);
6665             limit=MagickResourceInfinity;
6666             if (LocaleCompare("unlimited",argv[i+2]) != 0)
6667               limit=(MagickSizeType) SiPrefixToDouble(argv[i+2],100.0);
6668             (void) SetMagickResourceLimit(type,limit);
6669             break;
6670           }
6671         if (LocaleCompare("list",option+1) == 0)
6672           {
6673             ssize_t
6674               list;
6675
6676             /*
6677               Display configuration list.
6678             */
6679             list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i+1]);
6680             switch (list)
6681             {
6682               case MagickCoderOptions:
6683               {
6684                 (void) ListCoderInfo((FILE *) NULL,exception);
6685                 break;
6686               }
6687               case MagickColorOptions:
6688               {
6689                 (void) ListColorInfo((FILE *) NULL,exception);
6690                 break;
6691               }
6692               case MagickConfigureOptions:
6693               {
6694                 (void) ListConfigureInfo((FILE *) NULL,exception);
6695                 break;
6696               }
6697               case MagickDelegateOptions:
6698               {
6699                 (void) ListDelegateInfo((FILE *) NULL,exception);
6700                 break;
6701               }
6702               case MagickFontOptions:
6703               {
6704                 (void) ListTypeInfo((FILE *) NULL,exception);
6705                 break;
6706               }
6707               case MagickFormatOptions:
6708               {
6709                 (void) ListMagickInfo((FILE *) NULL,exception);
6710                 break;
6711               }
6712               case MagickLocaleOptions:
6713               {
6714                 (void) ListLocaleInfo((FILE *) NULL,exception);
6715                 break;
6716               }
6717               case MagickLogOptions:
6718               {
6719                 (void) ListLogInfo((FILE *) NULL,exception);
6720                 break;
6721               }
6722               case MagickMagicOptions:
6723               {
6724                 (void) ListMagicInfo((FILE *) NULL,exception);
6725                 break;
6726               }
6727               case MagickMimeOptions:
6728               {
6729                 (void) ListMimeInfo((FILE *) NULL,exception);
6730                 break;
6731               }
6732               case MagickModuleOptions:
6733               {
6734                 (void) ListModuleInfo((FILE *) NULL,exception);
6735                 break;
6736               }
6737               case MagickPolicyOptions:
6738               {
6739                 (void) ListPolicyInfo((FILE *) NULL,exception);
6740                 break;
6741               }
6742               case MagickResourceOptions:
6743               {
6744                 (void) ListMagickResourceInfo((FILE *) NULL,exception);
6745                 break;
6746               }
6747               case MagickThresholdOptions:
6748               {
6749                 (void) ListThresholdMaps((FILE *) NULL,exception);
6750                 break;
6751               }
6752               default:
6753               {
6754                 (void) ListCommandOptions((FILE *) NULL,(CommandOption) list,
6755                   exception);
6756                 break;
6757               }
6758             }
6759             break;
6760           }
6761         if (LocaleCompare("log",option+1) == 0)
6762           {
6763             if (*option == '+')
6764               break;
6765             (void) SetLogFormat(argv[i+1]);
6766             break;
6767           }
6768         if (LocaleCompare("loop",option+1) == 0)
6769           {
6770             if (*option == '+')
6771               {
6772                 (void) SetImageOption(image_info,option+1,"0");
6773                 break;
6774               }
6775             (void) SetImageOption(image_info,option+1,argv[i+1]);
6776             break;
6777           }
6778         break;
6779       }
6780       case 'm':
6781       {
6782         if (LocaleCompare("matte",option+1) == 0)
6783           {
6784             if (*option == '+')
6785               {
6786                 (void) SetImageOption(image_info,option+1,"false");
6787                 break;
6788               }
6789             (void) SetImageOption(image_info,option+1,"true");
6790             break;
6791           }
6792         if (LocaleCompare("mattecolor",option+1) == 0)
6793           {
6794             if (*option == '+')
6795               {
6796                 (void) SetImageOption(image_info,option+1,argv[i+1]);
6797                 (void) QueryColorCompliance(MogrifyMatteColor,AllCompliance,
6798                   &image_info->matte_color,exception);
6799                 break;
6800               }
6801             (void) SetImageOption(image_info,option+1,argv[i+1]);
6802             (void) QueryColorCompliance(argv[i+1],AllCompliance,
6803               &image_info->matte_color,exception);
6804             break;
6805           }
6806         if (LocaleCompare("monitor",option+1) == 0)
6807           {
6808             (void) SetImageInfoProgressMonitor(image_info,MonitorProgress,
6809               (void *) NULL);
6810             break;
6811           }
6812         if (LocaleCompare("monochrome",option+1) == 0)
6813           {
6814             image_info->monochrome=(*option == '-') ? MagickTrue : MagickFalse;
6815             break;
6816           }
6817         break;
6818       }
6819       case 'o':
6820       {
6821         if (LocaleCompare("orient",option+1) == 0)
6822           {
6823             if (*option == '+')
6824               {
6825                 image_info->orientation=UndefinedOrientation;
6826                 (void) SetImageOption(image_info,option+1,"undefined");
6827                 break;
6828               }
6829             image_info->orientation=(OrientationType) ParseCommandOption(
6830               MagickOrientationOptions,MagickFalse,argv[i+1]);
6831             (void) SetImageOption(image_info,option+1,argv[i+1]);
6832             break;
6833           }
6834       }
6835       case 'p':
6836       {
6837         if (LocaleCompare("page",option+1) == 0)
6838           {
6839             char
6840               *canonical_page,
6841               page[MaxTextExtent];
6842
6843             const char
6844               *image_option;
6845
6846             MagickStatusType
6847               flags;
6848
6849             RectangleInfo
6850               geometry;
6851
6852             if (*option == '+')
6853               {
6854                 (void) DeleteImageOption(image_info,option+1);
6855                 (void) CloneString(&image_info->page,(char *) NULL);
6856                 break;
6857               }
6858             (void) ResetMagickMemory(&geometry,0,sizeof(geometry));
6859             image_option=GetImageOption(image_info,"page");
6860             if (image_option != (const char *) NULL)
6861               flags=ParseAbsoluteGeometry(image_option,&geometry);
6862             canonical_page=GetPageGeometry(argv[i+1]);
6863             flags=ParseAbsoluteGeometry(canonical_page,&geometry);
6864             canonical_page=DestroyString(canonical_page);
6865             (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu",
6866               (unsigned long) geometry.width,(unsigned long) geometry.height);
6867             if (((flags & XValue) != 0) || ((flags & YValue) != 0))
6868               (void) FormatLocaleString(page,MaxTextExtent,"%lux%lu%+ld%+ld",
6869                 (unsigned long) geometry.width,(unsigned long) geometry.height,
6870                 (long) geometry.x,(long) geometry.y);
6871             (void) SetImageOption(image_info,option+1,page);
6872             (void) CloneString(&image_info->page,page);
6873             break;
6874           }
6875         if (LocaleCompare("pen",option+1) == 0)
6876           {
6877             if (*option == '+')
6878               {
6879                 (void) SetImageOption(image_info,option+1,"none");
6880                 break;
6881               }
6882             (void) SetImageOption(image_info,option+1,argv[i+1]);
6883             break;
6884           }
6885         if (LocaleCompare("ping",option+1) == 0)
6886           {
6887             image_info->ping=(*option == '-') ? MagickTrue : MagickFalse;
6888             break;
6889           }
6890         if (LocaleCompare("pointsize",option+1) == 0)
6891           {
6892             if (*option == '+')
6893               geometry_info.rho=0.0;
6894             else
6895               (void) ParseGeometry(argv[i+1],&geometry_info);
6896             image_info->pointsize=geometry_info.rho;
6897             break;
6898           }
6899         if (LocaleCompare("precision",option+1) == 0)
6900           {
6901             (void) SetMagickPrecision(StringToInteger(argv[i+1]));
6902             break;
6903           }
6904         if (LocaleCompare("preview",option+1) == 0)
6905           {
6906             /*
6907               Preview image.
6908             */
6909             if (*option == '+')
6910               {
6911                 image_info->preview_type=UndefinedPreview;
6912                 break;
6913               }
6914             image_info->preview_type=(PreviewType) ParseCommandOption(
6915               MagickPreviewOptions,MagickFalse,argv[i+1]);
6916             break;
6917           }
6918         break;
6919       }
6920       case 'q':
6921       {
6922         if (LocaleCompare("quality",option+1) == 0)
6923           {
6924             /*
6925               Set image compression quality.
6926             */
6927             if (*option == '+')
6928               {
6929                 image_info->quality=UndefinedCompressionQuality;
6930                 (void) SetImageOption(image_info,option+1,"0");
6931                 break;
6932               }
6933             image_info->quality=StringToUnsignedLong(argv[i+1]);
6934             (void) SetImageOption(image_info,option+1,argv[i+1]);
6935             break;
6936           }
6937         if (LocaleCompare("quiet",option+1) == 0)
6938           {
6939             static WarningHandler
6940               warning_handler = (WarningHandler) NULL;
6941
6942             if (*option == '+')
6943               {
6944                 /*
6945                   Restore error or warning messages.
6946                 */
6947                 warning_handler=SetWarningHandler(warning_handler);
6948                 break;
6949               }
6950             /*
6951               Suppress error or warning messages.
6952             */
6953             warning_handler=SetWarningHandler((WarningHandler) NULL);
6954             break;
6955           }
6956         break;
6957       }
6958       case 'r':
6959       {
6960         if (LocaleCompare("red-primary",option+1) == 0)
6961           {
6962             if (*option == '+')
6963               {
6964                 (void) SetImageOption(image_info,option+1,"0.0");
6965                 break;
6966               }
6967             (void) SetImageOption(image_info,option+1,argv[i+1]);
6968             break;
6969           }
6970         break;
6971       }
6972       case 's':
6973       {
6974         if (LocaleCompare("sampling-factor",option+1) == 0)
6975           {
6976             /*
6977               Set image sampling factor.
6978             */
6979             if (*option == '+')
6980               {
6981                 if (image_info->sampling_factor != (char *) NULL)
6982                   image_info->sampling_factor=DestroyString(
6983                     image_info->sampling_factor);
6984                 break;
6985               }
6986             (void) CloneString(&image_info->sampling_factor,argv[i+1]);
6987             break;
6988           }
6989         if (LocaleCompare("scene",option+1) == 0)
6990           {
6991             /*
6992               Set image scene.
6993             */
6994             if (*option == '+')
6995               {
6996                 image_info->scene=0;
6997                 (void) SetImageOption(image_info,option+1,"0");
6998                 break;
6999               }
7000             image_info->scene=StringToUnsignedLong(argv[i+1]);
7001             (void) SetImageOption(image_info,option+1,argv[i+1]);
7002             break;
7003           }
7004         if (LocaleCompare("seed",option+1) == 0)
7005           {
7006             size_t
7007               seed;
7008
7009             if (*option == '+')
7010               {
7011                 seed=(size_t) time((time_t *) NULL);
7012                 SeedPseudoRandomGenerator(seed);
7013                 break;
7014               }
7015             seed=StringToUnsignedLong(argv[i+1]);
7016             SeedPseudoRandomGenerator(seed);
7017             break;
7018           }
7019         if (LocaleCompare("size",option+1) == 0)
7020           {
7021             if (*option == '+')
7022               {
7023                 if (image_info->size != (char *) NULL)
7024                   image_info->size=DestroyString(image_info->size);
7025                 break;
7026               }
7027             (void) CloneString(&image_info->size,argv[i+1]);
7028             break;
7029           }
7030         if (LocaleCompare("stroke",option+1) == 0)
7031           {
7032             if (*option == '+')
7033               {
7034                 (void) SetImageOption(image_info,option+1,"none");
7035                 break;
7036               }
7037             (void) SetImageOption(image_info,option+1,argv[i+1]);
7038             break;
7039           }
7040         if (LocaleCompare("strokewidth",option+1) == 0)
7041           {
7042             if (*option == '+')
7043               {
7044                 (void) SetImageOption(image_info,option+1,"0");
7045                 break;
7046               }
7047             (void) SetImageOption(image_info,option+1,argv[i+1]);
7048             break;
7049           }
7050         if (LocaleCompare("synchronize",option+1) == 0)
7051           {
7052             if (*option == '+')
7053               {
7054                 image_info->synchronize=MagickFalse;
7055                 break;
7056               }
7057             image_info->synchronize=MagickTrue;
7058             break;
7059           }
7060         break;
7061       }
7062       case 't':
7063       {
7064         if (LocaleCompare("taint",option+1) == 0)
7065           {
7066             if (*option == '+')
7067               {
7068                 (void) SetImageOption(image_info,option+1,"false");
7069                 break;
7070               }
7071             (void) SetImageOption(image_info,option+1,"true");
7072             break;
7073           }
7074         if (LocaleCompare("texture",option+1) == 0)
7075           {
7076             if (*option == '+')
7077               {
7078                 if (image_info->texture != (char *) NULL)
7079                   image_info->texture=DestroyString(image_info->texture);
7080                 break;
7081               }
7082             (void) CloneString(&image_info->texture,argv[i+1]);
7083             break;
7084           }
7085         if (LocaleCompare("tile-offset",option+1) == 0)
7086           {
7087             if (*option == '+')
7088               {
7089                 (void) SetImageOption(image_info,option+1,"0");
7090                 break;
7091               }
7092             (void) SetImageOption(image_info,option+1,argv[i+1]);
7093             break;
7094           }
7095         if (LocaleCompare("transparent-color",option+1) == 0)
7096           {
7097             if (*option == '+')
7098               {
7099                 (void) QueryColorCompliance("none",AllCompliance,
7100                   &image_info->transparent_color,exception);
7101                 (void) SetImageOption(image_info,option+1,"none");
7102                 break;
7103               }
7104             (void) QueryColorCompliance(argv[i+1],AllCompliance,
7105               &image_info->transparent_color,exception);
7106             (void) SetImageOption(image_info,option+1,argv[i+1]);
7107             break;
7108           }
7109         if (LocaleCompare("type",option+1) == 0)
7110           {
7111             if (*option == '+')
7112               {
7113                 image_info->type=UndefinedType;
7114                 (void) SetImageOption(image_info,option+1,"undefined");
7115                 break;
7116               }
7117             image_info->type=(ImageType) ParseCommandOption(MagickTypeOptions,
7118               MagickFalse,argv[i+1]);
7119             (void) SetImageOption(image_info,option+1,argv[i+1]);
7120             break;
7121           }
7122         break;
7123       }
7124       case 'u':
7125       {
7126         if (LocaleCompare("undercolor",option+1) == 0)
7127           {
7128             if (*option == '+')
7129               {
7130                 (void) DeleteImageOption(image_info,option+1);
7131                 break;
7132               }
7133             (void) SetImageOption(image_info,option+1,argv[i+1]);
7134             break;
7135           }
7136         if (LocaleCompare("units",option+1) == 0)
7137           {
7138             if (*option == '+')
7139               {
7140                 image_info->units=UndefinedResolution;
7141                 (void) SetImageOption(image_info,option+1,"undefined");
7142                 break;
7143               }
7144             image_info->units=(ResolutionType) ParseCommandOption(
7145               MagickResolutionOptions,MagickFalse,argv[i+1]);
7146             (void) SetImageOption(image_info,option+1,argv[i+1]);
7147             break;
7148           }
7149         break;
7150       }
7151       case 'v':
7152       {
7153         if (LocaleCompare("verbose",option+1) == 0)
7154           {
7155             if (*option == '+')
7156               {
7157                 image_info->verbose=MagickFalse;
7158                 break;
7159               }
7160             image_info->verbose=MagickTrue;
7161             image_info->ping=MagickFalse;
7162             break;
7163           }
7164         if (LocaleCompare("view",option+1) == 0)
7165           {
7166             if (*option == '+')
7167               {
7168                 if (image_info->view != (char *) NULL)
7169                   image_info->view=DestroyString(image_info->view);
7170                 break;
7171               }
7172             (void) CloneString(&image_info->view,argv[i+1]);
7173             break;
7174           }
7175         if (LocaleCompare("virtual-pixel",option+1) == 0)
7176           {
7177             if (*option == '+')
7178               {
7179                 image_info->virtual_pixel_method=UndefinedVirtualPixelMethod;
7180                 (void) SetImageOption(image_info,option+1,"undefined");
7181                 break;
7182               }
7183             image_info->virtual_pixel_method=(VirtualPixelMethod)
7184               ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
7185               argv[i+1]);
7186             (void) SetImageOption(image_info,option+1,argv[i+1]);
7187             break;
7188           }
7189         break;
7190       }
7191       case 'w':
7192       {
7193         if (LocaleCompare("white-point",option+1) == 0)
7194           {
7195             if (*option == '+')
7196               {
7197                 (void) SetImageOption(image_info,option+1,"0.0");
7198                 break;
7199               }
7200             (void) SetImageOption(image_info,option+1,argv[i+1]);
7201             break;
7202           }
7203         break;
7204       }
7205       default:
7206         break;
7207     }
7208     i+=count;
7209   }
7210   return(MagickTrue);
7211 }
7212 \f
7213 /*
7214 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7215 %                                                                             %
7216 %                                                                             %
7217 %                                                                             %
7218 +     M o g r i f y I m a g e L i s t                                         %
7219 %                                                                             %
7220 %                                                                             %
7221 %                                                                             %
7222 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7223 %
7224 %  MogrifyImageList() applies any command line options that might affect the
7225 %  entire image list (e.g. -append, -coalesce, etc.).
7226 %
7227 %  The format of the MogrifyImage method is:
7228 %
7229 %      MagickBooleanType MogrifyImageList(ImageInfo *image_info,const int argc,
7230 %        const char **argv,Image **images,ExceptionInfo *exception)
7231 %
7232 %  A description of each parameter follows:
7233 %
7234 %    o image_info: the image info..
7235 %
7236 %    o argc: Specifies a pointer to an integer describing the number of
7237 %      elements in the argument vector.
7238 %
7239 %    o argv: Specifies a pointer to a text array containing the command line
7240 %      arguments.
7241 %
7242 %    o images: pointer to pointer of the first image in image list.
7243 %
7244 %    o exception: return any errors or warnings in this structure.
7245 %
7246 */
7247 WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
7248   const int argc,const char **argv,Image **images,ExceptionInfo *exception)
7249 {
7250   const char
7251     *option;
7252
7253   ImageInfo
7254     *mogrify_info;
7255
7256   MagickStatusType
7257     status;
7258
7259   PixelInterpolateMethod
7260    interpolate_method;
7261
7262   QuantizeInfo
7263     *quantize_info;
7264
7265   register ssize_t
7266     i;
7267
7268   ssize_t
7269     count,
7270     index;
7271
7272   /*
7273     Apply options to the image list.
7274   */
7275   assert(image_info != (ImageInfo *) NULL);
7276   assert(image_info->signature == MagickSignature);
7277   assert(images != (Image **) NULL);
7278   assert((*images)->previous == (Image *) NULL);
7279   assert((*images)->signature == MagickSignature);
7280   if ((*images)->debug != MagickFalse)
7281     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
7282       (*images)->filename);
7283   if ((argc <= 0) || (*argv == (char *) NULL))
7284     return(MagickTrue);
7285   interpolate_method=UndefinedInterpolatePixel;
7286   mogrify_info=CloneImageInfo(image_info);
7287   quantize_info=AcquireQuantizeInfo(mogrify_info);
7288   status=MagickTrue;
7289   for (i=0; i < (ssize_t) argc; i++)
7290   {
7291     if (*images == (Image *) NULL)
7292       break;
7293     option=argv[i];
7294     if (IsCommandOption(option) == MagickFalse)
7295       continue;
7296     count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
7297     count=MagickMax(count,0L);
7298     if ((i+count) >= (ssize_t) argc)
7299       break;
7300     status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception);
7301     switch (*(option+1))
7302     {
7303       case 'a':
7304       {
7305         if (LocaleCompare("affinity",option+1) == 0)
7306           {
7307             (void) SyncImagesSettings(mogrify_info,*images);
7308             if (*option == '+')
7309               {
7310                 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7311                   exception);
7312                 break;
7313               }
7314             i++;
7315             break;
7316           }
7317         if (LocaleCompare("append",option+1) == 0)
7318           {
7319             Image
7320               *append_image;
7321
7322             (void) SyncImagesSettings(mogrify_info,*images);
7323             append_image=AppendImages(*images,*option == '-' ? MagickTrue :
7324               MagickFalse,exception);
7325             if (append_image == (Image *) NULL)
7326               {
7327                 status=MagickFalse;
7328                 break;
7329               }
7330             *images=DestroyImageList(*images);
7331             *images=append_image;
7332             break;
7333           }
7334         if (LocaleCompare("average",option+1) == 0)
7335           {
7336             Image
7337               *average_image;
7338
7339             /*
7340               Average an image sequence (deprecated).
7341             */
7342             (void) SyncImagesSettings(mogrify_info,*images);
7343             average_image=EvaluateImages(*images,MeanEvaluateOperator,
7344               exception);
7345             if (average_image == (Image *) NULL)
7346               {
7347                 status=MagickFalse;
7348                 break;
7349               }
7350             *images=DestroyImageList(*images);
7351             *images=average_image;
7352             break;
7353           }
7354         break;
7355       }
7356       case 'c':
7357       {
7358         if (LocaleCompare("channel",option+1) == 0)
7359           {
7360             ChannelType
7361               channel;
7362
7363             if (*option == '+')
7364               {
7365                 channel=DefaultChannels;
7366                 break;
7367               }
7368             channel=(ChannelType) ParseChannelOption(argv[i+1]);
7369             SetPixelChannelMap(*images,channel);
7370             break;
7371           }
7372         if (LocaleCompare("clut",option+1) == 0)
7373           {
7374             Image
7375               *clut_image,
7376               *image;
7377
7378             (void) SyncImagesSettings(mogrify_info,*images);
7379             image=RemoveFirstImageFromList(images);
7380             clut_image=RemoveFirstImageFromList(images);
7381             if (clut_image == (Image *) NULL)
7382               {
7383                 status=MagickFalse;
7384                 break;
7385               }
7386             (void) ClutImage(image,clut_image,interpolate_method,exception);
7387             clut_image=DestroyImage(clut_image);
7388             *images=DestroyImageList(*images);
7389             *images=image;
7390             break;
7391           }
7392         if (LocaleCompare("coalesce",option+1) == 0)
7393           {
7394             Image
7395               *coalesce_image;
7396
7397             (void) SyncImagesSettings(mogrify_info,*images);
7398             coalesce_image=CoalesceImages(*images,exception);
7399             if (coalesce_image == (Image *) NULL)
7400               {
7401                 status=MagickFalse;
7402                 break;
7403               }
7404             *images=DestroyImageList(*images);
7405             *images=coalesce_image;
7406             break;
7407           }
7408         if (LocaleCompare("combine",option+1) == 0)
7409           {
7410             Image
7411               *combine_image;
7412
7413             (void) SyncImagesSettings(mogrify_info,*images);
7414             combine_image=CombineImages(*images,exception);
7415             if (combine_image == (Image *) NULL)
7416               {
7417                 status=MagickFalse;
7418                 break;
7419               }
7420             *images=DestroyImageList(*images);
7421             *images=combine_image;
7422             break;
7423           }
7424         if (LocaleCompare("composite",option+1) == 0)
7425           {
7426             Image
7427               *mask_image,
7428               *composite_image,
7429               *image;
7430
7431             RectangleInfo
7432               geometry;
7433
7434             (void) SyncImagesSettings(mogrify_info,*images);
7435             image=RemoveFirstImageFromList(images);
7436             composite_image=RemoveFirstImageFromList(images);
7437             if (composite_image == (Image *) NULL)
7438               {
7439                 status=MagickFalse;
7440                 break;
7441               }
7442             (void) TransformImage(&composite_image,(char *) NULL,
7443               composite_image->geometry);
7444             SetGeometry(composite_image,&geometry);
7445             (void) ParseAbsoluteGeometry(composite_image->geometry,&geometry);
7446             GravityAdjustGeometry(image->columns,image->rows,image->gravity,
7447               &geometry);
7448             mask_image=RemoveFirstImageFromList(images);
7449             if (mask_image != (Image *) NULL)
7450               {
7451                 if ((image->compose == DisplaceCompositeOp) ||
7452                     (image->compose == DistortCompositeOp))
7453                   {
7454                     /*
7455                       Merge Y displacement into X displacement image.
7456                     */
7457                     (void) CompositeImage(composite_image,CopyGreenCompositeOp,
7458                       mask_image,0,0);
7459                     mask_image=DestroyImage(mask_image);
7460                   }
7461                 else
7462                   {
7463                     /*
7464                       Set a blending mask for the composition.
7465                       Posible error, what if image->mask already set.
7466                     */
7467                     image->mask=mask_image;
7468                     (void) NegateImage(image->mask,MagickFalse,exception);
7469                   }
7470               }
7471             (void) CompositeImage(image,image->compose,composite_image,
7472               geometry.x,geometry.y);
7473             if (mask_image != (Image *) NULL)
7474               mask_image=image->mask=DestroyImage(image->mask);
7475             composite_image=DestroyImage(composite_image);
7476             InheritException(exception,&image->exception);
7477             *images=DestroyImageList(*images);
7478             *images=image;
7479             break;
7480           }
7481         break;
7482       }
7483       case 'd':
7484       {
7485         if (LocaleCompare("deconstruct",option+1) == 0)
7486           {
7487             Image
7488               *deconstruct_image;
7489
7490             (void) SyncImagesSettings(mogrify_info,*images);
7491             deconstruct_image=CompareImagesLayers(*images,CompareAnyLayer,
7492               exception);
7493             if (deconstruct_image == (Image *) NULL)
7494               {
7495                 status=MagickFalse;
7496                 break;
7497               }
7498             *images=DestroyImageList(*images);
7499             *images=deconstruct_image;
7500             break;
7501           }
7502         if (LocaleCompare("delete",option+1) == 0)
7503           {
7504             if (*option == '+')
7505               DeleteImages(images,"-1",exception);
7506             else
7507               DeleteImages(images,argv[i+1],exception);
7508             break;
7509           }
7510         if (LocaleCompare("dither",option+1) == 0)
7511           {
7512             if (*option == '+')
7513               {
7514                 quantize_info->dither=MagickFalse;
7515                 break;
7516               }
7517             quantize_info->dither=MagickTrue;
7518             quantize_info->dither_method=(DitherMethod) ParseCommandOption(
7519               MagickDitherOptions,MagickFalse,argv[i+1]);
7520             break;
7521           }
7522         if (LocaleCompare("duplicate",option+1) == 0)
7523           {
7524             Image
7525               *duplicate_images;
7526
7527             if (*option == '+')
7528               duplicate_images=DuplicateImages(*images,1,"-1",exception);
7529             else
7530               {
7531                 const char
7532                   *p;
7533
7534                 size_t
7535                   number_duplicates;
7536
7537                 number_duplicates=(size_t) StringToLong(argv[i+1]);
7538                 p=strchr(argv[i+1],',');
7539                 if (p == (const char *) NULL)
7540                   duplicate_images=DuplicateImages(*images,number_duplicates,
7541                     "-1",exception);
7542                 else
7543                   duplicate_images=DuplicateImages(*images,number_duplicates,p,
7544                     exception);
7545               }
7546             AppendImageToList(images, duplicate_images);
7547             (void) SyncImagesSettings(mogrify_info,*images);
7548             break;
7549           }
7550         break;
7551       }
7552       case 'e':
7553       {
7554         if (LocaleCompare("evaluate-sequence",option+1) == 0)
7555           {
7556             Image
7557               *evaluate_image;
7558
7559             MagickEvaluateOperator
7560               op;
7561
7562             (void) SyncImageSettings(mogrify_info,*images);
7563             op=(MagickEvaluateOperator) ParseCommandOption(
7564               MagickEvaluateOptions,MagickFalse,argv[i+1]);
7565             evaluate_image=EvaluateImages(*images,op,exception);
7566             if (evaluate_image == (Image *) NULL)
7567               {
7568                 status=MagickFalse;
7569                 break;
7570               }
7571             *images=DestroyImageList(*images);
7572             *images=evaluate_image;
7573             break;
7574           }
7575         break;
7576       }
7577       case 'f':
7578       {
7579         if (LocaleCompare("fft",option+1) == 0)
7580           {
7581             Image
7582               *fourier_image;
7583
7584             /*
7585               Implements the discrete Fourier transform (DFT).
7586             */
7587             (void) SyncImageSettings(mogrify_info,*images);
7588             fourier_image=ForwardFourierTransformImage(*images,*option == '-' ?
7589               MagickTrue : MagickFalse,exception);
7590             if (fourier_image == (Image *) NULL)
7591               break;
7592             *images=DestroyImage(*images);
7593             *images=fourier_image;
7594             break;
7595           }
7596         if (LocaleCompare("flatten",option+1) == 0)
7597           {
7598             Image
7599               *flatten_image;
7600
7601             (void) SyncImagesSettings(mogrify_info,*images);
7602             flatten_image=MergeImageLayers(*images,FlattenLayer,exception);
7603             if (flatten_image == (Image *) NULL)
7604               break;
7605             *images=DestroyImageList(*images);
7606             *images=flatten_image;
7607             break;
7608           }
7609         if (LocaleCompare("fx",option+1) == 0)
7610           {
7611             Image
7612               *fx_image;
7613
7614             (void) SyncImagesSettings(mogrify_info,*images);
7615             fx_image=FxImage(*images,argv[i+1],exception);
7616             if (fx_image == (Image *) NULL)
7617               {
7618                 status=MagickFalse;
7619                 break;
7620               }
7621             *images=DestroyImageList(*images);
7622             *images=fx_image;
7623             break;
7624           }
7625         break;
7626       }
7627       case 'h':
7628       {
7629         if (LocaleCompare("hald-clut",option+1) == 0)
7630           {
7631             Image
7632               *hald_image,
7633               *image;
7634
7635             (void) SyncImagesSettings(mogrify_info,*images);
7636             image=RemoveFirstImageFromList(images);
7637             hald_image=RemoveFirstImageFromList(images);
7638             if (hald_image == (Image *) NULL)
7639               {
7640                 status=MagickFalse;
7641                 break;
7642               }
7643             (void) HaldClutImage(image,hald_image,exception);
7644             hald_image=DestroyImage(hald_image);
7645             if (*images != (Image *) NULL)
7646               *images=DestroyImageList(*images);
7647             *images=image;
7648             break;
7649           }
7650         break;
7651       }
7652       case 'i':
7653       {
7654         if (LocaleCompare("ift",option+1) == 0)
7655           {
7656             Image
7657               *fourier_image,
7658               *magnitude_image,
7659               *phase_image;
7660
7661             /*
7662               Implements the inverse fourier discrete Fourier transform (DFT).
7663             */
7664             (void) SyncImagesSettings(mogrify_info,*images);
7665             magnitude_image=RemoveFirstImageFromList(images);
7666             phase_image=RemoveFirstImageFromList(images);
7667             if (phase_image == (Image *) NULL)
7668               {
7669                 status=MagickFalse;
7670                 break;
7671               }
7672             fourier_image=InverseFourierTransformImage(magnitude_image,
7673               phase_image,*option == '-' ? MagickTrue : MagickFalse,exception);
7674             if (fourier_image == (Image *) NULL)
7675               break;
7676             if (*images != (Image *) NULL)
7677               *images=DestroyImage(*images);
7678             *images=fourier_image;
7679             break;
7680           }
7681         if (LocaleCompare("insert",option+1) == 0)
7682           {
7683             Image
7684               *p,
7685               *q;
7686
7687             index=0;
7688             if (*option != '+')
7689               index=(ssize_t) StringToLong(argv[i+1]);
7690             p=RemoveLastImageFromList(images);
7691             if (p == (Image *) NULL)
7692               {
7693                 (void) ThrowMagickException(exception,GetMagickModule(),
7694                   OptionError,"NoSuchImage","`%s'",argv[i+1]);
7695                 status=MagickFalse;
7696                 break;
7697               }
7698             q=p;
7699             if (index == 0)
7700               PrependImageToList(images,q);
7701             else
7702               if (index == (ssize_t) GetImageListLength(*images))
7703                 AppendImageToList(images,q);
7704               else
7705                 {
7706                    q=GetImageFromList(*images,index-1);
7707                    if (q == (Image *) NULL)
7708                      {
7709                        (void) ThrowMagickException(exception,GetMagickModule(),
7710                          OptionError,"NoSuchImage","`%s'",argv[i+1]);
7711                        status=MagickFalse;
7712                        break;
7713                      }
7714                   InsertImageInList(&q,p);
7715                 }
7716             *images=GetFirstImageInList(q);
7717             break;
7718           }
7719         if (LocaleCompare("interpolate",option+1) == 0)
7720           {
7721             interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
7722               MagickInterpolateOptions,MagickFalse,argv[i+1]);
7723             break;
7724           }
7725         break;
7726       }
7727       case 'l':
7728       {
7729         if (LocaleCompare("layers",option+1) == 0)
7730           {
7731             Image
7732               *layers;
7733
7734             ImageLayerMethod
7735               method;
7736
7737             (void) SyncImagesSettings(mogrify_info,*images);
7738             layers=(Image *) NULL;
7739             method=(ImageLayerMethod) ParseCommandOption(MagickLayerOptions,
7740               MagickFalse,argv[i+1]);
7741             switch (method)
7742             {
7743               case CoalesceLayer:
7744               {
7745                 layers=CoalesceImages(*images,exception);
7746                 break;
7747               }
7748               case CompareAnyLayer:
7749               case CompareClearLayer:
7750               case CompareOverlayLayer:
7751               default:
7752               {
7753                 layers=CompareImagesLayers(*images,method,exception);
7754                 break;
7755               }
7756               case MergeLayer:
7757               case FlattenLayer:
7758               case MosaicLayer:
7759               case TrimBoundsLayer:
7760               {
7761                 layers=MergeImageLayers(*images,method,exception);
7762                 break;
7763               }
7764               case DisposeLayer:
7765               {
7766                 layers=DisposeImages(*images,exception);
7767                 break;
7768               }
7769               case OptimizeImageLayer:
7770               {
7771                 layers=OptimizeImageLayers(*images,exception);
7772                 break;
7773               }
7774               case OptimizePlusLayer:
7775               {
7776                 layers=OptimizePlusImageLayers(*images,exception);
7777                 break;
7778               }
7779               case OptimizeTransLayer:
7780               {
7781                 OptimizeImageTransparency(*images,exception);
7782                 break;
7783               }
7784               case RemoveDupsLayer:
7785               {
7786                 RemoveDuplicateLayers(images,exception);
7787                 break;
7788               }
7789               case RemoveZeroLayer:
7790               {
7791                 RemoveZeroDelayLayers(images,exception);
7792                 break;
7793               }
7794               case OptimizeLayer:
7795               {
7796                 /*
7797                   General Purpose, GIF Animation Optimizer.
7798                 */
7799                 layers=CoalesceImages(*images,exception);
7800                 if (layers == (Image *) NULL)
7801                   {
7802                     status=MagickFalse;
7803                     break;
7804                   }
7805                 *images=DestroyImageList(*images);
7806                 *images=layers;
7807                 layers=OptimizeImageLayers(*images,exception);
7808                 if (layers == (Image *) NULL)
7809                   {
7810                     status=MagickFalse;
7811                     break;
7812                   }
7813                 *images=DestroyImageList(*images);
7814                 *images=layers;
7815                 layers=(Image *) NULL;
7816                 OptimizeImageTransparency(*images,exception);
7817                 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7818                   exception);
7819                 break;
7820               }
7821               case CompositeLayer:
7822               {
7823                 CompositeOperator
7824                   compose;
7825
7826                 Image
7827                   *source;
7828
7829                 RectangleInfo
7830                   geometry;
7831
7832                 /*
7833                   Split image sequence at the first 'NULL:' image.
7834                 */
7835                 source=(*images);
7836                 while (source != (Image *) NULL)
7837                 {
7838                   source=GetNextImageInList(source);
7839                   if ((source != (Image *) NULL) &&
7840                       (LocaleCompare(source->magick,"NULL") == 0))
7841                     break;
7842                 }
7843                 if (source != (Image *) NULL)
7844                   {
7845                     if ((GetPreviousImageInList(source) == (Image *) NULL) ||
7846                         (GetNextImageInList(source) == (Image *) NULL))
7847                       source=(Image *) NULL;
7848                     else
7849                       {
7850                         /*
7851                           Separate the two lists, junk the null: image.
7852                         */
7853                         source=SplitImageList(source->previous);
7854                         DeleteImageFromList(&source);
7855                       }
7856                   }
7857                 if (source == (Image *) NULL)
7858                   {
7859                     (void) ThrowMagickException(exception,GetMagickModule(),
7860                       OptionError,"MissingNullSeparator","layers Composite");
7861                     status=MagickFalse;
7862                     break;
7863                   }
7864                 /*
7865                   Adjust offset with gravity and virtual canvas.
7866                 */
7867                 SetGeometry(*images,&geometry);
7868                 (void) ParseAbsoluteGeometry((*images)->geometry,&geometry);
7869                 geometry.width=source->page.width != 0 ?
7870                   source->page.width : source->columns;
7871                 geometry.height=source->page.height != 0 ?
7872                  source->page.height : source->rows;
7873                 GravityAdjustGeometry((*images)->page.width != 0 ?
7874                   (*images)->page.width : (*images)->columns,
7875                   (*images)->page.height != 0 ? (*images)->page.height :
7876                   (*images)->rows,(*images)->gravity,&geometry);
7877                 compose=OverCompositeOp;
7878                 option=GetImageOption(mogrify_info,"compose");
7879                 if (option != (const char *) NULL)
7880                   compose=(CompositeOperator) ParseCommandOption(
7881                     MagickComposeOptions,MagickFalse,option);
7882                 CompositeLayers(*images,compose,source,geometry.x,geometry.y,
7883                   exception);
7884                 source=DestroyImageList(source);
7885                 break;
7886               }
7887             }
7888             if (layers == (Image *) NULL)
7889               break;
7890             InheritException(exception,&layers->exception);
7891             *images=DestroyImageList(*images);
7892             *images=layers;
7893             break;
7894           }
7895         break;
7896       }
7897       case 'm':
7898       {
7899         if (LocaleCompare("map",option+1) == 0)
7900           {
7901             (void) SyncImagesSettings(mogrify_info,*images);
7902             if (*option == '+')
7903               {
7904                 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7905                   exception);
7906                 break;
7907               }
7908             i++;
7909             break;
7910           }
7911         if (LocaleCompare("maximum",option+1) == 0)
7912           {
7913             Image
7914               *maximum_image;
7915
7916             /*
7917               Maximum image sequence (deprecated).
7918             */
7919             (void) SyncImagesSettings(mogrify_info,*images);
7920             maximum_image=EvaluateImages(*images,MaxEvaluateOperator,exception);
7921             if (maximum_image == (Image *) NULL)
7922               {
7923                 status=MagickFalse;
7924                 break;
7925               }
7926             *images=DestroyImageList(*images);
7927             *images=maximum_image;
7928             break;
7929           }
7930         if (LocaleCompare("minimum",option+1) == 0)
7931           {
7932             Image
7933               *minimum_image;
7934
7935             /*
7936               Minimum image sequence (deprecated).
7937             */
7938             (void) SyncImagesSettings(mogrify_info,*images);
7939             minimum_image=EvaluateImages(*images,MinEvaluateOperator,exception);
7940             if (minimum_image == (Image *) NULL)
7941               {
7942                 status=MagickFalse;
7943                 break;
7944               }
7945             *images=DestroyImageList(*images);
7946             *images=minimum_image;
7947             break;
7948           }
7949         if (LocaleCompare("morph",option+1) == 0)
7950           {
7951             Image
7952               *morph_image;
7953
7954             (void) SyncImagesSettings(mogrify_info,*images);
7955             morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]),
7956               exception);
7957             if (morph_image == (Image *) NULL)
7958               {
7959                 status=MagickFalse;
7960                 break;
7961               }
7962             *images=DestroyImageList(*images);
7963             *images=morph_image;
7964             break;
7965           }
7966         if (LocaleCompare("mosaic",option+1) == 0)
7967           {
7968             Image
7969               *mosaic_image;
7970
7971             (void) SyncImagesSettings(mogrify_info,*images);
7972             mosaic_image=MergeImageLayers(*images,MosaicLayer,exception);
7973             if (mosaic_image == (Image *) NULL)
7974               {
7975                 status=MagickFalse;
7976                 break;
7977               }
7978             *images=DestroyImageList(*images);
7979             *images=mosaic_image;
7980             break;
7981           }
7982         break;
7983       }
7984       case 'p':
7985       {
7986         if (LocaleCompare("print",option+1) == 0)
7987           {
7988             char
7989               *string;
7990
7991             (void) SyncImagesSettings(mogrify_info,*images);
7992             string=InterpretImageProperties(mogrify_info,*images,argv[i+1],
7993               exception);
7994             if (string == (char *) NULL)
7995               break;
7996             (void) FormatLocaleFile(stdout,"%s",string);
7997             string=DestroyString(string);
7998           }
7999         if (LocaleCompare("process",option+1) == 0)
8000           {
8001             char
8002               **arguments;
8003
8004             int
8005               j,
8006               number_arguments;
8007
8008             (void) SyncImagesSettings(mogrify_info,*images);
8009             arguments=StringToArgv(argv[i+1],&number_arguments);
8010             if (arguments == (char **) NULL)
8011               break;
8012             if ((argc > 1) && (strchr(arguments[1],'=') != (char *) NULL))
8013               {
8014                 char
8015                   breaker,
8016                   quote,
8017                   *token;
8018
8019                 const char
8020                   *arguments;
8021
8022                 int
8023                   next,
8024                   status;
8025
8026                 size_t
8027                   length;
8028
8029                 TokenInfo
8030                   *token_info;
8031
8032                 /*
8033                   Support old style syntax, filter="-option arg".
8034                 */
8035                 length=strlen(argv[i+1]);
8036                 token=(char *) NULL;
8037                 if (~length >= (MaxTextExtent-1))
8038                   token=(char *) AcquireQuantumMemory(length+MaxTextExtent,
8039                     sizeof(*token));
8040                 if (token == (char *) NULL)
8041                   break;
8042                 next=0;
8043                 arguments=argv[i+1];
8044                 token_info=AcquireTokenInfo();
8045                 status=Tokenizer(token_info,0,token,length,arguments,"","=",
8046                   "\"",'\0',&breaker,&next,&quote);
8047                 token_info=DestroyTokenInfo(token_info);
8048                 if (status == 0)
8049                   {
8050                     const char
8051                       *argv;
8052
8053                     argv=(&(arguments[next]));
8054                     (void) InvokeDynamicImageFilter(token,&(*images),1,&argv,
8055                       exception);
8056                   }
8057                 token=DestroyString(token);
8058                 break;
8059               }
8060             (void) SubstituteString(&arguments[1],"-","");
8061             (void) InvokeDynamicImageFilter(arguments[1],&(*images),
8062               number_arguments-2,(const char **) arguments+2,exception);
8063             for (j=0; j < number_arguments; j++)
8064               arguments[j]=DestroyString(arguments[j]);
8065             arguments=(char **) RelinquishMagickMemory(arguments);
8066             break;
8067           }
8068         break;
8069       }
8070       case 'r':
8071       {
8072         if (LocaleCompare("reverse",option+1) == 0)
8073           {
8074             ReverseImageList(images);
8075             InheritException(exception,&(*images)->exception);
8076             break;
8077           }
8078         break;
8079       }
8080       case 's':
8081       {
8082         if (LocaleCompare("smush",option+1) == 0)
8083           {
8084             Image
8085               *smush_image;
8086
8087             ssize_t
8088               offset;
8089
8090             (void) SyncImagesSettings(mogrify_info,*images);
8091             offset=(ssize_t) StringToLong(argv[i+1]);
8092             smush_image=SmushImages(*images,*option == '-' ? MagickTrue :
8093               MagickFalse,offset,exception);
8094             if (smush_image == (Image *) NULL)
8095               {
8096                 status=MagickFalse;
8097                 break;
8098               }
8099             *images=DestroyImageList(*images);
8100             *images=smush_image;
8101             break;
8102           }
8103         if (LocaleCompare("swap",option+1) == 0)
8104           {
8105             Image
8106               *p,
8107               *q,
8108               *swap;
8109
8110             ssize_t
8111               swap_index;
8112
8113             index=(-1);
8114             swap_index=(-2);
8115             if (*option != '+')
8116               {
8117                 GeometryInfo
8118                   geometry_info;
8119
8120                 MagickStatusType
8121                   flags;
8122
8123                 swap_index=(-1);
8124                 flags=ParseGeometry(argv[i+1],&geometry_info);
8125                 index=(ssize_t) geometry_info.rho;
8126                 if ((flags & SigmaValue) != 0)
8127                   swap_index=(ssize_t) geometry_info.sigma;
8128               }
8129             p=GetImageFromList(*images,index);
8130             q=GetImageFromList(*images,swap_index);
8131             if ((p == (Image *) NULL) || (q == (Image *) NULL))
8132               {
8133                 (void) ThrowMagickException(exception,GetMagickModule(),
8134                   OptionError,"NoSuchImage","`%s'",(*images)->filename);
8135                 status=MagickFalse;
8136                 break;
8137               }
8138             if (p == q)
8139               break;
8140             swap=CloneImage(p,0,0,MagickTrue,exception);
8141             ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,exception));
8142             ReplaceImageInList(&q,swap);
8143             *images=GetFirstImageInList(q);
8144             break;
8145           }
8146         break;
8147       }
8148       case 'w':
8149       {
8150         if (LocaleCompare("write",option+1) == 0)
8151           {
8152             char
8153               key[MaxTextExtent];
8154
8155             Image
8156               *write_images;
8157
8158             ImageInfo
8159               *write_info;
8160
8161             (void) SyncImagesSettings(mogrify_info,*images);
8162             (void) FormatLocaleString(key,MaxTextExtent,"cache:%s",argv[i+1]);
8163             (void) DeleteImageRegistry(key);
8164             write_images=(*images);
8165             if (*option == '+')
8166               write_images=CloneImageList(*images,exception);
8167             write_info=CloneImageInfo(mogrify_info);
8168             status&=WriteImages(write_info,write_images,argv[i+1],exception);
8169             write_info=DestroyImageInfo(write_info);
8170             if (*option == '+')
8171               write_images=DestroyImageList(write_images);
8172             break;
8173           }
8174         break;
8175       }
8176       default:
8177         break;
8178     }
8179     i+=count;
8180   }
8181   quantize_info=DestroyQuantizeInfo(quantize_info);
8182   mogrify_info=DestroyImageInfo(mogrify_info);
8183   status&=MogrifyImageInfo(image_info,argc,argv,exception);
8184   return(status != 0 ? MagickTrue : MagickFalse);
8185 }
8186 \f
8187 /*
8188 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8189 %                                                                             %
8190 %                                                                             %
8191 %                                                                             %
8192 +     M o g r i f y I m a g e s                                               %
8193 %                                                                             %
8194 %                                                                             %
8195 %                                                                             %
8196 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8197 %
8198 %  MogrifyImages() applies image processing options to a sequence of images as
8199 %  prescribed by command line options.
8200 %
8201 %  The format of the MogrifyImage method is:
8202 %
8203 %      MagickBooleanType MogrifyImages(ImageInfo *image_info,
8204 %        const MagickBooleanType post,const int argc,const char **argv,
8205 %        Image **images,Exceptioninfo *exception)
8206 %
8207 %  A description of each parameter follows:
8208 %
8209 %    o image_info: the image info..
8210 %
8211 %    o post: If true, post process image list operators otherwise pre-process.
8212 %
8213 %    o argc: Specifies a pointer to an integer describing the number of
8214 %      elements in the argument vector.
8215 %
8216 %    o argv: Specifies a pointer to a text array containing the command line
8217 %      arguments.
8218 %
8219 %    o images: pointer to a pointer of the first image in image list.
8220 %
8221 %    o exception: return any errors or warnings in this structure.
8222 %
8223 */
8224 WandExport MagickBooleanType MogrifyImages(ImageInfo *image_info,
8225   const MagickBooleanType post,const int argc,const char **argv,
8226   Image **images,ExceptionInfo *exception)
8227 {
8228 #define MogrifyImageTag  "Mogrify/Image"
8229
8230   MagickStatusType
8231     status;
8232
8233   MagickBooleanType
8234     proceed;
8235
8236   size_t
8237     n;
8238
8239   register ssize_t
8240     i;
8241
8242   assert(image_info != (ImageInfo *) NULL);
8243   assert(image_info->signature == MagickSignature);
8244   if (images == (Image **) NULL)
8245     return(MogrifyImage(image_info,argc,argv,images,exception));
8246   assert((*images)->previous == (Image *) NULL);
8247   assert((*images)->signature == MagickSignature);
8248   if ((*images)->debug != MagickFalse)
8249     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
8250       (*images)->filename);
8251   if ((argc <= 0) || (*argv == (char *) NULL))
8252     return(MagickTrue);
8253   (void) SetImageInfoProgressMonitor(image_info,(MagickProgressMonitor) NULL,
8254     (void *) NULL);
8255   status=0;
8256
8257 #if 0
8258   (void) FormatLocaleFile(stderr, "mogrify start %s %d (%s)\n",argv[0],argc,
8259     post?"post":"pre");
8260 #endif
8261
8262   /*
8263     Pre-process multi-image sequence operators
8264   */
8265   if (post == MagickFalse)
8266     status&=MogrifyImageList(image_info,argc,argv,images,exception);
8267   /*
8268     For each image, process simple single image operators
8269   */
8270   i=0;
8271   n=GetImageListLength(*images);
8272   for ( ; ; )
8273   {
8274 #if 0
8275   (void) FormatLocaleFile(stderr,"mogrify %ld of %ld\n",(long)
8276     GetImageIndexInList(*images),(long)GetImageListLength(*images));
8277 #endif
8278     status&=MogrifyImage(image_info,argc,argv,images,exception);
8279     proceed=SetImageProgress(*images,MogrifyImageTag,(MagickOffsetType) i, n);
8280     if (proceed == MagickFalse)
8281       break;
8282     if ( (*images)->next == (Image *) NULL )
8283       break;
8284     *images=(*images)->next;
8285     i++;
8286   }
8287   assert( *images != (Image *) NULL );
8288 #if 0
8289   (void) FormatLocaleFile(stderr,"mogrify end %ld of %ld\n",(long)
8290     GetImageIndexInList(*images),(long)GetImageListLength(*images));
8291 #endif
8292
8293   /*
8294     Post-process, multi-image sequence operators
8295   */
8296   *images=GetFirstImageInList(*images);
8297   if (post != MagickFalse)
8298     status&=MogrifyImageList(image_info,argc,argv,images,exception);
8299   return(status != 0 ? MagickTrue : MagickFalse);
8300 }