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