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