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