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