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

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