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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                CCCC   OOO   N   N  V   V  EEEEE  RRRR   TTTTT               %
   7 %               C      O   O  NN  N  V   V  E      R   R    T                 %
   8 %               C      O   O  N N N  V   V  EEE    RRRR     T                 %
   9 %               C      O   O  N  NN   V V   E      R R      T                 %
  10 %                CCCC   OOO   N   N    V    EEEEE  R  R     T                 %
  11 %                                                                             %
  12 %                                                                             %
  13 %                Convert an image from one format to another.                 %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                April 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %  Use the convert program to convert between image formats as well as resize
  37 %  an image, blur, crop, despeckle, dither, draw on, flip, join, re-sample,
  38 %  and much more.
  39 %
  40 */
  41 \f
  42 /*
  43   Include declarations.
  44 */
  45 #include "MagickWand/studio.h"
  46 #include "MagickWand/MagickWand.h"
  47 #include "MagickWand/mogrify-private.h"
  48 #include "MagickCore/string-private.h"
  49 #include "MagickCore/utility-private.h"
  50 /*
  51   Define declarations.
  52 */
  53 #define ThrowFileException(exception,severity,tag,context) \
  54 { \
  55   char \
  56     *message; \
  57  \
  58   message=GetExceptionMessage(errno); \
  59   (void) ThrowMagickException(exception,GetMagickModule(),severity, \
  60     tag == (const char *) NULL ? "unknown" : tag,"`%s': %s",context,message); \
  61   message=DestroyString(message); \
  62 }
  63 \f
  64 /*
  65 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  66 %                                                                             %
  67 %                                                                             %
  68 %                                                                             %
  69 +   C o n v e r t I m a g e C o m m a n d                                     %
  70 %                                                                             %
  71 %                                                                             %
  72 %                                                                             %
  73 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  74 %
  75 %  ConvertImageCommand() reads one or more images, applies one or more image
  76 %  processing operations, and writes out the image in the same or differing
  77 %  format.
  78 %
  79 %  The format of the ConvertImageCommand method is:
  80 %
  81 %      MagickBooleanType ConvertImageCommand(ImageInfo *image_info,int argc,
  82 %        char **argv,char **metadata,ExceptionInfo *exception)
  83 %
  84 %  A description of each parameter follows:
  85 %
  86 %    o image_info: the image info.
  87 %
  88 %    o argc: the number of elements in the argument vector.
  89 %
  90 %    o argv: A text array containing the command line arguments.
  91 %
  92 %    o metadata: any metadata is returned here.
  93 %
  94 %    o exception: return any errors or warnings in this structure.
  95 %
  96 */
  97
  98 static MagickBooleanType ConcatenateImages(int argc,char **argv,
  99   ExceptionInfo *exception)
 100 {
 101   FILE
 102     *input,
 103     *output;
 104
 105   int
 106     c;
 107
 108   register ssize_t
 109     i;
 110
 111   /*
 112     Open output file.
 113   */
 114   output=fopen_utf8(argv[argc-1],"wb");
 115   if (output == (FILE *) NULL)
 116     {
 117       ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
 118         argv[argc-1]);
 119       return(MagickFalse);
 120     }
 121   for (i=2; i < (ssize_t) (argc-1); i++)
 122   {
 123     input=fopen_utf8(argv[i],"rb");
 124     if (input == (FILE *) NULL)
 125       ThrowFileException(exception,FileOpenError,"UnableToOpenFile",argv[i]);
 126     for (c=fgetc(input); c != EOF; c=fgetc(input))
 127       (void) fputc((char) c,output);
 128     (void) fclose(input);
 129     (void) remove_utf8(argv[i]);
 130   }
 131   (void) fclose(output);
 132   return(MagickTrue);
 133 }
 134
 135 static MagickBooleanType ConvertUsage(void)
 136 {
 137   static const char
 138     *miscellaneous[]=
 139     {
 140       "-debug events        display copious debugging information",
 141       "-help                print program options",
 142       "-list type           print a list of supported option arguments",
 143       "-log format          format of debugging information",
 144       "-version             print version information",
 145       (char *) NULL
 146     },
 147     *operators[]=
 148     {
 149       "-adaptive-blur geometry",
 150       "                     adaptively blur pixels; decrease effect near edges",
 151       "-adaptive-resize geometry",
 152       "                     adaptively resize image using 'mesh' interpolation",
 153       "-adaptive-sharpen geometry",
 154       "                     adaptively sharpen pixels; increase effect near edges",
 155       "-alpha option        on, activate, off, deactivate, set, opaque, copy",
 156       "                     transparent, extract, background, or shape",
 157       "-annotate geometry text",
 158       "                     annotate the image with text",
 159       "-auto-gamma          automagically adjust gamma level of image",
 160       "-auto-level          automagically adjust color levels of image",
 161       "-auto-orient         automagically orient (rotate) image",
 162       "-bench iterations    measure performance",
 163       "-black-threshold value",
 164       "                     force all pixels below the threshold into black",
 165       "-blue-shift factor   simulate a scene at nighttime in the moonlight",
 166       "-blur geometry       reduce image noise and reduce detail levels",
 167       "-border geometry     surround image with a border of color",
 168       "-bordercolor color   border color",
 169       "-brightness-contrast geometry",
 170       "                     improve brightness / contrast of the image",
 171       "-cdl filename        color correct with a color decision list",
 172       "-charcoal radius     simulate a charcoal drawing",
 173       "-chop geometry       remove pixels from the image interior",
 174       "-clamp               restrict pixel range from 0 to the quantum depth",
 175       "-clip                clip along the first path from the 8BIM profile",
 176       "-clip-mask filename  associate a clip mask with the image",
 177       "-clip-path id        clip along a named path from the 8BIM profile",
 178       "-colorize value      colorize the image with the fill color",
 179       "-color-matrix matrix apply color correction to the image",
 180       "-contrast            enhance or reduce the image contrast",
 181       "-contrast-stretch geometry",
 182       "                     improve contrast by `stretching' the intensity range",
 183       "-convolve coefficients",
 184       "                     apply a convolution kernel to the image",
 185       "-cycle amount        cycle the image colormap",
 186       "-decipher filename   convert cipher pixels to plain pixels",
 187       "-deskew threshold    straighten an image",
 188       "-despeckle           reduce the speckles within an image",
 189       "-distort method args",
 190       "                     distort images according to given method ad args",
 191       "-draw string         annotate the image with a graphic primitive",
 192       "-edge radius         apply a filter to detect edges in the image",
 193       "-encipher filename   convert plain pixels to cipher pixels",
 194       "-emboss radius       emboss an image",
 195       "-enhance             apply a digital filter to enhance a noisy image",
 196       "-equalize            perform histogram equalization to an image",
 197       "-evaluate operator value",
 198       "                     evaluate an arithmetic, relational, or logical expression",
 199       "-extent geometry     set the image size",
 200       "-extract geometry    extract area from image",
 201       "-fft                 implements the discrete Fourier transform (DFT)",
 202       "-flip                flip image vertically",
 203       "-floodfill geometry color",
 204       "                     floodfill the image with color",
 205       "-flop                flop image horizontally",
 206       "-frame geometry      surround image with an ornamental border",
 207       "-function name parameters",
 208       "                     apply function over image values",
 209       "-gamma value         level of gamma correction",
 210       "-gaussian-blur geometry",
 211       "                     reduce image noise and reduce detail levels",
 212       "-geometry geometry   preferred size or location of the image",
 213       "-identify            identify the format and characteristics of the image",
 214       "-ift                 implements the inverse discrete Fourier transform (DFT)",
 215       "-implode amount      implode image pixels about the center",
 216       "-lat geometry        local adaptive thresholding",
 217       "-layers method       optimize, merge,  or compare image layers",
 218       "-level value         adjust the level of image contrast",
 219       "-level-colors color,color",
 220       "                     level image with the given colors",
 221       "-linear-stretch geometry",
 222       "                     improve contrast by `stretching with saturation'",
 223       "-liquid-rescale geometry",
 224       "                     rescale image with seam-carving",
 225       "-median geometry     apply a median filter to the image",
 226       "-mode geometry       make each pixel the 'predominant color' of the neighborhood",
 227       "-modulate value      vary the brightness, saturation, and hue",
 228       "-monochrome          transform image to black and white",
 229       "-morphology method kernel",
 230       "                     apply a morphology method to the image",
 231       "-motion-blur geometry",
 232       "                     simulate motion blur",
 233       "-negate              replace every pixel with its complementary color ",
 234       "-noise geometry      add or reduce noise in an image",
 235       "-normalize           transform image to span the full range of colors",
 236       "-opaque color        change this color to the fill color",
 237       "-ordered-dither NxN",
 238       "                     add a noise pattern to the image with specific",
 239       "                     amplitudes",
 240       "-paint radius        simulate an oil painting",
 241       "-polaroid angle      simulate a Polaroid picture",
 242       "-posterize levels    reduce the image to a limited number of color levels",
 243       "-profile filename    add, delete, or apply an image profile",
 244       "-quantize colorspace reduce colors in this colorspace",
 245       "-radial-blur angle   radial blur the image",
 246       "-raise value         lighten/darken image edges to create a 3-D effect",
 247       "-random-threshold low,high",
 248       "                     random threshold the image",
 249       "-region geometry     apply options to a portion of the image",
 250       "-render              render vector graphics",
 251       "-repage geometry     size and location of an image canvas",
 252       "-resample geometry   change the resolution of an image",
 253       "-resize geometry     resize the image",
 254       "-roll geometry       roll an image vertically or horizontally",
 255       "-rotate degrees      apply Paeth rotation to the image",
 256       "-sample geometry     scale image with pixel sampling",
 257       "-scale geometry      scale the image",
 258       "-segment values      segment an image",
 259       "-selective-blur geometry",
 260       "                     selectively blur pixels within a contrast threshold",
 261       "-sepia-tone threshold",
 262       "                     simulate a sepia-toned photo",
 263       "-set property value  set an image property",
 264       "-shade degrees       shade the image using a distant light source",
 265       "-shadow geometry     simulate an image shadow",
 266       "-sharpen geometry    sharpen the image",
 267       "-shave geometry      shave pixels from the image edges",
 268       "-shear geometry      slide one edge of the image along the X or Y axis",
 269       "-sigmoidal-contrast geometry",
 270       "                     increase the contrast without saturating highlights or shadows",
 271       "-sketch geometry     simulate a pencil sketch",
 272       "-solarize threshold  negate all pixels above the threshold level",
 273       "-sparse-color method args",
 274       "                     fill in a image based on a few color points",
 275       "-splice geometry     splice the background color into the image",
 276       "-spread radius       displace image pixels by a random amount",
 277       "-statistic type geometry",
 278       "                     replace each pixel with corresponding statistic from the neighborhood",
 279       "-strip               strip image of all profiles and comments",
 280       "-swirl degrees       swirl image pixels about the center",
 281       "-threshold value     threshold the image",
 282       "-thumbnail geometry  create a thumbnail of the image",
 283       "-tile filename       tile image when filling a graphic primitive",
 284       "-tint value          tint the image with the fill color",
 285       "-transform           affine transform image",
 286       "-transparent color   make this color transparent within the image",
 287       "-transpose           flip image vertically and rotate 90 degrees",
 288       "-transverse          flop image horizontally and rotate 270 degrees",
 289       "-trim                trim image edges",
 290       "-type type           image type",
 291       "-unique-colors       discard all but one of any pixel color",
 292       "-unsharp geometry    sharpen the image",
 293       "-vignette geometry   soften the edges of the image in vignette style",
 294       "-wave geometry       alter an image along a sine wave",
 295       "-white-threshold value",
 296       "                     force all pixels above the threshold into white",
 297       (char *) NULL
 298     },
 299     *sequence_operators[]=
 300     {
 301       "-append              append an image sequence",
 302       "-clut                apply a color lookup table to the image",
 303       "-coalesce            merge a sequence of images",
 304       "-combine             combine a sequence of images",
 305       "-composite           composite image",
 306       "-crop geometry       cut out a rectangular region of the image",
 307       "-deconstruct         break down an image sequence into constituent parts",
 308       "-evaluate-sequence operator",
 309       "                     evaluate an arithmetic, relational, or logical expression",
 310       "-flatten             flatten a sequence of images",
 311       "-fx expression       apply mathematical expression to an image channel(s)",
 312       "-hald-clut           apply a Hald color lookup table to the image",
 313       "-morph value         morph an image sequence",
 314       "-mosaic              create a mosaic from an image sequence",
 315       "-print string        interpret string and print to console",
 316       "-process arguments   process the image with a custom image filter",
 317       "-separate            separate an image channel into a grayscale image",
 318       "-smush geometry      smush an image sequence together",
 319       "-write filename      write images to this file",
 320       (char *) NULL
 321     },
 322     *settings[]=
 323     {
 324       "-adjoin              join images into a single multi-image file",
 325       "-affine matrix       affine transform matrix",
 326       "-alpha option        activate, deactivate, reset, or set the alpha channel",
 327       "-antialias           remove pixel-aliasing",
 328       "-authenticate password",
 329       "                     decipher image with this password",
 330       "-attenuate value     lessen (or intensify) when adding noise to an image",
 331       "-background color    background color",
 332       "-bias value          add bias when convolving an image",
 333       "-black-point-compensation",
 334       "                     use black point compensation",
 335       "-blue-primary point  chromaticity blue primary point",
 336       "-bordercolor color   border color",
 337       "-caption string      assign a caption to an image",
 338       "-channel type        apply option to select image channels",
 339       "-colors value        preferred number of colors in the image",
 340       "-colorspace type     alternate image colorspace",
 341       "-comment string      annotate image with comment",
 342       "-compose operator    set image composite operator",
 343       "-compress type       type of pixel compression when writing the image",
 344       "-define format:option",
 345       "                     define one or more image format options",
 346       "-delay value         display the next image after pausing",
 347       "-density geometry    horizontal and vertical density of the image",
 348       "-depth value         image depth",
 349       "-direction type      render text right-to-left or left-to-right",
 350       "-display server      get image or font from this X server",
 351       "-dispose method      layer disposal method",
 352       "-dither method       apply error diffusion to image",
 353       "-encoding type       text encoding type",
 354       "-endian type         endianness (MSB or LSB) of the image",
 355       "-family name         render text with this font family",
 356       "-fill color          color to use when filling a graphic primitive",
 357       "-filter type         use this filter when resizing an image",
 358       "-font name           render text with this font",
 359       "-format \"string\"     output formatted image characteristics",
 360       "-fuzz distance       colors within this distance are considered equal",
 361       "-gravity type        horizontal and vertical text placement",
 362       "-green-primary point chromaticity green primary point",
 363       "-intent type         type of rendering intent when managing the image color",
 364       "-interlace type      type of image interlacing scheme",
 365       "-interline-spacing value",
 366       "                     set the space between two text lines",
 367       "-interpolate method  pixel color interpolation method",
 368       "-interword-spacing value",
 369       "                     set the space between two words",
 370       "-kerning value       set the space between two letters",
 371       "-label string        assign a label to an image",
 372       "-limit type value    pixel cache resource limit",
 373       "-loop iterations     add Netscape loop extension to your GIF animation",
 374       "-mask filename       associate a mask with the image",
 375       "-mattecolor color    frame color",
 376       "-monitor             monitor progress",
 377       "-orient type         image orientation",
 378       "-page geometry       size and location of an image canvas (setting)",
 379       "-ping                efficiently determine image attributes",
 380       "-pointsize value     font point size",
 381       "-precision value     maximum number of significant digits to print",
 382       "-preview type        image preview type",
 383       "-quality value       JPEG/MIFF/PNG compression level",
 384       "-quiet               suppress all warning messages",
 385       "-red-primary point   chromaticity red primary point",
 386       "-regard-warnings     pay attention to warning messages",
 387       "-remap filename      transform image colors to match this set of colors",
 388       "-respect-parentheses settings remain in effect until parenthesis boundary",
 389       "-sampling-factor geometry",
 390       "                     horizontal and vertical sampling factor",
 391       "-scene value         image scene number",
 392       "-seed value          seed a new sequence of pseudo-random numbers",
 393       "-size geometry       width and height of image",
 394       "-stretch type        render text with this font stretch",
 395       "-stroke color        graphic primitive stroke color",
 396       "-strokewidth value   graphic primitive stroke width",
 397       "-style type          render text with this font style",
 398       "-synchronize         synchronize image to storage device",
 399       "-taint               declare the image as modified",
 400       "-texture filename    name of texture to tile onto the image background",
 401       "-tile-offset geometry",
 402       "                     tile offset",
 403       "-treedepth value     color tree depth",
 404       "-transparent-color color",
 405       "                     transparent color",
 406       "-undercolor color    annotation bounding box color",
 407       "-units type          the units of image resolution",
 408       "-verbose             print detailed information about the image",
 409       "-view                FlashPix viewing transforms",
 410       "-virtual-pixel method",
 411       "                     virtual pixel access method",
 412       "-weight type         render text with this font weight",
 413       "-white-point point   chromaticity white point",
 414       (char *) NULL
 415     },
 416     *stack_operators[]=
 417     {
 418       "-clone indexes       clone an image",
 419       "-delete indexes      delete the image from the image sequence",
 420       "-duplicate count,indexes",
 421       "                     duplicate an image one or more times",
 422       "-insert index        insert last image into the image sequence",
 423       "-reverse             reverse image sequence",
 424       "-swap indexes        swap two images in the image sequence",
 425       (char *) NULL
 426     };
 427
 428   const char
 429     **p;
 430
 431   (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL));
 432   (void) printf("Copyright: %s\n",GetMagickCopyright());
 433   (void) printf("Features: %s\n\n",GetMagickFeatures());
 434   (void) printf("Usage: %s [options ...] file [ [options ...] "
 435     "file ...] [options ...] file\n",GetClientName());
 436   (void) printf("\nImage Settings:\n");
 437   for (p=settings; *p != (char *) NULL; p++)
 438     (void) printf("  %s\n",*p);
 439   (void) printf("\nImage Operators:\n");
 440   for (p=operators; *p != (char *) NULL; p++)
 441     (void) printf("  %s\n",*p);
 442   (void) printf("\nImage Sequence Operators:\n");
 443   for (p=sequence_operators; *p != (char *) NULL; p++)
 444     (void) printf("  %s\n",*p);
 445   (void) printf("\nImage Stack Operators:\n");
 446   for (p=stack_operators; *p != (char *) NULL; p++)
 447     (void) printf("  %s\n",*p);
 448   (void) printf("\nMiscellaneous Options:\n");
 449   for (p=miscellaneous; *p != (char *) NULL; p++)
 450     (void) printf("  %s\n",*p);
 451   (void) printf(
 452     "\nBy default, the image format of `file' is determined by its magic\n");
 453   (void) printf(
 454     "number.  To specify a particular image format, precede the filename\n");
 455   (void) printf(
 456     "with an image format name and a colon (i.e. ps:image) or specify the\n");
 457   (void) printf(
 458     "image type as the filename suffix (i.e. image.ps).  Specify 'file' as\n");
 459   (void) printf("'-' for standard input or output.\n");
 460   return(MagickFalse);
 461 }
 462
 463 WandExport MagickBooleanType ConvertImageCommand(ImageInfo *image_info,
 464   int argc,char **argv,char **metadata,ExceptionInfo *exception)
 465 {
 466 #define NotInitialized  (unsigned int) (~0)
 467 #define DestroyConvert() \
 468 { \
 469   DestroyImageStack(); \
 470   for (i=0; i < (ssize_t) argc; i++) \
 471     argv[i]=DestroyString(argv[i]); \
 472   argv=(char **) RelinquishMagickMemory(argv); \
 473 }
 474 #define ThrowConvertException(asperity,tag,option) \
 475 { \
 476   (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
 477     option); \
 478   DestroyConvert(); \
 479   return(MagickFalse); \
 480 }
 481 #define ThrowConvertInvalidArgumentException(option,argument) \
 482 { \
 483   (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
 484     "InvalidArgument","`%s': %s",option,argument); \
 485   DestroyConvert(); \
 486   return(MagickFalse); \
 487 }
 488
 489   char
 490     *filename,
 491     *option;
 492
 493   const char
 494     *format;
 495
 496   Image
 497     *image;
 498
 499   ImageStack
 500     image_stack[MaxImageStackDepth+1];
 501
 502   MagickBooleanType
 503     fire,
 504     pend,
 505     respect_parenthesis;
 506
 507   MagickStatusType
 508     status;
 509
 510   register ssize_t
 511     i;
 512
 513   ssize_t
 514     j,
 515     k;
 516
 517   /*
 518     Set defaults.
 519   */
 520   assert(image_info != (ImageInfo *) NULL);
 521   assert(image_info->signature == MagickSignature);
 522   if (image_info->debug != MagickFalse)
 523     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 524   assert(exception != (ExceptionInfo *) NULL);
 525   if (argc == 2)
 526     {
 527       option=argv[1];
 528       if ((LocaleCompare("version",option+1) == 0) ||
 529           (LocaleCompare("-version",option+1) == 0))
 530         {
 531           (void) FormatLocaleFile(stdout,"Version: %s\n",
 532             GetMagickVersion((size_t *) NULL));
 533           (void) FormatLocaleFile(stdout,"Copyright: %s\n",
 534             GetMagickCopyright());
 535           (void) FormatLocaleFile(stdout,"Features: %s\n\n",
 536             GetMagickFeatures());
 537           return(MagickFalse);
 538         }
 539     }
 540   if (argc < 3)
 541     return(ConvertUsage());
 542   filename=(char *) NULL;
 543   format="%w,%h,%m";
 544   j=1;
 545   k=0;
 546   NewImageStack();
 547   option=(char *) NULL;
 548   pend=MagickFalse;
 549   respect_parenthesis=MagickFalse;
 550   status=MagickTrue;
 551   /*
 552     Parse command-line arguments.
 553   */
 554   ReadCommandlLine(argc,&argv);
 555   status=ExpandFilenames(&argc,&argv);
 556   if (status == MagickFalse)
 557     ThrowConvertException(ResourceLimitError,"MemoryAllocationFailed",
 558       GetExceptionMessage(errno));
 559   if ((argc > 2) && (LocaleCompare("-concatenate",argv[1]) == 0))
 560     return(ConcatenateImages(argc,argv,exception));
 561   for (i=1; i < (ssize_t) (argc-1); i++)
 562   {
 563     option=argv[i];
 564     if (LocaleCompare(option,"(") == 0)
 565       {
 566         FireImageStack(MagickTrue,MagickTrue,pend);
 567         if (k == MaxImageStackDepth)
 568           ThrowConvertException(OptionError,"ParenthesisNestedTooDeeply",
 569             option);
 570         PushImageStack();
 571         continue;
 572       }
 573     if (LocaleCompare(option,")") == 0)
 574       {
 575         FireImageStack(MagickTrue,MagickTrue,MagickTrue);
 576         if (k == 0)
 577           ThrowConvertException(OptionError,"UnableToParseExpression",option);
 578         PopImageStack();
 579         continue;
 580       }
 581     if (IsCommandOption(option) == MagickFalse)
 582       {
 583         Image
 584           *images;
 585
 586         /*
 587           Read input image.
 588         */
 589         FireImageStack(MagickTrue,MagickTrue,pend);
 590         filename=argv[i];
 591         if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
 592           filename=argv[++i];
 593         (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
 594         if (image_info->ping != MagickFalse)
 595           images=PingImages(image_info,exception);
 596         else
 597           images=ReadImages(image_info,exception);
 598         status&=(images != (Image *) NULL) &&
 599           (exception->severity < ErrorException);
 600         if (images == (Image *) NULL)
 601           continue;
 602         AppendImageStack(images);
 603         continue;
 604       }
 605     pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
 606     switch (*(option+1))
 607     {
 608       case 'a':
 609       {
 610         if (LocaleCompare("adaptive-blur",option+1) == 0)
 611           {
 612             i++;
 613             if (i == (ssize_t) (argc-1))
 614               ThrowConvertException(OptionError,"MissingArgument",option);
 615             if (IsGeometry(argv[i]) == MagickFalse)
 616               ThrowConvertInvalidArgumentException(option,argv[i]);
 617             break;
 618           }
 619         if (LocaleCompare("adaptive-resize",option+1) == 0)
 620           {
 621             i++;
 622             if (i == (ssize_t) (argc-1))
 623               ThrowConvertException(OptionError,"MissingArgument",option);
 624             if (IsGeometry(argv[i]) == MagickFalse)
 625               ThrowConvertInvalidArgumentException(option,argv[i]);
 626             break;
 627           }
 628         if (LocaleCompare("adaptive-sharpen",option+1) == 0)
 629           {
 630             i++;
 631             if (i == (ssize_t) (argc-1))
 632               ThrowConvertException(OptionError,"MissingArgument",option);
 633             if (IsGeometry(argv[i]) == MagickFalse)
 634               ThrowConvertInvalidArgumentException(option,argv[i]);
 635             break;
 636           }
 637         if (LocaleCompare("adjoin",option+1) == 0)
 638           break;
 639         if (LocaleCompare("affine",option+1) == 0)
 640           {
 641             if (*option == '+')
 642               break;
 643             i++;
 644             if (i == (ssize_t) (argc-1))
 645               ThrowConvertException(OptionError,"MissingArgument",option);
 646             break;
 647           }
 648         if (LocaleCompare("alpha",option+1) == 0)
 649           {
 650             ssize_t
 651               type;
 652
 653             if (*option == '+')
 654               break;
 655             i++;
 656             if (i == (ssize_t) argc)
 657               ThrowConvertException(OptionError,"MissingArgument",option);
 658             type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
 659             if (type < 0)
 660               ThrowConvertException(OptionError,"UnrecognizedAlphaChannelType",
 661                 argv[i]);
 662             break;
 663           }
 664         if (LocaleCompare("annotate",option+1) == 0)
 665           {
 666             if (*option == '+')
 667               break;
 668             i++;
 669             if (i == (ssize_t) (argc-1))
 670               ThrowConvertException(OptionError,"MissingArgument",option);
 671             if (IsGeometry(argv[i]) == MagickFalse)
 672               ThrowConvertInvalidArgumentException(option,argv[i]);
 673             i++;
 674             if (i == (ssize_t) (argc-1))
 675               ThrowConvertException(OptionError,"MissingArgument",option);
 676             break;
 677           }
 678         if (LocaleCompare("antialias",option+1) == 0)
 679           break;
 680         if (LocaleCompare("append",option+1) == 0)
 681           break;
 682         if (LocaleCompare("attenuate",option+1) == 0)
 683           {
 684             if (*option == '+')
 685               break;
 686             i++;
 687             if (i == (ssize_t) (argc-1))
 688               ThrowConvertException(OptionError,"MissingArgument",option);
 689             if (IsGeometry(argv[i]) == MagickFalse)
 690               ThrowConvertInvalidArgumentException(option,argv[i]);
 691             break;
 692           }
 693         if (LocaleCompare("authenticate",option+1) == 0)
 694           {
 695             if (*option == '+')
 696               break;
 697             i++;
 698             if (i == (ssize_t) (argc-1))
 699               ThrowConvertException(OptionError,"MissingArgument",option);
 700             break;
 701           }
 702         if (LocaleCompare("auto-gamma",option+1) == 0)
 703           break;
 704         if (LocaleCompare("auto-level",option+1) == 0)
 705           break;
 706         if (LocaleCompare("auto-orient",option+1) == 0)
 707           break;
 708         if (LocaleCompare("average",option+1) == 0)
 709           break;
 710         ThrowConvertException(OptionError,"UnrecognizedOption",option)
 711       }
 712       case 'b':
 713       {
 714         if (LocaleCompare("background",option+1) == 0)
 715           {
 716             if (*option == '+')
 717               break;
 718             i++;
 719             if (i == (ssize_t) (argc-1))
 720               ThrowConvertException(OptionError,"MissingArgument",option);
 721             break;
 722           }
 723         if (LocaleCompare("bench",option+1) == 0)
 724           {
 725             if (*option == '+')
 726               break;
 727             i++;
 728             if (i == (ssize_t) (argc-1))
 729               ThrowConvertException(OptionError,"MissingArgument",option);
 730             if (IsGeometry(argv[i]) == MagickFalse)
 731               ThrowConvertInvalidArgumentException(option,argv[i]);
 732             break;
 733           }
 734         if (LocaleCompare("bias",option+1) == 0)
 735           {
 736             if (*option == '+')
 737               break;
 738             i++;
 739             if (i == (ssize_t) (argc-1))
 740               ThrowConvertException(OptionError,"MissingArgument",option);
 741             if (IsGeometry(argv[i]) == MagickFalse)
 742               ThrowConvertInvalidArgumentException(option,argv[i]);
 743             break;
 744           }
 745         if (LocaleCompare("black-point-compensation",option+1) == 0)
 746           break;
 747         if (LocaleCompare("black-threshold",option+1) == 0)
 748           {
 749             if (*option == '+')
 750               break;
 751             i++;
 752             if (i == (ssize_t) (argc-1))
 753               ThrowConvertException(OptionError,"MissingArgument",option);
 754             if (IsGeometry(argv[i]) == MagickFalse)
 755               ThrowConvertInvalidArgumentException(option,argv[i]);
 756             break;
 757           }
 758         if (LocaleCompare("blue-primary",option+1) == 0)
 759           {
 760             if (*option == '+')
 761               break;
 762             i++;
 763             if (i == (ssize_t) (argc-1))
 764               ThrowConvertException(OptionError,"MissingArgument",option);
 765             if (IsGeometry(argv[i]) == MagickFalse)
 766               ThrowConvertInvalidArgumentException(option,argv[i]);
 767             break;
 768           }
 769         if (LocaleCompare("blue-shift",option+1) == 0)
 770           {
 771             if (*option == '+')
 772               break;
 773             i++;
 774             if (i == (ssize_t) (argc-1))
 775               ThrowConvertException(OptionError,"MissingArgument",option);
 776             if (IsGeometry(argv[i]) == MagickFalse)
 777               ThrowConvertInvalidArgumentException(option,argv[i]);
 778             break;
 779           }
 780         if (LocaleCompare("blur",option+1) == 0)
 781           {
 782             if (*option == '+')
 783               break;
 784             i++;
 785             if (i == (ssize_t) (argc-1))
 786               ThrowConvertException(OptionError,"MissingArgument",option);
 787             if (IsGeometry(argv[i]) == MagickFalse)
 788               ThrowConvertInvalidArgumentException(option,argv[i]);
 789             break;
 790           }
 791         if (LocaleCompare("border",option+1) == 0)
 792           {
 793             if (*option == '+')
 794               break;
 795             i++;
 796             if (i == (ssize_t) (argc-1))
 797               ThrowConvertException(OptionError,"MissingArgument",option);
 798             if (IsGeometry(argv[i]) == MagickFalse)
 799               ThrowConvertInvalidArgumentException(option,argv[i]);
 800             break;
 801           }
 802         if (LocaleCompare("bordercolor",option+1) == 0)
 803           {
 804             if (*option == '+')
 805               break;
 806             i++;
 807             if (i == (ssize_t) (argc-1))
 808               ThrowConvertException(OptionError,"MissingArgument",option);
 809             break;
 810           }
 811         if (LocaleCompare("box",option+1) == 0)
 812           {
 813             if (*option == '+')
 814               break;
 815             i++;
 816             if (i == (ssize_t) (argc-1))
 817               ThrowConvertException(OptionError,"MissingArgument",option);
 818             break;
 819           }
 820         if (LocaleCompare("brightness-contrast",option+1) == 0)
 821           {
 822             i++;
 823             if (i == (ssize_t) (argc-1))
 824               ThrowConvertException(OptionError,"MissingArgument",option);
 825             if (IsGeometry(argv[i]) == MagickFalse)
 826               ThrowConvertInvalidArgumentException(option,argv[i]);
 827             break;
 828           }
 829         ThrowConvertException(OptionError,"UnrecognizedOption",option)
 830       }
 831       case 'c':
 832       {
 833         if (LocaleCompare("cache",option+1) == 0)
 834           {
 835             if (*option == '+')
 836               break;
 837             i++;
 838             if (i == (ssize_t) (argc-1))
 839               ThrowConvertException(OptionError,"MissingArgument",option);
 840             if (IsGeometry(argv[i]) == MagickFalse)
 841               ThrowConvertInvalidArgumentException(option,argv[i]);
 842             break;
 843           }
 844         if (LocaleCompare("caption",option+1) == 0)
 845           {
 846             if (*option == '+')
 847               break;
 848             i++;
 849             if (i == (ssize_t) argc)
 850               ThrowConvertException(OptionError,"MissingArgument",option);
 851             break;
 852           }
 853         if (LocaleCompare("cdl",option+1) == 0)
 854           {
 855             if (*option == '+')
 856               break;
 857             i++;
 858             if (i == (ssize_t) (argc-1))
 859               ThrowConvertException(OptionError,"MissingArgument",option);
 860             break;
 861           }
 862         if (LocaleCompare("channel",option+1) == 0)
 863           {
 864             ssize_t
 865               channel;
 866
 867             if (*option == '+')
 868               break;
 869             i++;
 870             if (i == (ssize_t) (argc-1))
 871               ThrowConvertException(OptionError,"MissingArgument",option);
 872             channel=ParseChannelOption(argv[i]);
 873             if (channel < 0)
 874               ThrowConvertException(OptionError,"UnrecognizedChannelType",
 875                 argv[i]);
 876             break;
 877           }
 878         if (LocaleCompare("charcoal",option+1) == 0)
 879           {
 880             if (*option == '+')
 881               break;
 882             i++;
 883             if (i == (ssize_t) (argc-1))
 884               ThrowConvertException(OptionError,"MissingArgument",option);
 885             if (IsGeometry(argv[i]) == MagickFalse)
 886               ThrowConvertInvalidArgumentException(option,argv[i]);
 887             break;
 888           }
 889         if (LocaleCompare("chop",option+1) == 0)
 890           {
 891             if (*option == '+')
 892               break;
 893             i++;
 894             if (i == (ssize_t) (argc-1))
 895               ThrowConvertException(OptionError,"MissingArgument",option);
 896             if (IsGeometry(argv[i]) == MagickFalse)
 897               ThrowConvertInvalidArgumentException(option,argv[i]);
 898             break;
 899           }
 900         if (LocaleCompare("clamp",option+1) == 0)
 901           break;
 902         if (LocaleCompare("clip",option+1) == 0)
 903           break;
 904         if (LocaleCompare("clip-mask",option+1) == 0)
 905           {
 906             if (*option == '+')
 907               break;
 908             i++;
 909             if (i == (ssize_t) (argc-1))
 910               ThrowConvertException(OptionError,"MissingArgument",option);
 911             break;
 912           }
 913         if (LocaleCompare("clip-path",option+1) == 0)
 914           {
 915             i++;
 916             if (i == (ssize_t) (argc-1))
 917               ThrowConvertException(OptionError,"MissingArgument",option);
 918             break;
 919           }
 920         if (LocaleCompare("clone",option+1) == 0)
 921           {
 922             Image
 923               *clone_images;
 924
 925             clone_images=image;
 926             if (k != 0)
 927               clone_images=image_stack[k-1].image;
 928             if (clone_images == (Image *) NULL)
 929               ThrowConvertException(ImageError,"ImageSequenceRequired",option);
 930             FireImageStack(MagickTrue,MagickTrue,MagickTrue);
 931             if (*option == '+')
 932               clone_images=CloneImages(clone_images,"-1",exception);
 933             else
 934               {
 935                 i++;
 936                 if (i == (ssize_t) (argc-1))
 937                   ThrowConvertException(OptionError,"MissingArgument",option);
 938                 if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
 939                   ThrowConvertInvalidArgumentException(option,argv[i]);
 940                 clone_images=CloneImages(clone_images,argv[i],exception);
 941               }
 942             if (clone_images == (Image *) NULL)
 943               ThrowConvertException(OptionError,"NoSuchImage",option);
 944             AppendImageStack(clone_images);
 945             break;
 946           }
 947         if (LocaleCompare("clut",option+1) == 0)
 948           break;
 949         if (LocaleCompare("coalesce",option+1) == 0)
 950           break;
 951         if (LocaleCompare("colorize",option+1) == 0)
 952           {
 953             if (*option == '+')
 954               break;
 955             i++;
 956             if (i == (ssize_t) (argc-1))
 957               ThrowConvertException(OptionError,"MissingArgument",option);
 958             if (IsGeometry(argv[i]) == MagickFalse)
 959               ThrowConvertInvalidArgumentException(option,argv[i]);
 960             break;
 961           }
 962         if (LocaleCompare("color-matrix",option+1) == 0)
 963           {
 964             KernelInfo
 965               *kernel_info;
 966
 967             if (*option == '+')
 968               break;
 969             i++;
 970             if (i == (ssize_t) (argc-1))
 971               ThrowConvertException(OptionError,"MissingArgument",option);
 972             kernel_info=AcquireKernelInfo(argv[i]);
 973             if (kernel_info == (KernelInfo *) NULL)
 974               ThrowConvertInvalidArgumentException(option,argv[i]);
 975             kernel_info=DestroyKernelInfo(kernel_info);
 976             break;
 977           }
 978         if (LocaleCompare("colors",option+1) == 0)
 979           {
 980             if (*option == '+')
 981               break;
 982             i++;
 983             if ((i == (ssize_t) (argc-1)) ||
 984                 (IsGeometry(argv[i]) == MagickFalse))
 985               ThrowConvertException(OptionError,"MissingArgument",option);
 986             break;
 987           }
 988         if (LocaleCompare("colorspace",option+1) == 0)
 989           {
 990             ssize_t
 991               colorspace;
 992
 993             if (*option == '+')
 994               break;
 995             i++;
 996             if (i == (ssize_t) (argc-1))
 997               ThrowConvertException(OptionError,"MissingArgument",option);
 998             colorspace=ParseCommandOption(MagickColorspaceOptions,
 999               MagickFalse,argv[i]);
1000             if (colorspace < 0)
1001               ThrowConvertException(OptionError,"UnrecognizedColorspace",
1002                 argv[i]);
1003             break;
1004           }
1005         if (LocaleCompare("combine",option+1) == 0)
1006           break;
1007         if (LocaleCompare("comment",option+1) == 0)
1008           {
1009             if (*option == '+')
1010               break;
1011             i++;
1012             if (i == (ssize_t) argc)
1013               ThrowConvertException(OptionError,"MissingArgument",option);
1014             break;
1015           }
1016         if (LocaleCompare("compose",option+1) == 0)
1017           {
1018             ssize_t
1019               compose;
1020
1021             if (*option == '+')
1022               break;
1023             i++;
1024             if (i == (ssize_t) argc)
1025               ThrowConvertException(OptionError,"MissingArgument",option);
1026             compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
1027               argv[i]);
1028             if (compose < 0)
1029               ThrowConvertException(OptionError,"UnrecognizedComposeOperator",
1030                 argv[i]);
1031             break;
1032           }
1033         if (LocaleCompare("composite",option+1) == 0)
1034           break;
1035         if (LocaleCompare("compress",option+1) == 0)
1036           {
1037             ssize_t
1038               compress;
1039
1040             if (*option == '+')
1041               break;
1042             i++;
1043             if (i == (ssize_t) (argc-1))
1044               ThrowConvertException(OptionError,"MissingArgument",option);
1045             compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
1046               argv[i]);
1047             if (compress < 0)
1048               ThrowConvertException(OptionError,"UnrecognizedImageCompression",
1049                 argv[i]);
1050             break;
1051           }
1052         if (LocaleCompare("concurrent",option+1) == 0)
1053           break;
1054         if (LocaleCompare("contrast",option+1) == 0)
1055           break;
1056         if (LocaleCompare("contrast-stretch",option+1) == 0)
1057           {
1058             i++;
1059             if (i == (ssize_t) (argc-1))
1060               ThrowConvertException(OptionError,"MissingArgument",option);
1061             if (IsGeometry(argv[i]) == MagickFalse)
1062               ThrowConvertInvalidArgumentException(option,argv[i]);
1063             break;
1064           }
1065         if (LocaleCompare("convolve",option+1) == 0)
1066           {
1067             KernelInfo
1068               *kernel_info;
1069
1070             if (*option == '+')
1071               break;
1072             i++;
1073             if (i == (ssize_t) (argc-1))
1074               ThrowConvertException(OptionError,"MissingArgument",option);
1075             kernel_info=AcquireKernelInfo(argv[i]);
1076             if (kernel_info == (KernelInfo *) NULL)
1077               ThrowConvertInvalidArgumentException(option,argv[i]);
1078             kernel_info=DestroyKernelInfo(kernel_info);
1079             break;
1080           }
1081         if (LocaleCompare("crop",option+1) == 0)
1082           {
1083             if (*option == '+')
1084               break;
1085             i++;
1086             if (i == (ssize_t) (argc-1))
1087               ThrowConvertException(OptionError,"MissingArgument",option);
1088             if (IsGeometry(argv[i]) == MagickFalse)
1089               ThrowConvertInvalidArgumentException(option,argv[i]);
1090             break;
1091           }
1092         if (LocaleCompare("cycle",option+1) == 0)
1093           {
1094             if (*option == '+')
1095               break;
1096             i++;
1097             if (i == (ssize_t) (argc-1))
1098               ThrowConvertException(OptionError,"MissingArgument",option);
1099             if (IsGeometry(argv[i]) == MagickFalse)
1100               ThrowConvertInvalidArgumentException(option,argv[i]);
1101             break;
1102           }
1103         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1104       }
1105       case 'd':
1106       {
1107         if (LocaleCompare("decipher",option+1) == 0)
1108           {
1109             if (*option == '+')
1110               break;
1111             i++;
1112             if (i == (ssize_t) (argc-1))
1113               ThrowConvertException(OptionError,"MissingArgument",option);
1114             break;
1115           }
1116         if (LocaleCompare("deconstruct",option+1) == 0)
1117           break;
1118         if (LocaleCompare("debug",option+1) == 0)
1119           {
1120             ssize_t
1121               event;
1122
1123             if (*option == '+')
1124               break;
1125             i++;
1126             if (i == (ssize_t) argc)
1127               ThrowConvertException(OptionError,"MissingArgument",option);
1128             event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
1129             if (event < 0)
1130               ThrowConvertException(OptionError,"UnrecognizedEventType",
1131                 argv[i]);
1132             (void) SetLogEventMask(argv[i]);
1133             break;
1134           }
1135         if (LocaleCompare("define",option+1) == 0)
1136           {
1137             i++;
1138             if (i == (ssize_t) argc)
1139               ThrowConvertException(OptionError,"MissingArgument",option);
1140             if (*option == '+')
1141               {
1142                 const char
1143                   *define;
1144
1145                 define=GetImageOption(image_info,argv[i]);
1146                 if (define == (const char *) NULL)
1147                   ThrowConvertException(OptionError,"NoSuchOption",argv[i]);
1148                 break;
1149               }
1150             break;
1151           }
1152         if (LocaleCompare("delay",option+1) == 0)
1153           {
1154             if (*option == '+')
1155               break;
1156             i++;
1157             if (i == (ssize_t) argc)
1158               ThrowConvertException(OptionError,"MissingArgument",option);
1159             if (IsGeometry(argv[i]) == MagickFalse)
1160               ThrowConvertInvalidArgumentException(option,argv[i]);
1161             break;
1162           }
1163         if (LocaleCompare("density",option+1) == 0)
1164           {
1165             if (*option == '+')
1166               break;
1167             i++;
1168             if (i == (ssize_t) (argc-1))
1169               ThrowConvertException(OptionError,"MissingArgument",option);
1170             if (IsGeometry(argv[i]) == MagickFalse)
1171               ThrowConvertInvalidArgumentException(option,argv[i]);
1172             break;
1173           }
1174         if (LocaleCompare("depth",option+1) == 0)
1175           {
1176             if (*option == '+')
1177               break;
1178             i++;
1179             if (i == (ssize_t) (argc-1))
1180               ThrowConvertException(OptionError,"MissingArgument",option);
1181             if (IsGeometry(argv[i]) == MagickFalse)
1182               ThrowConvertInvalidArgumentException(option,argv[i]);
1183             break;
1184           }
1185         if (LocaleCompare("delete",option+1) == 0)
1186           {
1187             if (*option == '+')
1188               break;
1189             i++;
1190             if (i == (ssize_t) (argc-1))
1191               ThrowConvertException(OptionError,"MissingArgument",option);
1192             if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
1193               ThrowConvertInvalidArgumentException(option,argv[i]);
1194             break;
1195           }
1196         if (LocaleCompare("deskew",option+1) == 0)
1197           {
1198             if (*option == '+')
1199               break;
1200             i++;
1201             if (i == (ssize_t) (argc-1))
1202               ThrowConvertException(OptionError,"MissingArgument",option);
1203             if (IsGeometry(argv[i]) == MagickFalse)
1204               ThrowConvertInvalidArgumentException(option,argv[i]);
1205             break;
1206           }
1207         if (LocaleCompare("despeckle",option+1) == 0)
1208           break;
1209         if (LocaleCompare("direction",option+1) == 0)
1210           {
1211             ssize_t
1212               direction;
1213
1214             if (*option == '+')
1215               break;
1216             i++;
1217             if (i == (ssize_t) argc)
1218               ThrowConvertException(OptionError,"MissingArgument",option);
1219             direction=ParseCommandOption(MagickDirectionOptions,MagickFalse,
1220               argv[i]);
1221             if (direction < 0)
1222               ThrowConvertException(OptionError,"UnrecognizedDirectionType",
1223                 argv[i]);
1224             break;
1225           }
1226         if (LocaleCompare("display",option+1) == 0)
1227           {
1228             if (*option == '+')
1229               break;
1230             i++;
1231             if (i == (ssize_t) (argc-1))
1232               ThrowConvertException(OptionError,"MissingArgument",option);
1233             break;
1234           }
1235         if (LocaleCompare("dispose",option+1) == 0)
1236           {
1237             ssize_t
1238               dispose;
1239
1240             if (*option == '+')
1241               break;
1242             i++;
1243             if (i == (ssize_t) argc)
1244               ThrowConvertException(OptionError,"MissingArgument",option);
1245             dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,argv[i]);
1246             if (dispose < 0)
1247               ThrowConvertException(OptionError,"UnrecognizedDisposeMethod",
1248                 argv[i]);
1249             break;
1250           }
1251         if (LocaleCompare("distort",option+1) == 0)
1252           {
1253             ssize_t
1254               op;
1255
1256             i++;
1257             if (i == (ssize_t) argc)
1258               ThrowConvertException(OptionError,"MissingArgument",option);
1259             op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
1260             if (op < 0)
1261               ThrowConvertException(OptionError,"UnrecognizedDistortMethod",
1262                 argv[i]);
1263             i++;
1264             if (i == (ssize_t) (argc-1))
1265               ThrowConvertException(OptionError,"MissingArgument",option);
1266             break;
1267           }
1268         if (LocaleCompare("dither",option+1) == 0)
1269           {
1270             ssize_t
1271               method;
1272
1273             if (*option == '+')
1274               break;
1275             i++;
1276             if (i == (ssize_t) argc)
1277               ThrowConvertException(OptionError,"MissingArgument",option);
1278             method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]);
1279             if (method < 0)
1280               ThrowConvertException(OptionError,"UnrecognizedDitherMethod",
1281                 argv[i]);
1282             break;
1283           }
1284         if (LocaleCompare("draw",option+1) == 0)
1285           {
1286             if (*option == '+')
1287               break;
1288             i++;
1289             if (i == (ssize_t) (argc-1))
1290               ThrowConvertException(OptionError,"MissingArgument",option);
1291             break;
1292           }
1293         if (LocaleCompare("duplicate",option+1) == 0)
1294           {
1295             if (*option == '+')
1296               break;
1297             i++;
1298             if (i == (ssize_t) (argc-1))
1299               ThrowConvertException(OptionError,"MissingArgument",option);
1300             if (IsGeometry(argv[i]) == MagickFalse)
1301               ThrowConvertInvalidArgumentException(option,argv[i]);
1302             break;
1303           }
1304         if (LocaleCompare("duration",option+1) == 0)
1305           {
1306             if (*option == '+')
1307               break;
1308             i++;
1309             if (i == (ssize_t) (argc-1))
1310               ThrowConvertException(OptionError,"MissingArgument",option);
1311             if (IsGeometry(argv[i]) == MagickFalse)
1312               ThrowConvertInvalidArgumentException(option,argv[i]);
1313             break;
1314           }
1315         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1316       }
1317       case 'e':
1318       {
1319         if (LocaleCompare("edge",option+1) == 0)
1320           {
1321             if (*option == '+')
1322               break;
1323             i++;
1324             if (i == (ssize_t) (argc-1))
1325               ThrowConvertException(OptionError,"MissingArgument",option);
1326             if (IsGeometry(argv[i]) == MagickFalse)
1327               ThrowConvertInvalidArgumentException(option,argv[i]);
1328             break;
1329           }
1330         if (LocaleCompare("emboss",option+1) == 0)
1331           {
1332             if (*option == '+')
1333               break;
1334             i++;
1335             if (i == (ssize_t) (argc-1))
1336               ThrowConvertException(OptionError,"MissingArgument",option);
1337             if (IsGeometry(argv[i]) == MagickFalse)
1338               ThrowConvertInvalidArgumentException(option,argv[i]);
1339             break;
1340           }
1341         if (LocaleCompare("encipher",option+1) == 0)
1342           {
1343             if (*option == '+')
1344               break;
1345             i++;
1346             if (i == (ssize_t) (argc-1))
1347               ThrowConvertException(OptionError,"MissingArgument",option);
1348             break;
1349           }
1350         if (LocaleCompare("encoding",option+1) == 0)
1351           {
1352             if (*option == '+')
1353               break;
1354             i++;
1355             if (i == (ssize_t) (argc-1))
1356               ThrowConvertException(OptionError,"MissingArgument",option);
1357             break;
1358           }
1359         if (LocaleCompare("endian",option+1) == 0)
1360           {
1361             ssize_t
1362               endian;
1363
1364             if (*option == '+')
1365               break;
1366             i++;
1367             if (i == (ssize_t) (argc-1))
1368               ThrowConvertException(OptionError,"MissingArgument",option);
1369             endian=ParseCommandOption(MagickEndianOptions,MagickFalse,
1370               argv[i]);
1371             if (endian < 0)
1372               ThrowConvertException(OptionError,"UnrecognizedEndianType",
1373                 argv[i]);
1374             break;
1375           }
1376         if (LocaleCompare("enhance",option+1) == 0)
1377           break;
1378         if (LocaleCompare("equalize",option+1) == 0)
1379           break;
1380         if (LocaleCompare("evaluate",option+1) == 0)
1381           {
1382             ssize_t
1383               op;
1384
1385             if (*option == '+')
1386               break;
1387             i++;
1388             if (i == (ssize_t) argc)
1389               ThrowConvertException(OptionError,"MissingArgument",option);
1390             op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
1391             if (op < 0)
1392               ThrowConvertException(OptionError,"UnrecognizedEvaluateOperator",
1393                 argv[i]);
1394             i++;
1395             if (i == (ssize_t) (argc-1))
1396               ThrowConvertException(OptionError,"MissingArgument",option);
1397             if (IsGeometry(argv[i]) == MagickFalse)
1398               ThrowConvertInvalidArgumentException(option,argv[i]);
1399             break;
1400           }
1401         if (LocaleCompare("evaluate-sequence",option+1) == 0)
1402           {
1403             ssize_t
1404               op;
1405
1406             if (*option == '+')
1407               break;
1408             i++;
1409             if (i == (ssize_t) argc)
1410               ThrowConvertException(OptionError,"MissingArgument",option);
1411             op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
1412             if (op < 0)
1413               ThrowConvertException(OptionError,"UnrecognizedEvaluateOperator",
1414                 argv[i]);
1415             break;
1416           }
1417         if (LocaleCompare("extent",option+1) == 0)
1418           {
1419             if (*option == '+')
1420               break;
1421             i++;
1422             if (i == (ssize_t) (argc-1))
1423               ThrowConvertException(OptionError,"MissingArgument",option);
1424             if (IsGeometry(argv[i]) == MagickFalse)
1425               ThrowConvertInvalidArgumentException(option,argv[i]);
1426             break;
1427           }
1428         if (LocaleCompare("extract",option+1) == 0)
1429           {
1430             if (*option == '+')
1431               break;
1432             i++;
1433             if (i == (ssize_t) (argc-1))
1434               ThrowConvertException(OptionError,"MissingArgument",option);
1435             if (IsGeometry(argv[i]) == MagickFalse)
1436               ThrowConvertInvalidArgumentException(option,argv[i]);
1437             break;
1438           }
1439         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1440       }
1441       case 'f':
1442       {
1443         if (LocaleCompare("family",option+1) == 0)
1444           {
1445             if (*option == '+')
1446               break;
1447             i++;
1448             if (i == (ssize_t) (argc-1))
1449               ThrowConvertException(OptionError,"MissingArgument",option);
1450             break;
1451           }
1452         if (LocaleCompare("fft",option+1) == 0)
1453           break;
1454         if (LocaleCompare("fill",option+1) == 0)
1455           {
1456             if (*option == '+')
1457               break;
1458             i++;
1459             if (i == (ssize_t) (argc-1))
1460               ThrowConvertException(OptionError,"MissingArgument",option);
1461             break;
1462           }
1463         if (LocaleCompare("filter",option+1) == 0)
1464           {
1465             ssize_t
1466               filter;
1467
1468             if (*option == '+')
1469               break;
1470             i++;
1471             if (i == (ssize_t) (argc-1))
1472               ThrowConvertException(OptionError,"MissingArgument",option);
1473             filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]);
1474             if (filter < 0)
1475               ThrowConvertException(OptionError,"UnrecognizedImageFilter",
1476                 argv[i]);
1477             break;
1478           }
1479         if (LocaleCompare("flatten",option+1) == 0)
1480           break;
1481         if (LocaleCompare("flip",option+1) == 0)
1482           break;
1483         if (LocaleCompare("flop",option+1) == 0)
1484           break;
1485         if (LocaleCompare("floodfill",option+1) == 0)
1486           {
1487             if (*option == '+')
1488               break;
1489             i++;
1490             if (i == (ssize_t) (argc-1))
1491               ThrowConvertException(OptionError,"MissingArgument",option);
1492             if (IsGeometry(argv[i]) == MagickFalse)
1493               ThrowConvertInvalidArgumentException(option,argv[i]);
1494             i++;
1495             if (i == (ssize_t) (argc-1))
1496               ThrowConvertException(OptionError,"MissingArgument",option);
1497             break;
1498           }
1499         if (LocaleCompare("font",option+1) == 0)
1500           {
1501             if (*option == '+')
1502               break;
1503             i++;
1504             if (i == (ssize_t) (argc-1))
1505               ThrowConvertException(OptionError,"MissingArgument",option);
1506             break;
1507           }
1508         if (LocaleCompare("format",option+1) == 0)
1509           {
1510             if (*option == '+')
1511               break;
1512             i++;
1513             if (i == (ssize_t) (argc-1))
1514               ThrowConvertException(OptionError,"MissingArgument",option);
1515             format=argv[i];
1516             break;
1517           }
1518         if (LocaleCompare("frame",option+1) == 0)
1519           {
1520             if (*option == '+')
1521               break;
1522             i++;
1523             if (i == (ssize_t) (argc-1))
1524               ThrowConvertException(OptionError,"MissingArgument",option);
1525             if (IsGeometry(argv[i]) == MagickFalse)
1526               ThrowConvertInvalidArgumentException(option,argv[i]);
1527             break;
1528           }
1529         if (LocaleCompare("function",option+1) == 0)
1530           {
1531             ssize_t
1532               op;
1533
1534             if (*option == '+')
1535               break;
1536             i++;
1537             if (i == (ssize_t) argc)
1538               ThrowConvertException(OptionError,"MissingArgument",option);
1539             op=ParseCommandOption(MagickFunctionOptions,MagickFalse,argv[i]);
1540             if (op < 0)
1541               ThrowConvertException(OptionError,"UnrecognizedFunction",argv[i]);
1542              i++;
1543              if (i == (ssize_t) (argc-1))
1544                ThrowConvertException(OptionError,"MissingArgument",option);
1545             break;
1546           }
1547         if (LocaleCompare("fuzz",option+1) == 0)
1548           {
1549             if (*option == '+')
1550               break;
1551             i++;
1552             if (i == (ssize_t) (argc-1))
1553               ThrowConvertException(OptionError,"MissingArgument",option);
1554             if (IsGeometry(argv[i]) == MagickFalse)
1555               ThrowConvertInvalidArgumentException(option,argv[i]);
1556             break;
1557           }
1558         if (LocaleCompare("fx",option+1) == 0)
1559           {
1560             if (*option == '+')
1561               break;
1562             i++;
1563             if (i == (ssize_t) (argc-1))
1564               ThrowConvertException(OptionError,"MissingArgument",option);
1565             break;
1566           }
1567         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1568       }
1569       case 'g':
1570       {
1571         if (LocaleCompare("gamma",option+1) == 0)
1572           {
1573             i++;
1574             if (i == (ssize_t) (argc-1))
1575               ThrowConvertException(OptionError,"MissingArgument",option);
1576             if (IsGeometry(argv[i]) == MagickFalse)
1577               ThrowConvertInvalidArgumentException(option,argv[i]);
1578             break;
1579           }
1580         if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
1581             (LocaleCompare("gaussian",option+1) == 0))
1582           {
1583             i++;
1584             if (i == (ssize_t) (argc-1))
1585               ThrowConvertException(OptionError,"MissingArgument",option);
1586             if (IsGeometry(argv[i]) == MagickFalse)
1587               ThrowConvertInvalidArgumentException(option,argv[i]);
1588             break;
1589           }
1590         if (LocaleCompare("geometry",option+1) == 0)
1591           {
1592             if (*option == '+')
1593               break;
1594             i++;
1595             if (i == (ssize_t) (argc-1))
1596               ThrowConvertException(OptionError,"MissingArgument",option);
1597             if (IsGeometry(argv[i]) == MagickFalse)
1598               ThrowConvertInvalidArgumentException(option,argv[i]);
1599             break;
1600           }
1601         if (LocaleCompare("gravity",option+1) == 0)
1602           {
1603             ssize_t
1604               gravity;
1605
1606             if (*option == '+')
1607               break;
1608             i++;
1609             if (i == (ssize_t) (argc-1))
1610               ThrowConvertException(OptionError,"MissingArgument",option);
1611             gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
1612               argv[i]);
1613             if (gravity < 0)
1614               ThrowConvertException(OptionError,"UnrecognizedGravityType",
1615                 argv[i]);
1616             break;
1617           }
1618         if (LocaleCompare("green-primary",option+1) == 0)
1619           {
1620             if (*option == '+')
1621               break;
1622             i++;
1623             if (i == (ssize_t) (argc-1))
1624               ThrowConvertException(OptionError,"MissingArgument",option);
1625             if (IsGeometry(argv[i]) == MagickFalse)
1626               ThrowConvertInvalidArgumentException(option,argv[i]);
1627             break;
1628           }
1629         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1630       }
1631       case 'h':
1632       {
1633         if (LocaleCompare("hald-clut",option+1) == 0)
1634           break;
1635         if ((LocaleCompare("help",option+1) == 0) ||
1636             (LocaleCompare("-help",option+1) == 0))
1637           return(ConvertUsage());
1638         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1639       }
1640       case 'i':
1641       {
1642         if (LocaleCompare("identify",option+1) == 0)
1643           break;
1644         if (LocaleCompare("ift",option+1) == 0)
1645           break;
1646         if (LocaleCompare("implode",option+1) == 0)
1647           {
1648             if (*option == '+')
1649               break;
1650             i++;
1651             if (i == (ssize_t) (argc-1))
1652               ThrowConvertException(OptionError,"MissingArgument",option);
1653             if (IsGeometry(argv[i]) == MagickFalse)
1654               ThrowConvertInvalidArgumentException(option,argv[i]);
1655             break;
1656           }
1657         if (LocaleCompare("insert",option+1) == 0)
1658           {
1659             if (*option == '+')
1660               break;
1661             i++;
1662             if (i == (ssize_t) (argc-1))
1663               ThrowConvertException(OptionError,"MissingArgument",option);
1664             if (IsGeometry(argv[i]) == MagickFalse)
1665               ThrowConvertInvalidArgumentException(option,argv[i]);
1666             break;
1667           }
1668         if (LocaleCompare("intent",option+1) == 0)
1669           {
1670             ssize_t
1671               intent;
1672
1673             if (*option == '+')
1674               break;
1675             i++;
1676             if (i == (ssize_t) (argc-1))
1677               ThrowConvertException(OptionError,"MissingArgument",option);
1678             intent=ParseCommandOption(MagickIntentOptions,MagickFalse,
1679               argv[i]);
1680             if (intent < 0)
1681               ThrowConvertException(OptionError,"UnrecognizedIntentType",
1682                 argv[i]);
1683             break;
1684           }
1685         if (LocaleCompare("interlace",option+1) == 0)
1686           {
1687             ssize_t
1688               interlace;
1689
1690             if (*option == '+')
1691               break;
1692             i++;
1693             if (i == (ssize_t) (argc-1))
1694               ThrowConvertException(OptionError,"MissingArgument",option);
1695             interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
1696               argv[i]);
1697             if (interlace < 0)
1698               ThrowConvertException(OptionError,"UnrecognizedInterlaceType",
1699                 argv[i]);
1700             break;
1701           }
1702         if (LocaleCompare("interline-spacing",option+1) == 0)
1703           {
1704             if (*option == '+')
1705               break;
1706             i++;
1707             if (i == (ssize_t) (argc-1))
1708               ThrowConvertException(OptionError,"MissingArgument",option);
1709             if (IsGeometry(argv[i]) == MagickFalse)
1710               ThrowConvertInvalidArgumentException(option,argv[i]);
1711             break;
1712           }
1713         if (LocaleCompare("interpolate",option+1) == 0)
1714           {
1715             ssize_t
1716               interpolate;
1717
1718             if (*option == '+')
1719               break;
1720             i++;
1721             if (i == (ssize_t) argc)
1722               ThrowConvertException(OptionError,"MissingArgument",option);
1723             interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
1724               argv[i]);
1725             if (interpolate < 0)
1726               ThrowConvertException(OptionError,"UnrecognizedInterpolateMethod",
1727                 argv[i]);
1728             break;
1729           }
1730         if (LocaleCompare("interword-spacing",option+1) == 0)
1731           {
1732             if (*option == '+')
1733               break;
1734             i++;
1735             if (i == (ssize_t) (argc-1))
1736               ThrowConvertException(OptionError,"MissingArgument",option);
1737             if (IsGeometry(argv[i]) == MagickFalse)
1738               ThrowConvertInvalidArgumentException(option,argv[i]);
1739             break;
1740           }
1741         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1742       }
1743       case 'k':
1744       {
1745         if (LocaleCompare("kerning",option+1) == 0)
1746           {
1747             if (*option == '+')
1748               break;
1749             i++;
1750             if (i == (ssize_t) (argc-1))
1751               ThrowConvertException(OptionError,"MissingArgument",option);
1752             if (IsGeometry(argv[i]) == MagickFalse)
1753               ThrowConvertInvalidArgumentException(option,argv[i]);
1754             break;
1755           }
1756         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1757       }
1758       case 'l':
1759       {
1760         if (LocaleCompare("label",option+1) == 0)
1761           {
1762             if (*option == '+')
1763               break;
1764             i++;
1765             if (i == (ssize_t) argc)
1766               ThrowConvertException(OptionError,"MissingArgument",option);
1767             break;
1768           }
1769         if (LocaleCompare("lat",option+1) == 0)
1770           {
1771             if (*option == '+')
1772               break;
1773             i++;
1774             if (i == (ssize_t) (argc-1))
1775               ThrowConvertException(OptionError,"MissingArgument",option);
1776             if (IsGeometry(argv[i]) == MagickFalse)
1777               ThrowConvertInvalidArgumentException(option,argv[i]);
1778             break;
1779           }
1780         if (LocaleCompare("layers",option+1) == 0)
1781           {
1782             ssize_t
1783               type;
1784
1785             if (*option == '+')
1786               break;
1787             i++;
1788             if (i == (ssize_t) (argc-1))
1789               ThrowConvertException(OptionError,"MissingArgument",option);
1790             type=ParseCommandOption(MagickLayerOptions,MagickFalse,argv[i]);
1791             if (type < 0)
1792               ThrowConvertException(OptionError,"UnrecognizedLayerMethod",
1793                 argv[i]);
1794             break;
1795           }
1796         if (LocaleCompare("level",option+1) == 0)
1797           {
1798             i++;
1799             if (i == (ssize_t) (argc-1))
1800               ThrowConvertException(OptionError,"MissingArgument",option);
1801             if (IsGeometry(argv[i]) == MagickFalse)
1802               ThrowConvertInvalidArgumentException(option,argv[i]);
1803             break;
1804           }
1805         if (LocaleCompare("level-colors",option+1) == 0)
1806           {
1807             i++;
1808             if (i == (ssize_t) (argc-1))
1809               ThrowConvertException(OptionError,"MissingArgument",option);
1810             break;
1811           }
1812         if (LocaleCompare("linewidth",option+1) == 0)
1813           {
1814             if (*option == '+')
1815               break;
1816             i++;
1817             if (i == (ssize_t) (argc-1))
1818               ThrowConvertException(OptionError,"MissingArgument",option);
1819             if (IsGeometry(argv[i]) == MagickFalse)
1820               ThrowConvertInvalidArgumentException(option,argv[i]);
1821             break;
1822           }
1823         if (LocaleCompare("liquid-rescale",option+1) == 0)
1824           {
1825             i++;
1826             if (i == (ssize_t) (argc-1))
1827               ThrowConvertException(OptionError,"MissingArgument",option);
1828             if (IsGeometry(argv[i]) == MagickFalse)
1829               ThrowConvertInvalidArgumentException(option,argv[i]);
1830             break;
1831           }
1832         if (LocaleCompare("limit",option+1) == 0)
1833           {
1834             char
1835               *p;
1836
1837             double
1838               value;
1839
1840             ssize_t
1841               resource;
1842
1843             if (*option == '+')
1844               break;
1845             i++;
1846             if (i == (ssize_t) argc)
1847               ThrowConvertException(OptionError,"MissingArgument",option);
1848             resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
1849               argv[i]);
1850             if (resource < 0)
1851               ThrowConvertException(OptionError,"UnrecognizedResourceType",
1852                 argv[i]);
1853             i++;
1854             if (i == (ssize_t) argc)
1855               ThrowConvertException(OptionError,"MissingArgument",option);
1856             value=InterpretLocaleValue(argv[i],&p);
1857             (void) value;
1858             if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
1859               ThrowConvertInvalidArgumentException(option,argv[i]);
1860             break;
1861           }
1862         if (LocaleCompare("linear-stretch",option+1) == 0)
1863           {
1864             i++;
1865             if (i == (ssize_t) (argc-1))
1866               ThrowConvertException(OptionError,"MissingArgument",option);
1867             if (IsGeometry(argv[i]) == MagickFalse)
1868               ThrowConvertInvalidArgumentException(option,argv[i]);
1869             break;
1870           }
1871         if (LocaleCompare("list",option+1) == 0)
1872           {
1873             ssize_t
1874               list;
1875
1876             if (*option == '+')
1877               break;
1878             i++;
1879             if (i == (ssize_t) argc)
1880               ThrowConvertException(OptionError,"MissingArgument",option);
1881             list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
1882             if (list < 0)
1883               ThrowConvertException(OptionError,"UnrecognizedListType",argv[i]);
1884             status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
1885               argv+j,exception);
1886             DestroyConvert();
1887             return(status != 0 ? MagickFalse : MagickTrue);
1888           }
1889         if (LocaleCompare("log",option+1) == 0)
1890           {
1891             if (*option == '+')
1892               break;
1893             i++;
1894             if ((i == (ssize_t) argc) ||
1895                 (strchr(argv[i],'%') == (char *) NULL))
1896               ThrowConvertException(OptionError,"MissingArgument",option);
1897             break;
1898           }
1899         if (LocaleCompare("loop",option+1) == 0)
1900           {
1901             if (*option == '+')
1902               break;
1903             i++;
1904             if (i == (ssize_t) (argc-1))
1905               ThrowConvertException(OptionError,"MissingArgument",option);
1906             if (IsGeometry(argv[i]) == MagickFalse)
1907               ThrowConvertInvalidArgumentException(option,argv[i]);
1908             break;
1909           }
1910         ThrowConvertException(OptionError,"UnrecognizedOption",option)
1911       }
1912       case 'm':
1913       {
1914         if (LocaleCompare("map",option+1) == 0)
1915           {
1916             if (*option == '+')
1917               break;
1918             i++;
1919             if (i == (ssize_t) (argc-1))
1920               ThrowConvertException(OptionError,"MissingArgument",option);
1921             break;
1922           }
1923         if (LocaleCompare("mask",option+1) == 0)
1924           {
1925             if (*option == '+')
1926               break;
1927             i++;
1928             if (i == (ssize_t) (argc-1))
1929               ThrowConvertException(OptionError,"MissingArgument",option);
1930             break;
1931           }
1932         if (LocaleCompare("matte",option+1) == 0)
1933           break;
1934         if (LocaleCompare("mattecolor",option+1) == 0)
1935           {
1936             if (*option == '+')
1937               break;
1938             i++;
1939             if (i == (ssize_t) (argc-1))
1940               ThrowConvertException(OptionError,"MissingArgument",option);
1941             break;
1942           }
1943         if (LocaleCompare("maximum",option+1) == 0)
1944           break;
1945         if (LocaleCompare("median",option+1) == 0)
1946           {
1947             if (*option == '+')
1948               break;
1949             i++;
1950             if (i == (ssize_t) (argc-1))
1951               ThrowConvertException(OptionError,"MissingArgument",option);
1952             if (IsGeometry(argv[i]) == MagickFalse)
1953               ThrowConvertInvalidArgumentException(option,argv[i]);
1954             break;
1955           }
1956         if (LocaleCompare("minimum",option+1) == 0)
1957           break;
1958         if (LocaleCompare("mode",option+1) == 0)
1959           {
1960             if (*option == '+')
1961               break;
1962             i++;
1963             if (i == (ssize_t) (argc-1))
1964               ThrowConvertException(OptionError,"MissingArgument",option);
1965             if (IsGeometry(argv[i]) == MagickFalse)
1966               ThrowConvertInvalidArgumentException(option,argv[i]);
1967             break;
1968           }
1969         if (LocaleCompare("modulate",option+1) == 0)
1970           {
1971             if (*option == '+')
1972               break;
1973             i++;
1974             if (i == (ssize_t) (argc-1))
1975               ThrowConvertException(OptionError,"MissingArgument",option);
1976             if (IsGeometry(argv[i]) == MagickFalse)
1977               ThrowConvertInvalidArgumentException(option,argv[i]);
1978             break;
1979           }
1980         if (LocaleCompare("monitor",option+1) == 0)
1981           break;
1982         if (LocaleCompare("monochrome",option+1) == 0)
1983           break;
1984         if (LocaleCompare("morph",option+1) == 0)
1985           {
1986             if (*option == '+')
1987               break;
1988             i++;
1989             if (i == (ssize_t) (argc-1))
1990               ThrowConvertException(OptionError,"MissingArgument",option);
1991             if (IsGeometry(argv[i]) == MagickFalse)
1992               ThrowConvertInvalidArgumentException(option,argv[i]);
1993             break;
1994           }
1995         if (LocaleCompare("morphology",option+1) == 0)
1996           {
1997             char
1998               token[MaxTextExtent];
1999
2000             KernelInfo
2001               *kernel_info;
2002
2003             ssize_t
2004               op;
2005
2006             i++;
2007             if (i == (ssize_t) argc)
2008               ThrowConvertException(OptionError,"MissingArgument",option);
2009             GetMagickToken(argv[i],NULL,token);
2010             op=ParseCommandOption(MagickMorphologyOptions,MagickFalse,token);
2011             if (op < 0)
2012               ThrowConvertException(OptionError,"UnrecognizedMorphologyMethod",
2013                 token);
2014             i++;
2015             if (i == (ssize_t) (argc-1))
2016               ThrowConvertException(OptionError,"MissingArgument",option);
2017             kernel_info=AcquireKernelInfo(argv[i]);
2018             if (kernel_info == (KernelInfo *) NULL)
2019               ThrowConvertInvalidArgumentException(option,argv[i]);
2020             kernel_info=DestroyKernelInfo(kernel_info);
2021             break;
2022           }
2023         if (LocaleCompare("mosaic",option+1) == 0)
2024           break;
2025         if (LocaleCompare("motion-blur",option+1) == 0)
2026           {
2027             if (*option == '+')
2028               break;
2029             i++;
2030             if (i == (ssize_t) (argc-1))
2031               ThrowConvertException(OptionError,"MissingArgument",option);
2032             if (IsGeometry(argv[i]) == MagickFalse)
2033               ThrowConvertInvalidArgumentException(option,argv[i]);
2034             break;
2035           }
2036         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2037       }
2038       case 'n':
2039       {
2040         if (LocaleCompare("negate",option+1) == 0)
2041           break;
2042         if (LocaleCompare("noise",option+1) == 0)
2043           {
2044             i++;
2045             if (i == (ssize_t) (argc-1))
2046               ThrowConvertException(OptionError,"MissingArgument",option);
2047             if (*option == '+')
2048               {
2049                 ssize_t
2050                   noise;
2051
2052                 noise=ParseCommandOption(MagickNoiseOptions,MagickFalse,argv[i]);
2053                 if (noise < 0)
2054                   ThrowConvertException(OptionError,"UnrecognizedNoiseType",
2055                     argv[i]);
2056                 break;
2057               }
2058             if (IsGeometry(argv[i]) == MagickFalse)
2059               ThrowConvertInvalidArgumentException(option,argv[i]);
2060             break;
2061           }
2062         if (LocaleCompare("noop",option+1) == 0)
2063           break;
2064         if (LocaleCompare("normalize",option+1) == 0)
2065           break;
2066         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2067       }
2068       case 'o':
2069       {
2070         if (LocaleCompare("opaque",option+1) == 0)
2071           {
2072             i++;
2073             if (i == (ssize_t) (argc-1))
2074               ThrowConvertException(OptionError,"MissingArgument",option);
2075             break;
2076           }
2077         if (LocaleCompare("ordered-dither",option+1) == 0)
2078           {
2079             if (*option == '+')
2080               break;
2081             i++;
2082             if (i == (ssize_t) (argc-1))
2083               ThrowConvertException(OptionError,"MissingArgument",option);
2084             break;
2085           }
2086         if (LocaleCompare("orient",option+1) == 0)
2087           {
2088             ssize_t
2089               orientation;
2090
2091             if (*option == '+')
2092               break;
2093             i++;
2094             if (i == (ssize_t) (argc-1))
2095               ThrowConvertException(OptionError,"MissingArgument",option);
2096             orientation=ParseCommandOption(MagickOrientationOptions,
2097               MagickFalse,argv[i]);
2098             if (orientation < 0)
2099               ThrowConvertException(OptionError,"UnrecognizedImageOrientation",
2100                 argv[i]);
2101             break;
2102           }
2103         ThrowConvertException(OptionError,"UnrecognizedOption",argv[i])
2104       }
2105       case 'p':
2106       {
2107         if (LocaleCompare("page",option+1) == 0)
2108           {
2109             if (*option == '+')
2110               break;
2111             i++;
2112             if (i == (ssize_t) argc)
2113               ThrowConvertException(OptionError,"MissingArgument",option);
2114             break;
2115           }
2116         if (LocaleCompare("paint",option+1) == 0)
2117           {
2118             if (*option == '+')
2119               break;
2120             i++;
2121             if (i == (ssize_t) (argc-1))
2122               ThrowConvertException(OptionError,"MissingArgument",option);
2123             if (IsGeometry(argv[i]) == MagickFalse)
2124               ThrowConvertInvalidArgumentException(option,argv[i]);
2125             break;
2126           }
2127         if (LocaleCompare("ping",option+1) == 0)
2128           break;
2129         if (LocaleCompare("pointsize",option+1) == 0)
2130           {
2131             if (*option == '+')
2132               break;
2133             i++;
2134             if (i == (ssize_t) (argc-1))
2135               ThrowConvertException(OptionError,"MissingArgument",option);
2136             if (IsGeometry(argv[i]) == MagickFalse)
2137               ThrowConvertInvalidArgumentException(option,argv[i]);
2138             break;
2139           }
2140         if (LocaleCompare("polaroid",option+1) == 0)
2141           {
2142             if (*option == '+')
2143               break;
2144             i++;
2145             if (i == (ssize_t) (argc-1))
2146               ThrowConvertException(OptionError,"MissingArgument",option);
2147             if (IsGeometry(argv[i]) == MagickFalse)
2148               ThrowConvertInvalidArgumentException(option,argv[i]);
2149             break;
2150           }
2151         if (LocaleCompare("posterize",option+1) == 0)
2152           {
2153             if (*option == '+')
2154               break;
2155             i++;
2156             if (i == (ssize_t) (argc-1))
2157               ThrowConvertException(OptionError,"MissingArgument",option);
2158             if (IsGeometry(argv[i]) == MagickFalse)
2159               ThrowConvertInvalidArgumentException(option,argv[i]);
2160             break;
2161           }
2162         if (LocaleCompare("precision",option+1) == 0)
2163           {
2164             if (*option == '+')
2165               break;
2166             i++;
2167             if (i == (ssize_t) (argc-1))
2168               ThrowConvertException(OptionError,"MissingArgument",option);
2169             if (IsGeometry(argv[i]) == MagickFalse)
2170               ThrowConvertInvalidArgumentException(option,argv[i]);
2171             break;
2172           }
2173         if (LocaleCompare("preview",option+1) == 0)
2174           {
2175             ssize_t
2176               preview;
2177
2178             if (*option == '+')
2179               break;
2180             i++;
2181             if (i == (ssize_t) (argc-1))
2182               ThrowConvertException(OptionError,"MissingArgument",option);
2183             preview=ParseCommandOption(MagickPreviewOptions,MagickFalse,
2184               argv[i]);
2185             if (preview < 0)
2186               ThrowConvertException(OptionError,"UnrecognizedPreviewType",
2187                 argv[i]);
2188             break;
2189           }
2190         if (LocaleCompare("print",option+1) == 0)
2191           {
2192             if (*option == '+')
2193               break;
2194             i++;
2195             if (i == (ssize_t) (argc-1))
2196               ThrowConvertException(OptionError,"MissingArgument",option);
2197             break;
2198           }
2199         if (LocaleCompare("process",option+1) == 0)
2200           {
2201             if (*option == '+')
2202               break;
2203             i++;
2204             if (i == (ssize_t) (argc-1))
2205               ThrowConvertException(OptionError,"MissingArgument",option);
2206             break;
2207           }
2208         if (LocaleCompare("profile",option+1) == 0)
2209           {
2210             i++;
2211             if (i == (ssize_t) (argc-1))
2212               ThrowConvertException(OptionError,"MissingArgument",option);
2213             break;
2214           }
2215         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2216       }
2217       case 'q':
2218       {
2219         if (LocaleCompare("quality",option+1) == 0)
2220           {
2221             if (*option == '+')
2222               break;
2223             i++;
2224             if (i == (ssize_t) (argc-1))
2225               ThrowConvertException(OptionError,"MissingArgument",option);
2226             if (IsGeometry(argv[i]) == MagickFalse)
2227               ThrowConvertInvalidArgumentException(option,argv[i]);
2228             break;
2229           }
2230         if (LocaleCompare("quantize",option+1) == 0)
2231           {
2232             ssize_t
2233               colorspace;
2234
2235             if (*option == '+')
2236               break;
2237             i++;
2238             if (i == (ssize_t) (argc-1))
2239               ThrowConvertException(OptionError,"MissingArgument",option);
2240             colorspace=ParseCommandOption(MagickColorspaceOptions,
2241               MagickFalse,argv[i]);
2242             if (colorspace < 0)
2243               ThrowConvertException(OptionError,"UnrecognizedColorspace",
2244                 argv[i]);
2245             break;
2246           }
2247         if (LocaleCompare("quiet",option+1) == 0)
2248           break;
2249         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2250       }
2251       case 'r':
2252       {
2253         if (LocaleCompare("radial-blur",option+1) == 0)
2254           {
2255             i++;
2256             if (i == (ssize_t) (argc-1))
2257               ThrowConvertException(OptionError,"MissingArgument",option);
2258             if (IsGeometry(argv[i]) == MagickFalse)
2259               ThrowConvertInvalidArgumentException(option,argv[i]);
2260             break;
2261           }
2262         if (LocaleCompare("raise",option+1) == 0)
2263           {
2264             i++;
2265             if (i == (ssize_t) (argc-1))
2266               ThrowConvertException(OptionError,"MissingArgument",option);
2267             if (IsGeometry(argv[i]) == MagickFalse)
2268               ThrowConvertInvalidArgumentException(option,argv[i]);
2269             break;
2270           }
2271         if (LocaleCompare("random-threshold",option+1) == 0)
2272           {
2273             if (*option == '+')
2274               break;
2275             i++;
2276             if (i == (ssize_t) (argc-1))
2277               ThrowConvertException(OptionError,"MissingArgument",option);
2278             if (IsGeometry(argv[i]) == MagickFalse)
2279               ThrowConvertInvalidArgumentException(option,argv[i]);
2280             break;
2281           }
2282         if (LocaleCompare("recolor",option+1) == 0)
2283           {
2284             if (*option == '+')
2285               break;
2286             i++;
2287             if (i == (ssize_t) (argc-1))
2288               ThrowConvertException(OptionError,"MissingArgument",option);
2289             if (IsGeometry(argv[i]) == MagickFalse)
2290               ThrowConvertInvalidArgumentException(option,argv[i]);
2291             break;
2292           }
2293         if (LocaleCompare("red-primary",option+1) == 0)
2294           {
2295             if (*option == '+')
2296               break;
2297             i++;
2298             if (i == (ssize_t) (argc-1))
2299               ThrowConvertException(OptionError,"MissingArgument",option);
2300             if (IsGeometry(argv[i]) == MagickFalse)
2301               ThrowConvertInvalidArgumentException(option,argv[i]);
2302             break;
2303           }
2304         if (LocaleCompare("regard-warnings",option+1) == 0)
2305           break;
2306         if (LocaleCompare("region",option+1) == 0)
2307           {
2308             if (*option == '+')
2309               break;
2310             i++;
2311             if (i == (ssize_t) (argc-1))
2312               ThrowConvertException(OptionError,"MissingArgument",option);
2313             if (IsGeometry(argv[i]) == MagickFalse)
2314               ThrowConvertInvalidArgumentException(option,argv[i]);
2315             break;
2316           }
2317         if (LocaleCompare("remap",option+1) == 0)
2318           {
2319             if (*option == '+')
2320               break;
2321             i++;
2322             if (i == (ssize_t) (argc-1))
2323               ThrowConvertException(OptionError,"MissingArgument",option);
2324             break;
2325           }
2326         if (LocaleCompare("render",option+1) == 0)
2327           break;
2328         if (LocaleCompare("repage",option+1) == 0)
2329           {
2330             if (*option == '+')
2331               break;
2332             i++;
2333             if (i == (ssize_t) (argc-1))
2334               ThrowConvertException(OptionError,"MissingArgument",option);
2335             if (IsGeometry(argv[i]) == MagickFalse)
2336               ThrowConvertInvalidArgumentException(option,argv[i]);
2337             break;
2338           }
2339         if (LocaleCompare("resample",option+1) == 0)
2340           {
2341             if (*option == '+')
2342               break;
2343             i++;
2344             if (i == (ssize_t) (argc-1))
2345               ThrowConvertException(OptionError,"MissingArgument",option);
2346             if (IsGeometry(argv[i]) == MagickFalse)
2347               ThrowConvertInvalidArgumentException(option,argv[i]);
2348             break;
2349           }
2350         if (LocaleCompare("resize",option+1) == 0)
2351           {
2352             if (*option == '+')
2353               break;
2354             i++;
2355             if (i == (ssize_t) (argc-1))
2356               ThrowConvertException(OptionError,"MissingArgument",option);
2357             if (IsGeometry(argv[i]) == MagickFalse)
2358               ThrowConvertInvalidArgumentException(option,argv[i]);
2359             break;
2360           }
2361         if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
2362           {
2363             respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
2364             break;
2365           }
2366         if (LocaleCompare("reverse",option+1) == 0)
2367           break;
2368         if (LocaleCompare("roll",option+1) == 0)
2369           {
2370             if (*option == '+')
2371               break;
2372             i++;
2373             if (i == (ssize_t) (argc-1))
2374               ThrowConvertException(OptionError,"MissingArgument",option);
2375             if (IsGeometry(argv[i]) == MagickFalse)
2376               ThrowConvertInvalidArgumentException(option,argv[i]);
2377             break;
2378           }
2379         if (LocaleCompare("rotate",option+1) == 0)
2380           {
2381             i++;
2382             if (i == (ssize_t) (argc-1))
2383               ThrowConvertException(OptionError,"MissingArgument",option);
2384             if (IsGeometry(argv[i]) == MagickFalse)
2385               ThrowConvertInvalidArgumentException(option,argv[i]);
2386             break;
2387           }
2388         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2389       }
2390       case 's':
2391       {
2392         if (LocaleCompare("sample",option+1) == 0)
2393           {
2394             if (*option == '+')
2395               break;
2396             i++;
2397             if (i == (ssize_t) (argc-1))
2398               ThrowConvertException(OptionError,"MissingArgument",option);
2399             if (IsGeometry(argv[i]) == MagickFalse)
2400               ThrowConvertInvalidArgumentException(option,argv[i]);
2401             break;
2402           }
2403         if (LocaleCompare("sampling-factor",option+1) == 0)
2404           {
2405             if (*option == '+')
2406               break;
2407             i++;
2408             if (i == (ssize_t) (argc-1))
2409               ThrowConvertException(OptionError,"MissingArgument",option);
2410             if (IsGeometry(argv[i]) == MagickFalse)
2411               ThrowConvertInvalidArgumentException(option,argv[i]);
2412             break;
2413           }
2414         if (LocaleCompare("scale",option+1) == 0)
2415           {
2416             if (*option == '+')
2417               break;
2418             i++;
2419             if (i == (ssize_t) (argc-1))
2420               ThrowConvertException(OptionError,"MissingArgument",option);
2421             if (IsGeometry(argv[i]) == MagickFalse)
2422               ThrowConvertInvalidArgumentException(option,argv[i]);
2423             break;
2424           }
2425         if (LocaleCompare("scene",option+1) == 0)
2426           {
2427             if (*option == '+')
2428               break;
2429             i++;
2430             if (i == (ssize_t) (argc-1))
2431               ThrowConvertException(OptionError,"MissingArgument",option);
2432             if (IsGeometry(argv[i]) == MagickFalse)
2433               ThrowConvertInvalidArgumentException(option,argv[i]);
2434             break;
2435           }
2436         if (LocaleCompare("seed",option+1) == 0)
2437           {
2438             if (*option == '+')
2439               break;
2440             i++;
2441             if (i == (ssize_t) (argc-1))
2442               ThrowConvertException(OptionError,"MissingArgument",option);
2443             if (IsGeometry(argv[i]) == MagickFalse)
2444               ThrowConvertInvalidArgumentException(option,argv[i]);
2445             break;
2446           }
2447         if (LocaleCompare("segment",option+1) == 0)
2448           {
2449             if (*option == '+')
2450               break;
2451             i++;
2452             if (i == (ssize_t) (argc-1))
2453               ThrowConvertException(OptionError,"MissingArgument",option);
2454             if (IsGeometry(argv[i]) == MagickFalse)
2455               ThrowConvertInvalidArgumentException(option,argv[i]);
2456             break;
2457           }
2458         if (LocaleCompare("selective-blur",option+1) == 0)
2459           {
2460             i++;
2461             if (i == (ssize_t) (argc-1))
2462               ThrowConvertException(OptionError,"MissingArgument",option);
2463             if (IsGeometry(argv[i]) == MagickFalse)
2464               ThrowConvertInvalidArgumentException(option,argv[i]);
2465             break;
2466           }
2467         if (LocaleCompare("separate",option+1) == 0)
2468           break;
2469         if (LocaleCompare("sepia-tone",option+1) == 0)
2470           {
2471             if (*option == '+')
2472               break;
2473             i++;
2474             if (i == (ssize_t) (argc-1))
2475               ThrowConvertException(OptionError,"MissingArgument",option);
2476             if (IsGeometry(argv[i]) == MagickFalse)
2477               ThrowConvertInvalidArgumentException(option,argv[i]);
2478             break;
2479           }
2480         if (LocaleCompare("set",option+1) == 0)
2481           {
2482             i++;
2483             if (i == (ssize_t) argc)
2484               ThrowConvertException(OptionError,"MissingArgument",option);
2485             if (*option == '+')
2486               break;
2487             i++;
2488             if (i == (ssize_t) argc)
2489               ThrowConvertException(OptionError,"MissingArgument",option);
2490             break;
2491           }
2492         if (LocaleCompare("shade",option+1) == 0)
2493           {
2494             i++;
2495             if (i == (ssize_t) (argc-1))
2496               ThrowConvertException(OptionError,"MissingArgument",option);
2497             if (IsGeometry(argv[i]) == MagickFalse)
2498               ThrowConvertInvalidArgumentException(option,argv[i]);
2499             break;
2500           }
2501         if (LocaleCompare("shadow",option+1) == 0)
2502           {
2503             if (*option == '+')
2504               break;
2505             i++;
2506             if (i == (ssize_t) (argc-1))
2507               ThrowConvertException(OptionError,"MissingArgument",option);
2508             if (IsGeometry(argv[i]) == MagickFalse)
2509               ThrowConvertInvalidArgumentException(option,argv[i]);
2510             break;
2511           }
2512         if (LocaleCompare("sharpen",option+1) == 0)
2513           {
2514             i++;
2515             if (i == (ssize_t) (argc-1))
2516               ThrowConvertException(OptionError,"MissingArgument",option);
2517             if (IsGeometry(argv[i]) == MagickFalse)
2518               ThrowConvertInvalidArgumentException(option,argv[i]);
2519             break;
2520           }
2521         if (LocaleCompare("shave",option+1) == 0)
2522           {
2523             if (*option == '+')
2524               break;
2525             i++;
2526             if (i == (ssize_t) (argc-1))
2527               ThrowConvertException(OptionError,"MissingArgument",option);
2528             if (IsGeometry(argv[i]) == MagickFalse)
2529               ThrowConvertInvalidArgumentException(option,argv[i]);
2530             break;
2531           }
2532         if (LocaleCompare("shear",option+1) == 0)
2533           {
2534             i++;
2535             if (i == (ssize_t) (argc-1))
2536               ThrowConvertException(OptionError,"MissingArgument",option);
2537             if (IsGeometry(argv[i]) == MagickFalse)
2538               ThrowConvertInvalidArgumentException(option,argv[i]);
2539             break;
2540           }
2541         if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
2542           {
2543             i++;
2544             if (i == (ssize_t) (argc-1))
2545               ThrowConvertException(OptionError,"MissingArgument",option);
2546             if (IsGeometry(argv[i]) == MagickFalse)
2547               ThrowConvertInvalidArgumentException(option,argv[i]);
2548             break;
2549           }
2550         if (LocaleCompare("size",option+1) == 0)
2551           {
2552             if (*option == '+')
2553               break;
2554             i++;
2555             if (i == (ssize_t) (argc-1))
2556               ThrowConvertException(OptionError,"MissingArgument",option);
2557             if (IsGeometry(argv[i]) == MagickFalse)
2558               ThrowConvertInvalidArgumentException(option,argv[i]);
2559             break;
2560           }
2561         if (LocaleCompare("sketch",option+1) == 0)
2562           {
2563             if (*option == '+')
2564               break;
2565             i++;
2566             if (i == (ssize_t) (argc-1))
2567               ThrowConvertException(OptionError,"MissingArgument",option);
2568             if (IsGeometry(argv[i]) == MagickFalse)
2569               ThrowConvertInvalidArgumentException(option,argv[i]);
2570             break;
2571           }
2572         if (LocaleCompare("smush",option+1) == 0)
2573           {
2574             i++;
2575             if (i == (ssize_t) (argc-1))
2576               ThrowConvertException(OptionError,"MissingArgument",option);
2577             if (IsGeometry(argv[i]) == MagickFalse)
2578               ThrowConvertInvalidArgumentException(option,argv[i]);
2579             break;
2580           }
2581         if (LocaleCompare("solarize",option+1) == 0)
2582           {
2583             if (*option == '+')
2584               break;
2585             i++;
2586             if (i == (ssize_t) (argc-1))
2587               ThrowConvertException(OptionError,"MissingArgument",option);
2588             if (IsGeometry(argv[i]) == MagickFalse)
2589               ThrowConvertInvalidArgumentException(option,argv[i]);
2590             break;
2591           }
2592         if (LocaleCompare("sparse-color",option+1) == 0)
2593           {
2594             ssize_t
2595               op;
2596
2597             i++;
2598             if (i == (ssize_t) argc)
2599               ThrowConvertException(OptionError,"MissingArgument",option);
2600             op=ParseCommandOption(MagickSparseColorOptions,MagickFalse,argv[i]);
2601             if (op < 0)
2602               ThrowConvertException(OptionError,"UnrecognizedSparseColorMethod",
2603                 argv[i]);
2604             i++;
2605             if (i == (ssize_t) (argc-1))
2606               ThrowConvertException(OptionError,"MissingArgument",option);
2607             break;
2608           }
2609         if (LocaleCompare("splice",option+1) == 0)
2610           {
2611             if (*option == '+')
2612               break;
2613             i++;
2614             if (i == (ssize_t) (argc-1))
2615               ThrowConvertException(OptionError,"MissingArgument",option);
2616             if (IsGeometry(argv[i]) == MagickFalse)
2617               ThrowConvertInvalidArgumentException(option,argv[i]);
2618             break;
2619           }
2620         if (LocaleCompare("spread",option+1) == 0)
2621           {
2622             if (*option == '+')
2623               break;
2624             i++;
2625             if ((i == (ssize_t) (argc-1)) ||
2626                 (IsGeometry(argv[i]) == MagickFalse))
2627               ThrowConvertException(OptionError,"MissingArgument",option);
2628             break;
2629           }
2630         if (LocaleCompare("statistic",option+1) == 0)
2631           {
2632             ssize_t
2633               op;
2634
2635             if (*option == '+')
2636               break;
2637             i++;
2638             if (i == (ssize_t) argc)
2639               ThrowConvertException(OptionError,"MissingArgument",option);
2640             op=ParseCommandOption(MagickStatisticOptions,MagickFalse,argv[i]);
2641             if (op < 0)
2642               ThrowConvertException(OptionError,"UnrecognizedStatisticType",
2643                 argv[i]);
2644             i++;
2645             if (i == (ssize_t) (argc-1))
2646               ThrowConvertException(OptionError,"MissingArgument",option);
2647             if (IsGeometry(argv[i]) == MagickFalse)
2648               ThrowConvertInvalidArgumentException(option,argv[i]);
2649             break;
2650           }
2651         if (LocaleCompare("stretch",option+1) == 0)
2652           {
2653             ssize_t
2654               stretch;
2655
2656             if (*option == '+')
2657               break;
2658             i++;
2659             if (i == (ssize_t) (argc-1))
2660               ThrowConvertException(OptionError,"MissingArgument",option);
2661             stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,
2662               argv[i]);
2663             if (stretch < 0)
2664               ThrowConvertException(OptionError,"UnrecognizedStyleType",
2665                 argv[i]);
2666             break;
2667           }
2668         if (LocaleCompare("strip",option+1) == 0)
2669           break;
2670         if (LocaleCompare("stroke",option+1) == 0)
2671           {
2672             if (*option == '+')
2673               break;
2674             i++;
2675             if (i == (ssize_t) (argc-1))
2676               ThrowConvertException(OptionError,"MissingArgument",option);
2677             break;
2678           }
2679         if (LocaleCompare("strokewidth",option+1) == 0)
2680           {
2681             if (*option == '+')
2682               break;
2683             i++;
2684             if (i == (ssize_t) (argc-1))
2685               ThrowConvertException(OptionError,"MissingArgument",option);
2686             if (IsGeometry(argv[i]) == MagickFalse)
2687               ThrowConvertInvalidArgumentException(option,argv[i]);
2688             break;
2689           }
2690         if (LocaleCompare("style",option+1) == 0)
2691           {
2692             ssize_t
2693               style;
2694
2695             if (*option == '+')
2696               break;
2697             i++;
2698             if (i == (ssize_t) (argc-1))
2699               ThrowConvertException(OptionError,"MissingArgument",option);
2700             style=ParseCommandOption(MagickStyleOptions,MagickFalse,argv[i]);
2701             if (style < 0)
2702               ThrowConvertException(OptionError,"UnrecognizedStyleType",
2703                 argv[i]);
2704             break;
2705           }
2706         if (LocaleCompare("support",option+1) == 0)
2707           {
2708             i++;  /* deprecated */
2709             break;
2710           }
2711         if (LocaleCompare("swap",option+1) == 0)
2712           {
2713             if (*option == '+')
2714               break;
2715             i++;
2716             if (i == (ssize_t) (argc-1))
2717               ThrowConvertException(OptionError,"MissingArgument",option);
2718             if (IsGeometry(argv[i]) == MagickFalse)
2719               ThrowConvertInvalidArgumentException(option,argv[i]);
2720             break;
2721           }
2722         if (LocaleCompare("swirl",option+1) == 0)
2723           {
2724             if (*option == '+')
2725               break;
2726             i++;
2727             if (i == (ssize_t) (argc-1))
2728               ThrowConvertException(OptionError,"MissingArgument",option);
2729             if (IsGeometry(argv[i]) == MagickFalse)
2730               ThrowConvertInvalidArgumentException(option,argv[i]);
2731             break;
2732           }
2733         if (LocaleCompare("synchronize",option+1) == 0)
2734           break;
2735         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2736       }
2737       case 't':
2738       {
2739         if (LocaleCompare("taint",option+1) == 0)
2740           break;
2741         if (LocaleCompare("texture",option+1) == 0)
2742           {
2743             if (*option == '+')
2744               break;
2745             i++;
2746             if (i == (ssize_t) (argc-1))
2747               ThrowConvertException(OptionError,"MissingArgument",option);
2748             break;
2749           }
2750         if (LocaleCompare("thumbnail",option+1) == 0)
2751           {
2752             if (*option == '+')
2753               break;
2754             i++;
2755             if (i == (ssize_t) (argc-1))
2756               ThrowConvertException(OptionError,"MissingArgument",option);
2757             if (IsGeometry(argv[i]) == MagickFalse)
2758               ThrowConvertInvalidArgumentException(option,argv[i]);
2759             break;
2760           }
2761         if (LocaleCompare("threshold",option+1) == 0)
2762           {
2763             if (*option == '+')
2764               break;
2765             i++;
2766             if (i == (ssize_t) (argc-1))
2767               ThrowConvertException(OptionError,"MissingArgument",option);
2768             if (IsGeometry(argv[i]) == MagickFalse)
2769               ThrowConvertInvalidArgumentException(option,argv[i]);
2770             break;
2771           }
2772         if (LocaleCompare("tile",option+1) == 0)
2773           {
2774             if (*option == '+')
2775               break;
2776             i++;
2777             if (i == (ssize_t) (argc-1))
2778               ThrowConvertException(OptionError,"MissingArgument",option);
2779             break;
2780           }
2781         if (LocaleCompare("tile-offset",option+1) == 0)
2782           {
2783             if (*option == '+')
2784               break;
2785             i++;
2786             if (i == (ssize_t) (argc-1))
2787               ThrowConvertException(OptionError,"MissingArgument",option);
2788             if (IsGeometry(argv[i]) == MagickFalse)
2789               ThrowConvertInvalidArgumentException(option,argv[i]);
2790             break;
2791           }
2792         if (LocaleCompare("tint",option+1) == 0)
2793           {
2794             if (*option == '+')
2795               break;
2796             i++;
2797             if (i == (ssize_t) (argc-1))
2798               ThrowConvertException(OptionError,"MissingArgument",option);
2799             if (IsGeometry(argv[i]) == MagickFalse)
2800               ThrowConvertInvalidArgumentException(option,argv[i]);
2801             break;
2802           }
2803         if (LocaleCompare("transform",option+1) == 0)
2804           break;
2805         if (LocaleCompare("transparent",option+1) == 0)
2806           {
2807             i++;
2808             if (i == (ssize_t) (argc-1))
2809               ThrowConvertException(OptionError,"MissingArgument",option);
2810             break;
2811           }
2812         if (LocaleCompare("transparent-color",option+1) == 0)
2813           {
2814             if (*option == '+')
2815               break;
2816             i++;
2817             if (i == (ssize_t) (argc-1))
2818               ThrowConvertException(OptionError,"MissingArgument",option);
2819             break;
2820           }
2821         if (LocaleCompare("transpose",option+1) == 0)
2822           break;
2823         if (LocaleCompare("transverse",option+1) == 0)
2824           break;
2825         if (LocaleCompare("treedepth",option+1) == 0)
2826           {
2827             if (*option == '+')
2828               break;
2829             i++;
2830             if (i == (ssize_t) (argc-1))
2831               ThrowConvertException(OptionError,"MissingArgument",option);
2832             if (IsGeometry(argv[i]) == MagickFalse)
2833               ThrowConvertInvalidArgumentException(option,argv[i]);
2834             break;
2835           }
2836         if (LocaleCompare("trim",option+1) == 0)
2837           break;
2838         if (LocaleCompare("type",option+1) == 0)
2839           {
2840             ssize_t
2841               type;
2842
2843             if (*option == '+')
2844               break;
2845             i++;
2846             if (i == (ssize_t) (argc-1))
2847               ThrowConvertException(OptionError,"MissingArgument",option);
2848             type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
2849             if (type < 0)
2850               ThrowConvertException(OptionError,"UnrecognizedImageType",
2851                 argv[i]);
2852             break;
2853           }
2854         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2855       }
2856       case 'u':
2857       {
2858         if (LocaleCompare("undercolor",option+1) == 0)
2859           {
2860             if (*option == '+')
2861               break;
2862             i++;
2863             if (i == (ssize_t) (argc-1))
2864               ThrowConvertException(OptionError,"MissingArgument",option);
2865             break;
2866           }
2867         if (LocaleCompare("unique-colors",option+1) == 0)
2868           break;
2869         if (LocaleCompare("units",option+1) == 0)
2870           {
2871             ssize_t
2872               units;
2873
2874             if (*option == '+')
2875               break;
2876             i++;
2877             if (i == (ssize_t) (argc-1))
2878               ThrowConvertException(OptionError,"MissingArgument",option);
2879             units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
2880               argv[i]);
2881             if (units < 0)
2882               ThrowConvertException(OptionError,"UnrecognizedUnitsType",
2883                 argv[i]);
2884             break;
2885           }
2886         if (LocaleCompare("unsharp",option+1) == 0)
2887           {
2888             if (*option == '+')
2889               break;
2890             i++;
2891             if (i == (ssize_t) (argc-1))
2892               ThrowConvertException(OptionError,"MissingArgument",option);
2893             if (IsGeometry(argv[i]) == MagickFalse)
2894               ThrowConvertInvalidArgumentException(option,argv[i]);
2895             break;
2896           }
2897         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2898       }
2899       case 'v':
2900       {
2901         if (LocaleCompare("verbose",option+1) == 0)
2902           break;
2903         if ((LocaleCompare("version",option+1) == 0) ||
2904             (LocaleCompare("-version",option+1) == 0))
2905           {
2906             (void) FormatLocaleFile(stdout,"Version: %s\n",
2907               GetMagickVersion((size_t *) NULL));
2908             (void) FormatLocaleFile(stdout,"Copyright: %s\n",
2909               GetMagickCopyright());
2910             (void) FormatLocaleFile(stdout,"Features: %s\n\n",
2911               GetMagickFeatures());
2912             break;
2913           }
2914         if (LocaleCompare("view",option+1) == 0)
2915           {
2916             if (*option == '+')
2917               break;
2918             i++;
2919             if (i == (ssize_t) (argc-1))
2920               ThrowConvertException(OptionError,"MissingArgument",option);
2921             break;
2922           }
2923         if (LocaleCompare("vignette",option+1) == 0)
2924           {
2925             if (*option == '+')
2926               break;
2927             i++;
2928             if (i == (ssize_t) (argc-1))
2929               ThrowConvertException(OptionError,"MissingArgument",option);
2930             if (IsGeometry(argv[i]) == MagickFalse)
2931               ThrowConvertInvalidArgumentException(option,argv[i]);
2932             break;
2933           }
2934         if (LocaleCompare("virtual-pixel",option+1) == 0)
2935           {
2936             ssize_t
2937               method;
2938
2939             if (*option == '+')
2940               break;
2941             i++;
2942             if (i == (ssize_t) (argc-1))
2943               ThrowConvertException(OptionError,"MissingArgument",option);
2944             method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
2945               argv[i]);
2946             if (method < 0)
2947               ThrowConvertException(OptionError,
2948                 "UnrecognizedVirtualPixelMethod",argv[i]);
2949             break;
2950           }
2951         ThrowConvertException(OptionError,"UnrecognizedOption",option)
2952       }
2953       case 'w':
2954       {
2955         if (LocaleCompare("wave",option+1) == 0)
2956           {
2957             i++;
2958             if (i == (ssize_t) (argc-1))
2959               ThrowConvertException(OptionError,"MissingArgument",option);
2960             if (IsGeometry(argv[i]) == MagickFalse)
2961               ThrowConvertInvalidArgumentException(option,argv[i]);
2962             break;
2963           }
2964         if (LocaleCompare("weight",option+1) == 0)
2965           {
2966             if (*option == '+')
2967               break;
2968             i++;
2969             if (i == (ssize_t) (argc-1))
2970               ThrowConvertException(OptionError,"MissingArgument",option);
2971             break;
2972           }
2973         if (LocaleCompare("white-point",option+1) == 0)
2974           {
2975             if (*option == '+')
2976               break;
2977             i++;
2978             if (i == (ssize_t) (argc-1))
2979               ThrowConvertException(OptionError,"MissingArgument",option);
2980             if (IsGeometry(argv[i]) == MagickFalse)
2981               ThrowConvertInvalidArgumentException(option,argv[i]);
2982             break;
2983           }
2984         if (LocaleCompare("white-threshold",option+1) == 0)
2985           {
2986             if (*option == '+')
2987               break;
2988             i++;
2989             if (i == (ssize_t) (argc-1))
2990               ThrowConvertException(OptionError,"MissingArgument",option);
2991             if (IsGeometry(argv[i]) == MagickFalse)
2992               ThrowConvertInvalidArgumentException(option,argv[i]);
2993             break;
2994           }
2995         if (LocaleCompare("write",option+1) == 0)
2996           {
2997             i++;
2998             if (i == (ssize_t) (argc-1))
2999               ThrowConvertException(OptionError,"MissingArgument",option);
3000             break;
3001           }
3002         ThrowConvertException(OptionError,"UnrecognizedOption",option)
3003       }
3004       case '?':
3005         break;
3006       default:
3007         ThrowConvertException(OptionError,"UnrecognizedOption",option)
3008     }
3009     fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
3010       FireOptionFlag) == 0 ?  MagickFalse : MagickTrue;
3011     if (fire != MagickFalse)
3012       FireImageStack(MagickTrue,MagickTrue,MagickTrue);
3013   }
3014   if (k != 0)
3015     ThrowConvertException(OptionError,"UnbalancedParenthesis",argv[i]);
3016   if (i-- != (ssize_t) (argc-1))
3017     ThrowConvertException(OptionError,"MissingAnImageFilename",argv[argc-1]);
3018   if (image == (Image *) NULL)
3019     ThrowConvertException(OptionError,"MissingAnImageFilename",argv[argc-1]);
3020   FinalizeImageSettings(image_info,image,MagickTrue);
3021   if (image == (Image *) NULL)
3022     ThrowConvertException(OptionError,"MissingAnImageFilename",argv[argc-1]);
3023   status&=WriteImages(image_info,image,argv[argc-1],exception);
3024   if (metadata != (char **) NULL)
3025     {
3026       char
3027         *text;
3028
3029       text=InterpretImageProperties(image_info,image,format,exception);
3030       if (text == (char *) NULL)
3031         ThrowConvertException(ResourceLimitError,"MemoryAllocationFailed",
3032           GetExceptionMessage(errno));
3033       (void) ConcatenateString(&(*metadata),text);
3034       text=DestroyString(text);
3035     }
3036   DestroyConvert();
3037   return(status != 0 ? MagickTrue : MagickFalse);
3038 }