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