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