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

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