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