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

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