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