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