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