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