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