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

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