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