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