root/ImageMagick/trunk/wand/convert.c

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