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