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