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

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