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

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