MagickWand  6.9.12-67
Convert, Edit, Or Compose Bitmap Images
 All Data Structures
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-2021 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;
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  return(ConvertUsage());
545  filename=(char *) NULL;
546  format="%w,%h,%m";
547  j=1;
548  k=0;
549  NewImageStack();
550  option=(char *) NULL;
551  pend=MagickFalse;
552  respect_parenthesis=MagickFalse;
553  status=MagickTrue;
554  /*
555  Parse command-line arguments.
556  */
557  ReadCommandlLine(argc,&argv);
558  status=ExpandFilenames(&argc,&argv);
559  if (status == MagickFalse)
560  ThrowConvertException(ResourceLimitError,"MemoryAllocationFailed",
561  GetExceptionMessage(errno));
562  if ((argc > 2) && (LocaleCompare("-concatenate",argv[1]) == 0))
563  return(ConcatenateImages(argc,argv,exception));
564  for (i=1; i < (ssize_t) (argc-1); i++)
565  {
566  option=argv[i];
567  if (LocaleCompare(option,"(") == 0)
568  {
569  FireImageStack(MagickTrue,MagickTrue,pend);
570  if (k == MaxImageStackDepth)
571  ThrowConvertException(OptionError,"ParenthesisNestedTooDeeply",
572  option);
573  PushImageStack();
574  continue;
575  }
576  if (LocaleCompare(option,")") == 0)
577  {
578  FireImageStack(MagickTrue,MagickTrue,MagickTrue);
579  if (k == 0)
580  ThrowConvertException(OptionError,"UnableToParseExpression",option);
581  PopImageStack();
582  continue;
583  }
584  if (IsCommandOption(option) == MagickFalse)
585  {
586  Image
587  *images;
588 
589  /*
590  Read input image.
591  */
592  FireImageStack(MagickTrue,MagickTrue,pend);
593  filename=argv[i];
594  if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
595  filename=argv[++i];
596  (void) SetImageOption(image_info,"filename",filename);
597  (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
598  if (image_info->ping != MagickFalse)
599  images=PingImages(image_info,exception);
600  else
601  images=ReadImages(image_info,exception);
602  status&=(images != (Image *) NULL) &&
603  (exception->severity < ErrorException);
604  if (images == (Image *) NULL)
605  continue;
606  AppendImageStack(images);
607  continue;
608  }
609  pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
610  switch (*(option+1))
611  {
612  case 'a':
613  {
614  if (LocaleCompare("adaptive-blur",option+1) == 0)
615  {
616  i++;
617  if (i == (ssize_t) argc)
618  ThrowConvertException(OptionError,"MissingArgument",option);
619  if (IsGeometry(argv[i]) == MagickFalse)
620  ThrowConvertInvalidArgumentException(option,argv[i]);
621  break;
622  }
623  if (LocaleCompare("adaptive-resize",option+1) == 0)
624  {
625  i++;
626  if (i == (ssize_t) argc)
627  ThrowConvertException(OptionError,"MissingArgument",option);
628  if (IsGeometry(argv[i]) == MagickFalse)
629  ThrowConvertInvalidArgumentException(option,argv[i]);
630  break;
631  }
632  if (LocaleCompare("adaptive-sharpen",option+1) == 0)
633  {
634  i++;
635  if (i == (ssize_t) argc)
636  ThrowConvertException(OptionError,"MissingArgument",option);
637  if (IsGeometry(argv[i]) == MagickFalse)
638  ThrowConvertInvalidArgumentException(option,argv[i]);
639  break;
640  }
641  if (LocaleCompare("adjoin",option+1) == 0)
642  break;
643  if (LocaleCompare("affine",option+1) == 0)
644  {
645  if (*option == '+')
646  break;
647  i++;
648  if (i == (ssize_t) argc)
649  ThrowConvertException(OptionError,"MissingArgument",option);
650  if (IsGeometry(argv[i]) == MagickFalse)
651  ThrowConvertInvalidArgumentException(option,argv[i]);
652  break;
653  }
654  if (LocaleCompare("alpha",option+1) == 0)
655  {
656  ssize_t
657  type;
658 
659  if (*option == '+')
660  break;
661  i++;
662  if (i == (ssize_t) argc)
663  ThrowConvertException(OptionError,"MissingArgument",option);
664  type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
665  if (type < 0)
666  ThrowConvertException(OptionError,"UnrecognizedAlphaChannelType",
667  argv[i]);
668  break;
669  }
670  if (LocaleCompare("annotate",option+1) == 0)
671  {
672  if (*option == '+')
673  break;
674  i++;
675  if (i == (ssize_t) argc)
676  ThrowConvertException(OptionError,"MissingArgument",option);
677  if (IsGeometry(argv[i]) == MagickFalse)
678  ThrowConvertInvalidArgumentException(option,argv[i]);
679  i++;
680  if (i == (ssize_t) argc)
681  ThrowConvertException(OptionError,"MissingArgument",option);
682  break;
683  }
684  if (LocaleCompare("antialias",option+1) == 0)
685  break;
686  if (LocaleCompare("append",option+1) == 0)
687  break;
688  if (LocaleCompare("attenuate",option+1) == 0)
689  {
690  if (*option == '+')
691  break;
692  i++;
693  if (i == (ssize_t) argc)
694  ThrowConvertException(OptionError,"MissingArgument",option);
695  if (IsGeometry(argv[i]) == MagickFalse)
696  ThrowConvertInvalidArgumentException(option,argv[i]);
697  break;
698  }
699  if (LocaleCompare("authenticate",option+1) == 0)
700  {
701  if (*option == '+')
702  break;
703  i++;
704  if (i == (ssize_t) argc)
705  ThrowConvertException(OptionError,"MissingArgument",option);
706  break;
707  }
708  if (LocaleCompare("auto-gamma",option+1) == 0)
709  break;
710  if (LocaleCompare("auto-level",option+1) == 0)
711  break;
712  if (LocaleCompare("auto-orient",option+1) == 0)
713  break;
714  if (LocaleCompare("average",option+1) == 0)
715  break;
716  ThrowConvertException(OptionError,"UnrecognizedOption",option)
717  }
718  case 'b':
719  {
720  if (LocaleCompare("background",option+1) == 0)
721  {
722  if (*option == '+')
723  break;
724  i++;
725  if (i == (ssize_t) argc)
726  ThrowConvertException(OptionError,"MissingArgument",option);
727  break;
728  }
729  if (LocaleCompare("bench",option+1) == 0)
730  {
731  if (*option == '+')
732  break;
733  i++;
734  if (i == (ssize_t) argc)
735  ThrowConvertException(OptionError,"MissingArgument",option);
736  if (IsGeometry(argv[i]) == MagickFalse)
737  ThrowConvertInvalidArgumentException(option,argv[i]);
738  break;
739  }
740  if (LocaleCompare("bias",option+1) == 0)
741  {
742  if (*option == '+')
743  break;
744  i++;
745  if (i == (ssize_t) argc)
746  ThrowConvertException(OptionError,"MissingArgument",option);
747  if (IsGeometry(argv[i]) == MagickFalse)
748  ThrowConvertInvalidArgumentException(option,argv[i]);
749  break;
750  }
751  if (LocaleCompare("black-point-compensation",option+1) == 0)
752  break;
753  if (LocaleCompare("black-threshold",option+1) == 0)
754  {
755  if (*option == '+')
756  break;
757  i++;
758  if (i == (ssize_t) argc)
759  ThrowConvertException(OptionError,"MissingArgument",option);
760  if (IsGeometry(argv[i]) == MagickFalse)
761  ThrowConvertInvalidArgumentException(option,argv[i]);
762  break;
763  }
764  if (LocaleCompare("blue-primary",option+1) == 0)
765  {
766  if (*option == '+')
767  break;
768  i++;
769  if (i == (ssize_t) argc)
770  ThrowConvertException(OptionError,"MissingArgument",option);
771  if (IsGeometry(argv[i]) == MagickFalse)
772  ThrowConvertInvalidArgumentException(option,argv[i]);
773  break;
774  }
775  if (LocaleCompare("blue-shift",option+1) == 0)
776  {
777  if (*option == '+')
778  break;
779  i++;
780  if (i == (ssize_t) argc)
781  ThrowConvertException(OptionError,"MissingArgument",option);
782  if (IsGeometry(argv[i]) == MagickFalse)
783  ThrowConvertInvalidArgumentException(option,argv[i]);
784  break;
785  }
786  if (LocaleCompare("blur",option+1) == 0)
787  {
788  if (*option == '+')
789  break;
790  i++;
791  if (i == (ssize_t) argc)
792  ThrowConvertException(OptionError,"MissingArgument",option);
793  if (IsGeometry(argv[i]) == MagickFalse)
794  ThrowConvertInvalidArgumentException(option,argv[i]);
795  break;
796  }
797  if (LocaleCompare("border",option+1) == 0)
798  {
799  if (*option == '+')
800  break;
801  i++;
802  if (i == (ssize_t) argc)
803  ThrowConvertException(OptionError,"MissingArgument",option);
804  if (IsGeometry(argv[i]) == MagickFalse)
805  ThrowConvertInvalidArgumentException(option,argv[i]);
806  break;
807  }
808  if (LocaleCompare("bordercolor",option+1) == 0)
809  {
810  if (*option == '+')
811  break;
812  i++;
813  if (i == (ssize_t) argc)
814  ThrowConvertException(OptionError,"MissingArgument",option);
815  break;
816  }
817  if (LocaleCompare("box",option+1) == 0)
818  {
819  if (*option == '+')
820  break;
821  i++;
822  if (i == (ssize_t) argc)
823  ThrowConvertException(OptionError,"MissingArgument",option);
824  break;
825  }
826  if (LocaleCompare("brightness-contrast",option+1) == 0)
827  {
828  i++;
829  if (i == (ssize_t) argc)
830  ThrowConvertException(OptionError,"MissingArgument",option);
831  if (IsGeometry(argv[i]) == MagickFalse)
832  ThrowConvertInvalidArgumentException(option,argv[i]);
833  break;
834  }
835  ThrowConvertException(OptionError,"UnrecognizedOption",option)
836  }
837  case 'c':
838  {
839  if (LocaleCompare("cache",option+1) == 0)
840  {
841  if (*option == '+')
842  break;
843  i++;
844  if (i == (ssize_t) argc)
845  ThrowConvertException(OptionError,"MissingArgument",option);
846  if (IsGeometry(argv[i]) == MagickFalse)
847  ThrowConvertInvalidArgumentException(option,argv[i]);
848  break;
849  }
850  if (LocaleCompare("canny",option+1) == 0)
851  {
852  if (*option == '+')
853  break;
854  i++;
855  if (i == (ssize_t) argc)
856  ThrowConvertException(OptionError,"MissingArgument",option);
857  if (IsGeometry(argv[i]) == MagickFalse)
858  ThrowConvertInvalidArgumentException(option,argv[i]);
859  break;
860  }
861  if (LocaleCompare("caption",option+1) == 0)
862  {
863  if (*option == '+')
864  break;
865  i++;
866  if (i == (ssize_t) argc)
867  ThrowConvertException(OptionError,"MissingArgument",option);
868  break;
869  }
870  if (LocaleCompare("cdl",option+1) == 0)
871  {
872  if (*option == '+')
873  break;
874  i++;
875  if (i == (ssize_t) argc)
876  ThrowConvertException(OptionError,"MissingArgument",option);
877  break;
878  }
879  if (LocaleCompare("channel",option+1) == 0)
880  {
881  ssize_t
882  channel;
883 
884  if (*option == '+')
885  break;
886  i++;
887  if (i == (ssize_t) argc)
888  ThrowConvertException(OptionError,"MissingArgument",option);
889  channel=ParseChannelOption(argv[i]);
890  if (channel < 0)
891  ThrowConvertException(OptionError,"UnrecognizedChannelType",
892  argv[i]);
893  break;
894  }
895  if (LocaleCompare("charcoal",option+1) == 0)
896  {
897  if (*option == '+')
898  break;
899  i++;
900  if (i == (ssize_t) argc)
901  ThrowConvertException(OptionError,"MissingArgument",option);
902  if (IsGeometry(argv[i]) == MagickFalse)
903  ThrowConvertInvalidArgumentException(option,argv[i]);
904  break;
905  }
906  if (LocaleCompare("chop",option+1) == 0)
907  {
908  if (*option == '+')
909  break;
910  i++;
911  if (i == (ssize_t) argc)
912  ThrowConvertException(OptionError,"MissingArgument",option);
913  if (IsGeometry(argv[i]) == MagickFalse)
914  ThrowConvertInvalidArgumentException(option,argv[i]);
915  break;
916  }
917  if (LocaleCompare("clamp",option+1) == 0)
918  break;
919  if (LocaleCompare("clip",option+1) == 0)
920  break;
921  if (LocaleCompare("clip-mask",option+1) == 0)
922  {
923  if (*option == '+')
924  break;
925  i++;
926  if (i == (ssize_t) argc)
927  ThrowConvertException(OptionError,"MissingArgument",option);
928  break;
929  }
930  if (LocaleCompare("clip-path",option+1) == 0)
931  {
932  i++;
933  if (i == (ssize_t) argc)
934  ThrowConvertException(OptionError,"MissingArgument",option);
935  break;
936  }
937  if (LocaleCompare("clone",option+1) == 0)
938  {
939  Image
940  *clone_images,
941  *clone_list;
942 
943  if (k == 0)
944  clone_list=CloneImageList(image,exception);
945  else
946  clone_list=CloneImageList(image_stack[k-1].image,exception);
947  if (clone_list == (Image *) NULL)
948  ThrowConvertException(ImageError,"ImageSequenceRequired",option);
949  FireImageStack(MagickTrue,MagickTrue,MagickTrue);
950  if (*option == '+')
951  clone_images=CloneImages(clone_list,"-1",exception);
952  else
953  {
954  i++;
955  if (i == (ssize_t) argc)
956  ThrowConvertException(OptionError,"MissingArgument",option);
957  if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
958  ThrowConvertInvalidArgumentException(option,argv[i]);
959  clone_images=CloneImages(clone_list,argv[i],exception);
960  }
961  if (clone_images == (Image *) NULL)
962  ThrowConvertException(OptionError,"NoSuchImage",option);
963  AppendImageStack(clone_images);
964  clone_list=DestroyImageList(clone_list);
965  break;
966  }
967  if (LocaleCompare("clut",option+1) == 0)
968  break;
969  if (LocaleCompare("coalesce",option+1) == 0)
970  break;
971  if (LocaleCompare("colorize",option+1) == 0)
972  {
973  if (*option == '+')
974  break;
975  i++;
976  if (i == (ssize_t) argc)
977  ThrowConvertException(OptionError,"MissingArgument",option);
978  if (IsGeometry(argv[i]) == MagickFalse)
979  ThrowConvertInvalidArgumentException(option,argv[i]);
980  break;
981  }
982  if (LocaleCompare("color-matrix",option+1) == 0)
983  {
984  KernelInfo
985  *kernel_info;
986 
987  if (*option == '+')
988  break;
989  i++;
990  if (i == (ssize_t) argc)
991  ThrowConvertException(OptionError,"MissingArgument",option);
992  kernel_info=AcquireKernelInfo(argv[i]);
993  if (kernel_info == (KernelInfo *) NULL)
994  ThrowConvertInvalidArgumentException(option,argv[i]);
995  kernel_info=DestroyKernelInfo(kernel_info);
996  break;
997  }
998  if (LocaleCompare("colors",option+1) == 0)
999  {
1000  if (*option == '+')
1001  break;
1002  i++;
1003  if ((i == (ssize_t) argc) ||
1004  (IsGeometry(argv[i]) == MagickFalse))
1005  ThrowConvertException(OptionError,"MissingArgument",option);
1006  break;
1007  }
1008  if (LocaleCompare("colorspace",option+1) == 0)
1009  {
1010  ssize_t
1011  colorspace;
1012 
1013  if (*option == '+')
1014  break;
1015  i++;
1016  if (i == (ssize_t) argc)
1017  ThrowConvertException(OptionError,"MissingArgument",option);
1018  colorspace=ParseCommandOption(MagickColorspaceOptions,
1019  MagickFalse,argv[i]);
1020  if (colorspace < 0)
1021  ThrowConvertException(OptionError,"UnrecognizedColorspace",
1022  argv[i]);
1023  break;
1024  }
1025  if (LocaleCompare("combine",option+1) == 0)
1026  break;
1027  if (LocaleCompare("comment",option+1) == 0)
1028  {
1029  if (*option == '+')
1030  break;
1031  i++;
1032  if (i == (ssize_t) argc)
1033  ThrowConvertException(OptionError,"MissingArgument",option);
1034  break;
1035  }
1036  if (LocaleCompare("compare",option+1) == 0)
1037  break;
1038  if (LocaleCompare("complex",option+1) == 0)
1039  {
1040  ssize_t
1041  op;
1042 
1043  if (*option == '+')
1044  break;
1045  i++;
1046  if (i == (ssize_t) argc)
1047  ThrowConvertException(OptionError,"MissingArgument",option);
1048  op=ParseCommandOption(MagickComplexOptions,MagickFalse,argv[i]);
1049  if (op < 0)
1050  ThrowConvertException(OptionError,"UnrecognizedComplexOperator",
1051  argv[i]);
1052  break;
1053  }
1054  if (LocaleCompare("compose",option+1) == 0)
1055  {
1056  ssize_t
1057  compose;
1058 
1059  if (*option == '+')
1060  break;
1061  i++;
1062  if (i == (ssize_t) argc)
1063  ThrowConvertException(OptionError,"MissingArgument",option);
1064  compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
1065  argv[i]);
1066  if (compose < 0)
1067  ThrowConvertException(OptionError,"UnrecognizedComposeOperator",
1068  argv[i]);
1069  break;
1070  }
1071  if (LocaleCompare("composite",option+1) == 0)
1072  break;
1073  if (LocaleCompare("compress",option+1) == 0)
1074  {
1075  ssize_t
1076  compress;
1077 
1078  if (*option == '+')
1079  break;
1080  i++;
1081  if (i == (ssize_t) argc)
1082  ThrowConvertException(OptionError,"MissingArgument",option);
1083  compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
1084  argv[i]);
1085  if (compress < 0)
1086  ThrowConvertException(OptionError,"UnrecognizedImageCompression",
1087  argv[i]);
1088  break;
1089  }
1090  if (LocaleCompare("concurrent",option+1) == 0)
1091  break;
1092  if (LocaleCompare("connected-components",option+1) == 0)
1093  {
1094  i++;
1095  if (i == (ssize_t) argc)
1096  ThrowConvertException(OptionError,"MissingArgument",option);
1097  if (IsGeometry(argv[i]) == MagickFalse)
1098  ThrowConvertInvalidArgumentException(option,argv[i]);
1099  break;
1100  }
1101  if (LocaleCompare("contrast",option+1) == 0)
1102  break;
1103  if (LocaleCompare("contrast-stretch",option+1) == 0)
1104  {
1105  i++;
1106  if (i == (ssize_t) argc)
1107  ThrowConvertException(OptionError,"MissingArgument",option);
1108  if (IsGeometry(argv[i]) == MagickFalse)
1109  ThrowConvertInvalidArgumentException(option,argv[i]);
1110  break;
1111  }
1112  if (LocaleCompare("convolve",option+1) == 0)
1113  {
1114  KernelInfo
1115  *kernel_info;
1116 
1117  if (*option == '+')
1118  break;
1119  i++;
1120  if (i == (ssize_t) argc)
1121  ThrowConvertException(OptionError,"MissingArgument",option);
1122  kernel_info=AcquireKernelInfo(argv[i]);
1123  if (kernel_info == (KernelInfo *) NULL)
1124  ThrowConvertInvalidArgumentException(option,argv[i]);
1125  kernel_info=DestroyKernelInfo(kernel_info);
1126  break;
1127  }
1128  if (LocaleCompare("copy",option+1) == 0)
1129  {
1130  if (*option == '+')
1131  break;
1132  i++;
1133  if (i == (ssize_t) argc)
1134  ThrowConvertException(OptionError,"MissingArgument",option);
1135  if (IsGeometry(argv[i]) == MagickFalse)
1136  ThrowConvertInvalidArgumentException(option,argv[i]);
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  break;
1143  }
1144  if (LocaleCompare("crop",option+1) == 0)
1145  {
1146  if (*option == '+')
1147  break;
1148  i++;
1149  if (i == (ssize_t) argc)
1150  ThrowConvertException(OptionError,"MissingArgument",option);
1151  if (IsGeometry(argv[i]) == MagickFalse)
1152  ThrowConvertInvalidArgumentException(option,argv[i]);
1153  break;
1154  }
1155  if (LocaleCompare("cycle",option+1) == 0)
1156  {
1157  if (*option == '+')
1158  break;
1159  i++;
1160  if (i == (ssize_t) argc)
1161  ThrowConvertException(OptionError,"MissingArgument",option);
1162  if (IsGeometry(argv[i]) == MagickFalse)
1163  ThrowConvertInvalidArgumentException(option,argv[i]);
1164  break;
1165  }
1166  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1167  }
1168  case 'd':
1169  {
1170  if (LocaleCompare("decipher",option+1) == 0)
1171  {
1172  if (*option == '+')
1173  break;
1174  i++;
1175  if (i == (ssize_t) argc)
1176  ThrowConvertException(OptionError,"MissingArgument",option);
1177  break;
1178  }
1179  if (LocaleCompare("deconstruct",option+1) == 0)
1180  break;
1181  if (LocaleCompare("debug",option+1) == 0)
1182  {
1183  ssize_t
1184  event;
1185 
1186  if (*option == '+')
1187  break;
1188  i++;
1189  if (i == (ssize_t) argc)
1190  ThrowConvertException(OptionError,"MissingArgument",option);
1191  event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
1192  if (event < 0)
1193  ThrowConvertException(OptionError,"UnrecognizedEventType",
1194  argv[i]);
1195  (void) SetLogEventMask(argv[i]);
1196  break;
1197  }
1198  if (LocaleCompare("define",option+1) == 0)
1199  {
1200  i++;
1201  if (i == (ssize_t) argc)
1202  ThrowConvertException(OptionError,"MissingArgument",option);
1203  if (*option == '+')
1204  {
1205  const char
1206  *define;
1207 
1208  define=GetImageOption(image_info,argv[i]);
1209  if (define == (const char *) NULL)
1210  ThrowConvertException(OptionError,"NoSuchOption",argv[i]);
1211  break;
1212  }
1213  break;
1214  }
1215  if (LocaleCompare("delay",option+1) == 0)
1216  {
1217  if (*option == '+')
1218  break;
1219  i++;
1220  if (i == (ssize_t) argc)
1221  ThrowConvertException(OptionError,"MissingArgument",option);
1222  if (IsGeometry(argv[i]) == MagickFalse)
1223  ThrowConvertInvalidArgumentException(option,argv[i]);
1224  break;
1225  }
1226  if (LocaleCompare("delete",option+1) == 0)
1227  {
1228  if (*option == '+')
1229  break;
1230  i++;
1231  if (i == (ssize_t) argc)
1232  ThrowConvertException(OptionError,"MissingArgument",option);
1233  if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
1234  ThrowConvertInvalidArgumentException(option,argv[i]);
1235  break;
1236  }
1237  if (LocaleCompare("density",option+1) == 0)
1238  {
1239  if (*option == '+')
1240  break;
1241  i++;
1242  if (i == (ssize_t) argc)
1243  ThrowConvertException(OptionError,"MissingArgument",option);
1244  if (IsGeometry(argv[i]) == MagickFalse)
1245  ThrowConvertInvalidArgumentException(option,argv[i]);
1246  break;
1247  }
1248  if (LocaleCompare("depth",option+1) == 0)
1249  {
1250  if (*option == '+')
1251  break;
1252  i++;
1253  if (i == (ssize_t) argc)
1254  ThrowConvertException(OptionError,"MissingArgument",option);
1255  if (IsGeometry(argv[i]) == MagickFalse)
1256  ThrowConvertInvalidArgumentException(option,argv[i]);
1257  break;
1258  }
1259  if (LocaleCompare("deskew",option+1) == 0)
1260  {
1261  if (*option == '+')
1262  break;
1263  i++;
1264  if (i == (ssize_t) argc)
1265  ThrowConvertException(OptionError,"MissingArgument",option);
1266  if (IsGeometry(argv[i]) == MagickFalse)
1267  ThrowConvertInvalidArgumentException(option,argv[i]);
1268  break;
1269  }
1270  if (LocaleCompare("despeckle",option+1) == 0)
1271  break;
1272  if (LocaleCompare("direction",option+1) == 0)
1273  {
1274  ssize_t
1275  direction;
1276 
1277  if (*option == '+')
1278  break;
1279  i++;
1280  if (i == (ssize_t) argc)
1281  ThrowConvertException(OptionError,"MissingArgument",option);
1282  direction=ParseCommandOption(MagickDirectionOptions,MagickFalse,
1283  argv[i]);
1284  if (direction < 0)
1285  ThrowConvertException(OptionError,"UnrecognizedDirectionType",
1286  argv[i]);
1287  break;
1288  }
1289  if (LocaleCompare("display",option+1) == 0)
1290  {
1291  if (*option == '+')
1292  break;
1293  i++;
1294  if (i == (ssize_t) argc)
1295  ThrowConvertException(OptionError,"MissingArgument",option);
1296  break;
1297  }
1298  if (LocaleCompare("dispose",option+1) == 0)
1299  {
1300  ssize_t
1301  dispose;
1302 
1303  if (*option == '+')
1304  break;
1305  i++;
1306  if (i == (ssize_t) argc)
1307  ThrowConvertException(OptionError,"MissingArgument",option);
1308  dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,argv[i]);
1309  if (dispose < 0)
1310  ThrowConvertException(OptionError,"UnrecognizedDisposeMethod",
1311  argv[i]);
1312  break;
1313  }
1314  if (LocaleCompare("distort",option+1) == 0)
1315  {
1316  ssize_t
1317  op;
1318 
1319  i++;
1320  if (i == (ssize_t) argc)
1321  ThrowConvertException(OptionError,"MissingArgument",option);
1322  op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
1323  if (op < 0)
1324  ThrowConvertException(OptionError,"UnrecognizedDistortMethod",
1325  argv[i]);
1326  i++;
1327  if (i == (ssize_t) argc)
1328  ThrowConvertException(OptionError,"MissingArgument",option);
1329  break;
1330  }
1331  if (LocaleCompare("dither",option+1) == 0)
1332  {
1333  ssize_t
1334  method;
1335 
1336  if (*option == '+')
1337  break;
1338  i++;
1339  if (i == (ssize_t) argc)
1340  ThrowConvertException(OptionError,"MissingArgument",option);
1341  method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]);
1342  if (method < 0)
1343  ThrowConvertException(OptionError,"UnrecognizedDitherMethod",
1344  argv[i]);
1345  break;
1346  }
1347  if (LocaleCompare("draw",option+1) == 0)
1348  {
1349  if (*option == '+')
1350  break;
1351  i++;
1352  if (i == (ssize_t) argc)
1353  ThrowConvertException(OptionError,"MissingArgument",option);
1354  break;
1355  }
1356  if (LocaleCompare("duplicate",option+1) == 0)
1357  {
1358  if (*option == '+')
1359  break;
1360  i++;
1361  if (i == (ssize_t) argc)
1362  ThrowConvertException(OptionError,"MissingArgument",option);
1363  if (IsGeometry(argv[i]) == MagickFalse)
1364  ThrowConvertInvalidArgumentException(option,argv[i]);
1365  break;
1366  }
1367  if (LocaleCompare("duration",option+1) == 0)
1368  {
1369  if (*option == '+')
1370  break;
1371  i++;
1372  if (i == (ssize_t) argc)
1373  ThrowConvertException(OptionError,"MissingArgument",option);
1374  if (IsGeometry(argv[i]) == MagickFalse)
1375  ThrowConvertInvalidArgumentException(option,argv[i]);
1376  break;
1377  }
1378  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1379  }
1380  case 'e':
1381  {
1382  if (LocaleCompare("edge",option+1) == 0)
1383  {
1384  if (*option == '+')
1385  break;
1386  i++;
1387  if (i == (ssize_t) argc)
1388  ThrowConvertException(OptionError,"MissingArgument",option);
1389  if (IsGeometry(argv[i]) == MagickFalse)
1390  ThrowConvertInvalidArgumentException(option,argv[i]);
1391  break;
1392  }
1393  if (LocaleCompare("emboss",option+1) == 0)
1394  {
1395  if (*option == '+')
1396  break;
1397  i++;
1398  if (i == (ssize_t) argc)
1399  ThrowConvertException(OptionError,"MissingArgument",option);
1400  if (IsGeometry(argv[i]) == MagickFalse)
1401  ThrowConvertInvalidArgumentException(option,argv[i]);
1402  break;
1403  }
1404  if (LocaleCompare("encipher",option+1) == 0)
1405  {
1406  if (*option == '+')
1407  break;
1408  i++;
1409  if (i == (ssize_t) argc)
1410  ThrowConvertException(OptionError,"MissingArgument",option);
1411  break;
1412  }
1413  if (LocaleCompare("encoding",option+1) == 0)
1414  {
1415  if (*option == '+')
1416  break;
1417  i++;
1418  if (i == (ssize_t) argc)
1419  ThrowConvertException(OptionError,"MissingArgument",option);
1420  break;
1421  }
1422  if (LocaleCompare("endian",option+1) == 0)
1423  {
1424  ssize_t
1425  endian;
1426 
1427  if (*option == '+')
1428  break;
1429  i++;
1430  if (i == (ssize_t) argc)
1431  ThrowConvertException(OptionError,"MissingArgument",option);
1432  endian=ParseCommandOption(MagickEndianOptions,MagickFalse,
1433  argv[i]);
1434  if (endian < 0)
1435  ThrowConvertException(OptionError,"UnrecognizedEndianType",
1436  argv[i]);
1437  break;
1438  }
1439  if (LocaleCompare("enhance",option+1) == 0)
1440  break;
1441  if (LocaleCompare("equalize",option+1) == 0)
1442  break;
1443  if (LocaleCompare("evaluate",option+1) == 0)
1444  {
1445  ssize_t
1446  op;
1447 
1448  if (*option == '+')
1449  break;
1450  i++;
1451  if (i == (ssize_t) argc)
1452  ThrowConvertException(OptionError,"MissingArgument",option);
1453  op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
1454  if (op < 0)
1455  ThrowConvertException(OptionError,"UnrecognizedEvaluateOperator",
1456  argv[i]);
1457  i++;
1458  if (i == (ssize_t) argc)
1459  ThrowConvertException(OptionError,"MissingArgument",option);
1460  if (IsGeometry(argv[i]) == MagickFalse)
1461  ThrowConvertInvalidArgumentException(option,argv[i]);
1462  break;
1463  }
1464  if (LocaleCompare("evaluate-sequence",option+1) == 0)
1465  {
1466  ssize_t
1467  op;
1468 
1469  if (*option == '+')
1470  break;
1471  i++;
1472  if (i == (ssize_t) argc)
1473  ThrowConvertException(OptionError,"MissingArgument",option);
1474  op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
1475  if (op < 0)
1476  ThrowConvertException(OptionError,"UnrecognizedEvaluateOperator",
1477  argv[i]);
1478  break;
1479  }
1480  if (LocaleCompare("extent",option+1) == 0)
1481  {
1482  if (*option == '+')
1483  break;
1484  i++;
1485  if (i == (ssize_t) argc)
1486  ThrowConvertException(OptionError,"MissingArgument",option);
1487  if (IsGeometry(argv[i]) == MagickFalse)
1488  ThrowConvertInvalidArgumentException(option,argv[i]);
1489  break;
1490  }
1491  if (LocaleCompare("extract",option+1) == 0)
1492  {
1493  if (*option == '+')
1494  break;
1495  i++;
1496  if (i == (ssize_t) argc)
1497  ThrowConvertException(OptionError,"MissingArgument",option);
1498  if (IsGeometry(argv[i]) == MagickFalse)
1499  ThrowConvertInvalidArgumentException(option,argv[i]);
1500  break;
1501  }
1502  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1503  }
1504  case 'f':
1505  {
1506  if (LocaleCompare("family",option+1) == 0)
1507  {
1508  if (*option == '+')
1509  break;
1510  i++;
1511  if (i == (ssize_t) argc)
1512  ThrowConvertException(OptionError,"MissingArgument",option);
1513  break;
1514  }
1515  if (LocaleCompare("features",option+1) == 0)
1516  {
1517  if (*option == '+')
1518  break;
1519  i++;
1520  if (i == (ssize_t) argc)
1521  ThrowConvertException(OptionError,"MissingArgument",option);
1522  if (IsGeometry(argv[i]) == MagickFalse)
1523  ThrowConvertInvalidArgumentException(option,argv[i]);
1524  break;
1525  }
1526  if (LocaleCompare("fft",option+1) == 0)
1527  break;
1528  if (LocaleCompare("fill",option+1) == 0)
1529  {
1530  if (*option == '+')
1531  break;
1532  i++;
1533  if (i == (ssize_t) argc)
1534  ThrowConvertException(OptionError,"MissingArgument",option);
1535  break;
1536  }
1537  if (LocaleCompare("filter",option+1) == 0)
1538  {
1539  ssize_t
1540  filter;
1541 
1542  if (*option == '+')
1543  break;
1544  i++;
1545  if (i == (ssize_t) argc)
1546  ThrowConvertException(OptionError,"MissingArgument",option);
1547  filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]);
1548  if (filter < 0)
1549  ThrowConvertException(OptionError,"UnrecognizedImageFilter",
1550  argv[i]);
1551  break;
1552  }
1553  if (LocaleCompare("flatten",option+1) == 0)
1554  break;
1555  if (LocaleCompare("flip",option+1) == 0)
1556  break;
1557  if (LocaleCompare("flop",option+1) == 0)
1558  break;
1559  if (LocaleCompare("floodfill",option+1) == 0)
1560  {
1561  if (*option == '+')
1562  break;
1563  i++;
1564  if (i == (ssize_t) argc)
1565  ThrowConvertException(OptionError,"MissingArgument",option);
1566  if (IsGeometry(argv[i]) == MagickFalse)
1567  ThrowConvertInvalidArgumentException(option,argv[i]);
1568  i++;
1569  if (i == (ssize_t) argc)
1570  ThrowConvertException(OptionError,"MissingArgument",option);
1571  break;
1572  }
1573  if (LocaleCompare("font",option+1) == 0)
1574  {
1575  if (*option == '+')
1576  break;
1577  i++;
1578  if (i == (ssize_t) argc)
1579  ThrowConvertException(OptionError,"MissingArgument",option);
1580  break;
1581  }
1582  if (LocaleCompare("format",option+1) == 0)
1583  {
1584  if (*option == '+')
1585  break;
1586  i++;
1587  if (i == (ssize_t) argc)
1588  ThrowConvertException(OptionError,"MissingArgument",option);
1589  format=argv[i];
1590  break;
1591  }
1592  if (LocaleCompare("frame",option+1) == 0)
1593  {
1594  if (*option == '+')
1595  break;
1596  i++;
1597  if (i == (ssize_t) argc)
1598  ThrowConvertException(OptionError,"MissingArgument",option);
1599  if (IsGeometry(argv[i]) == MagickFalse)
1600  ThrowConvertInvalidArgumentException(option,argv[i]);
1601  break;
1602  }
1603  if (LocaleCompare("function",option+1) == 0)
1604  {
1605  ssize_t
1606  op;
1607 
1608  if (*option == '+')
1609  break;
1610  i++;
1611  if (i == (ssize_t) argc)
1612  ThrowConvertException(OptionError,"MissingArgument",option);
1613  op=ParseCommandOption(MagickFunctionOptions,MagickFalse,argv[i]);
1614  if (op < 0)
1615  ThrowConvertException(OptionError,"UnrecognizedFunction",argv[i]);
1616  i++;
1617  if (i == (ssize_t) argc)
1618  ThrowConvertException(OptionError,"MissingArgument",option);
1619  break;
1620  }
1621  if (LocaleCompare("fuzz",option+1) == 0)
1622  {
1623  if (*option == '+')
1624  break;
1625  i++;
1626  if (i == (ssize_t) argc)
1627  ThrowConvertException(OptionError,"MissingArgument",option);
1628  if (IsGeometry(argv[i]) == MagickFalse)
1629  ThrowConvertInvalidArgumentException(option,argv[i]);
1630  break;
1631  }
1632  if (LocaleCompare("fx",option+1) == 0)
1633  {
1634  if (*option == '+')
1635  break;
1636  i++;
1637  if (i == (ssize_t) argc)
1638  ThrowConvertException(OptionError,"MissingArgument",option);
1639  break;
1640  }
1641  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1642  }
1643  case 'g':
1644  {
1645  if (LocaleCompare("gamma",option+1) == 0)
1646  {
1647  i++;
1648  if (i == (ssize_t) argc)
1649  ThrowConvertException(OptionError,"MissingArgument",option);
1650  if (IsGeometry(argv[i]) == MagickFalse)
1651  ThrowConvertInvalidArgumentException(option,argv[i]);
1652  break;
1653  }
1654  if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
1655  (LocaleCompare("gaussian",option+1) == 0))
1656  {
1657  i++;
1658  if (i == (ssize_t) argc)
1659  ThrowConvertException(OptionError,"MissingArgument",option);
1660  if (IsGeometry(argv[i]) == MagickFalse)
1661  ThrowConvertInvalidArgumentException(option,argv[i]);
1662  break;
1663  }
1664  if (LocaleCompare("geometry",option+1) == 0)
1665  {
1666  if (*option == '+')
1667  break;
1668  i++;
1669  if (i == (ssize_t) argc)
1670  ThrowConvertException(OptionError,"MissingArgument",option);
1671  if (IsGeometry(argv[i]) == MagickFalse)
1672  ThrowConvertInvalidArgumentException(option,argv[i]);
1673  break;
1674  }
1675  if (LocaleCompare("gravity",option+1) == 0)
1676  {
1677  ssize_t
1678  gravity;
1679 
1680  if (*option == '+')
1681  break;
1682  i++;
1683  if (i == (ssize_t) argc)
1684  ThrowConvertException(OptionError,"MissingArgument",option);
1685  gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
1686  argv[i]);
1687  if (gravity < 0)
1688  ThrowConvertException(OptionError,"UnrecognizedGravityType",
1689  argv[i]);
1690  break;
1691  }
1692  if (LocaleCompare("grayscale",option+1) == 0)
1693  {
1694  ssize_t
1695  method;
1696 
1697  if (*option == '+')
1698  break;
1699  i++;
1700  if (i == (ssize_t) argc)
1701  ThrowConvertException(OptionError,"MissingArgument",option);
1702  method=ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,
1703  argv[i]);
1704  if (method < 0)
1705  ThrowConvertException(OptionError,"UnrecognizedIntensityMethod",
1706  argv[i]);
1707  break;
1708  }
1709  if (LocaleCompare("green-primary",option+1) == 0)
1710  {
1711  if (*option == '+')
1712  break;
1713  i++;
1714  if (i == (ssize_t) argc)
1715  ThrowConvertException(OptionError,"MissingArgument",option);
1716  if (IsGeometry(argv[i]) == MagickFalse)
1717  ThrowConvertInvalidArgumentException(option,argv[i]);
1718  break;
1719  }
1720  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1721  }
1722  case 'h':
1723  {
1724  if (LocaleCompare("hald-clut",option+1) == 0)
1725  break;
1726  if (LocaleCompare("hough-lines",option+1) == 0)
1727  {
1728  if (*option == '+')
1729  break;
1730  i++;
1731  if (i == (ssize_t) argc)
1732  ThrowConvertException(OptionError,"MissingArgument",option);
1733  if (IsGeometry(argv[i]) == MagickFalse)
1734  ThrowConvertInvalidArgumentException(option,argv[i]);
1735  break;
1736  }
1737  if ((LocaleCompare("help",option+1) == 0) ||
1738  (LocaleCompare("-help",option+1) == 0))
1739  {
1740  DestroyConvert();
1741  return(ConvertUsage());
1742  }
1743  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1744  }
1745  case 'i':
1746  {
1747  if (LocaleCompare("identify",option+1) == 0)
1748  break;
1749  if (LocaleCompare("ift",option+1) == 0)
1750  break;
1751  if (LocaleCompare("implode",option+1) == 0)
1752  {
1753  if (*option == '+')
1754  break;
1755  i++;
1756  if (i == (ssize_t) argc)
1757  ThrowConvertException(OptionError,"MissingArgument",option);
1758  if (IsGeometry(argv[i]) == MagickFalse)
1759  ThrowConvertInvalidArgumentException(option,argv[i]);
1760  break;
1761  }
1762  if (LocaleCompare("interpolative-resize",option+1) == 0)
1763  {
1764  i++;
1765  if (i == (ssize_t) argc)
1766  ThrowConvertException(OptionError,"MissingArgument",option);
1767  if (IsGeometry(argv[i]) == MagickFalse)
1768  ThrowConvertInvalidArgumentException(option,argv[i]);
1769  break;
1770  }
1771  if (LocaleCompare("insert",option+1) == 0)
1772  {
1773  if (*option == '+')
1774  break;
1775  i++;
1776  if (i == (ssize_t) argc)
1777  ThrowConvertException(OptionError,"MissingArgument",option);
1778  if (IsGeometry(argv[i]) == MagickFalse)
1779  ThrowConvertInvalidArgumentException(option,argv[i]);
1780  break;
1781  }
1782  if (LocaleCompare("intensity",option+1) == 0)
1783  {
1784  ssize_t
1785  intensity;
1786 
1787  if (*option == '+')
1788  break;
1789  i++;
1790  if (i == (ssize_t) argc)
1791  ThrowConvertException(OptionError,"MissingArgument",option);
1792  intensity=ParseCommandOption(MagickPixelIntensityOptions,
1793  MagickFalse,argv[i]);
1794  if (intensity < 0)
1795  ThrowConvertException(OptionError,
1796  "UnrecognizedPixelIntensityMethod",argv[i]);
1797  break;
1798  }
1799  if (LocaleCompare("intent",option+1) == 0)
1800  {
1801  ssize_t
1802  intent;
1803 
1804  if (*option == '+')
1805  break;
1806  i++;
1807  if (i == (ssize_t) argc)
1808  ThrowConvertException(OptionError,"MissingArgument",option);
1809  intent=ParseCommandOption(MagickIntentOptions,MagickFalse,argv[i]);
1810  if (intent < 0)
1811  ThrowConvertException(OptionError,"UnrecognizedIntentType",
1812  argv[i]);
1813  break;
1814  }
1815  if (LocaleCompare("interlace",option+1) == 0)
1816  {
1817  ssize_t
1818  interlace;
1819 
1820  if (*option == '+')
1821  break;
1822  i++;
1823  if (i == (ssize_t) argc)
1824  ThrowConvertException(OptionError,"MissingArgument",option);
1825  interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
1826  argv[i]);
1827  if (interlace < 0)
1828  ThrowConvertException(OptionError,"UnrecognizedInterlaceType",
1829  argv[i]);
1830  break;
1831  }
1832  if (LocaleCompare("interline-spacing",option+1) == 0)
1833  {
1834  if (*option == '+')
1835  break;
1836  i++;
1837  if (i == (ssize_t) argc)
1838  ThrowConvertException(OptionError,"MissingArgument",option);
1839  if (IsGeometry(argv[i]) == MagickFalse)
1840  ThrowConvertInvalidArgumentException(option,argv[i]);
1841  break;
1842  }
1843  if (LocaleCompare("interpolate",option+1) == 0)
1844  {
1845  ssize_t
1846  interpolate;
1847 
1848  if (*option == '+')
1849  break;
1850  i++;
1851  if (i == (ssize_t) argc)
1852  ThrowConvertException(OptionError,"MissingArgument",option);
1853  interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
1854  argv[i]);
1855  if (interpolate < 0)
1856  ThrowConvertException(OptionError,"UnrecognizedInterpolateMethod",
1857  argv[i]);
1858  break;
1859  }
1860  if (LocaleCompare("interword-spacing",option+1) == 0)
1861  {
1862  if (*option == '+')
1863  break;
1864  i++;
1865  if (i == (ssize_t) argc)
1866  ThrowConvertException(OptionError,"MissingArgument",option);
1867  if (IsGeometry(argv[i]) == MagickFalse)
1868  ThrowConvertInvalidArgumentException(option,argv[i]);
1869  break;
1870  }
1871  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1872  }
1873  case 'k':
1874  {
1875  if (LocaleCompare("kerning",option+1) == 0)
1876  {
1877  if (*option == '+')
1878  break;
1879  i++;
1880  if (i == (ssize_t) argc)
1881  ThrowConvertException(OptionError,"MissingArgument",option);
1882  if (IsGeometry(argv[i]) == MagickFalse)
1883  ThrowConvertInvalidArgumentException(option,argv[i]);
1884  break;
1885  }
1886  if (LocaleCompare("kuwahara",option+1) == 0)
1887  {
1888  if (*option == '+')
1889  break;
1890  i++;
1891  if (i == (ssize_t) argc)
1892  ThrowConvertException(OptionError,"MissingArgument",option);
1893  if (IsGeometry(argv[i]) == MagickFalse)
1894  ThrowConvertInvalidArgumentException(option,argv[i]);
1895  break;
1896  }
1897  ThrowConvertException(OptionError,"UnrecognizedOption",option)
1898  }
1899  case 'l':
1900  {
1901  if (LocaleCompare("label",option+1) == 0)
1902  {
1903  if (*option == '+')
1904  break;
1905  i++;
1906  if (i == (ssize_t) argc)
1907  ThrowConvertException(OptionError,"MissingArgument",option);
1908  break;
1909  }
1910  if (LocaleCompare("lat",option+1) == 0)
1911  {
1912  if (*option == '+')
1913  break;
1914  i++;
1915  if (i == (ssize_t) argc)
1916  ThrowConvertException(OptionError,"MissingArgument",option);
1917  if (IsGeometry(argv[i]) == MagickFalse)
1918  ThrowConvertInvalidArgumentException(option,argv[i]);
1919  break;
1920  }
1921  if (LocaleCompare("layers",option+1) == 0)
1922  {
1923  ssize_t
1924  type;
1925 
1926  if (*option == '+')
1927  break;
1928  i++;
1929  if (i == (ssize_t) argc)
1930  ThrowConvertException(OptionError,"MissingArgument",option);
1931  type=ParseCommandOption(MagickLayerOptions,MagickFalse,argv[i]);
1932  if (type < 0)
1933  ThrowConvertException(OptionError,"UnrecognizedLayerMethod",
1934  argv[i]);
1935  break;
1936  }
1937  if (LocaleCompare("level",option+1) == 0)
1938  {
1939  i++;
1940  if (i == (ssize_t) argc)
1941  ThrowConvertException(OptionError,"MissingArgument",option);
1942  if (IsGeometry(argv[i]) == MagickFalse)
1943  ThrowConvertInvalidArgumentException(option,argv[i]);
1944  break;
1945  }
1946  if (LocaleCompare("level-colors",option+1) == 0)
1947  {
1948  i++;
1949  if (i == (ssize_t) argc)
1950  ThrowConvertException(OptionError,"MissingArgument",option);
1951  break;
1952  }
1953  if (LocaleCompare("linewidth",option+1) == 0)
1954  {
1955  if (*option == '+')
1956  break;
1957  i++;
1958  if (i == (ssize_t) argc)
1959  ThrowConvertException(OptionError,"MissingArgument",option);
1960  if (IsGeometry(argv[i]) == MagickFalse)
1961  ThrowConvertInvalidArgumentException(option,argv[i]);
1962  break;
1963  }
1964  if (LocaleCompare("liquid-rescale",option+1) == 0)
1965  {
1966  i++;
1967  if (i == (ssize_t) argc)
1968  ThrowConvertException(OptionError,"MissingArgument",option);
1969  if (IsGeometry(argv[i]) == MagickFalse)
1970  ThrowConvertInvalidArgumentException(option,argv[i]);
1971  break;
1972  }
1973  if (LocaleCompare("limit",option+1) == 0)
1974  {
1975  char
1976  *p;
1977 
1978  double
1979  value;
1980 
1981  ssize_t
1982  resource;
1983 
1984  if (*option == '+')
1985  break;
1986  i++;
1987  if (i == (ssize_t) argc)
1988  ThrowConvertException(OptionError,"MissingArgument",option);
1989  resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
1990  argv[i]);
1991  if (resource < 0)
1992  ThrowConvertException(OptionError,"UnrecognizedResourceType",
1993  argv[i]);
1994  i++;
1995  if (i == (ssize_t) argc)
1996  ThrowConvertException(OptionError,"MissingArgument",option);
1997  value=StringToDouble(argv[i],&p);
1998  (void) value;
1999  if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
2000  ThrowConvertInvalidArgumentException(option,argv[i]);
2001  break;
2002  }
2003  if (LocaleCompare("linear-stretch",option+1) == 0)
2004  {
2005  i++;
2006  if (i == (ssize_t) argc)
2007  ThrowConvertException(OptionError,"MissingArgument",option);
2008  if (IsGeometry(argv[i]) == MagickFalse)
2009  ThrowConvertInvalidArgumentException(option,argv[i]);
2010  break;
2011  }
2012  if (LocaleCompare("list",option+1) == 0)
2013  {
2014  ssize_t
2015  list;
2016 
2017  if (*option == '+')
2018  break;
2019  i++;
2020  if (i == (ssize_t) argc)
2021  ThrowConvertException(OptionError,"MissingArgument",option);
2022  list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
2023  if (list < 0)
2024  ThrowConvertException(OptionError,"UnrecognizedListType",argv[i]);
2025  status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
2026  argv+j,exception);
2027  DestroyConvert();
2028  return(status == 0 ? MagickFalse : MagickTrue);
2029  }
2030  if (LocaleCompare("local-contrast",option+1) == 0)
2031  {
2032  i++;
2033  if (i == (ssize_t) argc)
2034  ThrowConvertException(OptionError,"MissingArgument",option);
2035  if (IsGeometry(argv[i]) == MagickFalse)
2036  ThrowConvertInvalidArgumentException(option,argv[i]);
2037  break;
2038  }
2039  if (LocaleCompare("log",option+1) == 0)
2040  {
2041  if (*option == '+')
2042  break;
2043  i++;
2044  if ((i == (ssize_t) argc) ||
2045  (strchr(argv[i],'%') == (char *) NULL))
2046  ThrowConvertException(OptionError,"MissingArgument",option);
2047  break;
2048  }
2049  if (LocaleCompare("loop",option+1) == 0)
2050  {
2051  if (*option == '+')
2052  break;
2053  i++;
2054  if (i == (ssize_t) argc)
2055  ThrowConvertException(OptionError,"MissingArgument",option);
2056  if (IsGeometry(argv[i]) == MagickFalse)
2057  ThrowConvertInvalidArgumentException(option,argv[i]);
2058  break;
2059  }
2060  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2061  }
2062  case 'm':
2063  {
2064  if (LocaleCompare("magnify",option+1) == 0)
2065  break;
2066  if (LocaleCompare("map",option+1) == 0)
2067  {
2068  if (*option == '+')
2069  break;
2070  i++;
2071  if (i == (ssize_t) argc)
2072  ThrowConvertException(OptionError,"MissingArgument",option);
2073  break;
2074  }
2075  if (LocaleCompare("mask",option+1) == 0)
2076  {
2077  if (*option == '+')
2078  break;
2079  i++;
2080  if (i == (ssize_t) argc)
2081  ThrowConvertException(OptionError,"MissingArgument",option);
2082  break;
2083  }
2084  if (LocaleCompare("matte",option+1) == 0)
2085  break;
2086  if (LocaleCompare("mattecolor",option+1) == 0)
2087  {
2088  if (*option == '+')
2089  break;
2090  i++;
2091  if (i == (ssize_t) argc)
2092  ThrowConvertException(OptionError,"MissingArgument",option);
2093  break;
2094  }
2095  if (LocaleCompare("maximum",option+1) == 0)
2096  break;
2097  if (LocaleCompare("mean-shift",option+1) == 0)
2098  {
2099  if (*option == '+')
2100  break;
2101  i++;
2102  if (i == (ssize_t) argc)
2103  ThrowConvertException(OptionError,"MissingArgument",option);
2104  if (IsGeometry(argv[i]) == MagickFalse)
2105  ThrowConvertInvalidArgumentException(option,argv[i]);
2106  break;
2107  }
2108  if (LocaleCompare("median",option+1) == 0)
2109  {
2110  if (*option == '+')
2111  break;
2112  i++;
2113  if (i == (ssize_t) argc)
2114  ThrowConvertException(OptionError,"MissingArgument",option);
2115  if (IsGeometry(argv[i]) == MagickFalse)
2116  ThrowConvertInvalidArgumentException(option,argv[i]);
2117  break;
2118  }
2119  if (LocaleCompare("metric",option+1) == 0)
2120  {
2121  ssize_t
2122  type;
2123 
2124  if (*option == '+')
2125  break;
2126  i++;
2127  if (i == (ssize_t) argc)
2128  ThrowConvertException(OptionError,"MissingArgument",option);
2129  type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
2130  if (type < 0)
2131  ThrowConvertException(OptionError,"UnrecognizedMetricType",
2132  argv[i]);
2133  break;
2134  }
2135  if (LocaleCompare("minimum",option+1) == 0)
2136  break;
2137  if (LocaleCompare("mode",option+1) == 0)
2138  {
2139  if (*option == '+')
2140  break;
2141  i++;
2142  if (i == (ssize_t) argc)
2143  ThrowConvertException(OptionError,"MissingArgument",option);
2144  if (IsGeometry(argv[i]) == MagickFalse)
2145  ThrowConvertInvalidArgumentException(option,argv[i]);
2146  break;
2147  }
2148  if (LocaleCompare("modulate",option+1) == 0)
2149  {
2150  if (*option == '+')
2151  break;
2152  i++;
2153  if (i == (ssize_t) argc)
2154  ThrowConvertException(OptionError,"MissingArgument",option);
2155  if (IsGeometry(argv[i]) == MagickFalse)
2156  ThrowConvertInvalidArgumentException(option,argv[i]);
2157  break;
2158  }
2159  if (LocaleCompare("moments",option+1) == 0)
2160  break;
2161  if (LocaleCompare("monitor",option+1) == 0)
2162  break;
2163  if (LocaleCompare("monochrome",option+1) == 0)
2164  break;
2165  if (LocaleCompare("morph",option+1) == 0)
2166  {
2167  if (*option == '+')
2168  break;
2169  i++;
2170  if (i == (ssize_t) argc)
2171  ThrowConvertException(OptionError,"MissingArgument",option);
2172  if (IsGeometry(argv[i]) == MagickFalse)
2173  ThrowConvertInvalidArgumentException(option,argv[i]);
2174  break;
2175  }
2176  if (LocaleCompare("morphology",option+1) == 0)
2177  {
2178  char
2179  token[MaxTextExtent];
2180 
2181  KernelInfo
2182  *kernel_info;
2183 
2184  ssize_t
2185  op;
2186 
2187  i++;
2188  if (i == (ssize_t) argc)
2189  ThrowConvertException(OptionError,"MissingArgument",option);
2190  (void) GetNextToken(argv[i],(const char **) NULL,MaxTextExtent,token);
2191  op=ParseCommandOption(MagickMorphologyOptions,MagickFalse,token);
2192  if (op < 0)
2193  ThrowConvertException(OptionError,"UnrecognizedMorphologyMethod",
2194  token);
2195  i++;
2196  if (i == (ssize_t) argc)
2197  ThrowConvertException(OptionError,"MissingArgument",option);
2198  kernel_info=AcquireKernelInfo(argv[i]);
2199  if (kernel_info == (KernelInfo *) NULL)
2200  ThrowConvertInvalidArgumentException(option,argv[i]);
2201  kernel_info=DestroyKernelInfo(kernel_info);
2202  break;
2203  }
2204  if (LocaleCompare("mosaic",option+1) == 0)
2205  break;
2206  if (LocaleCompare("motion-blur",option+1) == 0)
2207  {
2208  if (*option == '+')
2209  break;
2210  i++;
2211  if (i == (ssize_t) argc)
2212  ThrowConvertException(OptionError,"MissingArgument",option);
2213  if (IsGeometry(argv[i]) == MagickFalse)
2214  ThrowConvertInvalidArgumentException(option,argv[i]);
2215  break;
2216  }
2217  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2218  }
2219  case 'n':
2220  {
2221  if (LocaleCompare("negate",option+1) == 0)
2222  break;
2223  if (LocaleCompare("noise",option+1) == 0)
2224  {
2225  i++;
2226  if (i == (ssize_t) argc)
2227  ThrowConvertException(OptionError,"MissingArgument",option);
2228  if (*option == '+')
2229  {
2230  ssize_t
2231  noise;
2232 
2233  noise=ParseCommandOption(MagickNoiseOptions,MagickFalse,
2234  argv[i]);
2235  if (noise < 0)
2236  ThrowConvertException(OptionError,"UnrecognizedNoiseType",
2237  argv[i]);
2238  break;
2239  }
2240  if (IsGeometry(argv[i]) == MagickFalse)
2241  ThrowConvertInvalidArgumentException(option,argv[i]);
2242  break;
2243  }
2244  if (LocaleCompare("noop",option+1) == 0)
2245  break;
2246  if (LocaleCompare("normalize",option+1) == 0)
2247  break;
2248  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2249  }
2250  case 'o':
2251  {
2252  if (LocaleCompare("opaque",option+1) == 0)
2253  {
2254  i++;
2255  if (i == (ssize_t) argc)
2256  ThrowConvertException(OptionError,"MissingArgument",option);
2257  break;
2258  }
2259  if (LocaleCompare("ordered-dither",option+1) == 0)
2260  {
2261  if (*option == '+')
2262  break;
2263  i++;
2264  if (i == (ssize_t) argc)
2265  ThrowConvertException(OptionError,"MissingArgument",option);
2266  break;
2267  }
2268  if (LocaleCompare("orient",option+1) == 0)
2269  {
2270  ssize_t
2271  orientation;
2272 
2273  if (*option == '+')
2274  break;
2275  i++;
2276  if (i == (ssize_t) argc)
2277  ThrowConvertException(OptionError,"MissingArgument",option);
2278  orientation=ParseCommandOption(MagickOrientationOptions,
2279  MagickFalse,argv[i]);
2280  if (orientation < 0)
2281  ThrowConvertException(OptionError,"UnrecognizedImageOrientation",
2282  argv[i]);
2283  break;
2284  }
2285  ThrowConvertException(OptionError,"UnrecognizedOption",argv[i])
2286  }
2287  case 'p':
2288  {
2289  if (LocaleCompare("page",option+1) == 0)
2290  {
2291  if (*option == '+')
2292  break;
2293  i++;
2294  if (i == (ssize_t) argc)
2295  ThrowConvertException(OptionError,"MissingArgument",option);
2296  break;
2297  }
2298  if (LocaleCompare("paint",option+1) == 0)
2299  {
2300  if (*option == '+')
2301  break;
2302  i++;
2303  if (i == (ssize_t) argc)
2304  ThrowConvertException(OptionError,"MissingArgument",option);
2305  if (IsGeometry(argv[i]) == MagickFalse)
2306  ThrowConvertInvalidArgumentException(option,argv[i]);
2307  break;
2308  }
2309  if (LocaleCompare("perceptible",option+1) == 0)
2310  {
2311  if (*option == '+')
2312  break;
2313  i++;
2314  if (i == (ssize_t) argc)
2315  ThrowConvertException(OptionError,"MissingArgument",option);
2316  if (IsGeometry(argv[i]) == MagickFalse)
2317  ThrowConvertInvalidArgumentException(option,argv[i]);
2318  break;
2319  }
2320  if (LocaleCompare("ping",option+1) == 0)
2321  break;
2322  if (LocaleCompare("pointsize",option+1) == 0)
2323  {
2324  if (*option == '+')
2325  break;
2326  i++;
2327  if (i == (ssize_t) argc)
2328  ThrowConvertException(OptionError,"MissingArgument",option);
2329  if (IsGeometry(argv[i]) == MagickFalse)
2330  ThrowConvertInvalidArgumentException(option,argv[i]);
2331  break;
2332  }
2333  if (LocaleCompare("polaroid",option+1) == 0)
2334  {
2335  if (*option == '+')
2336  break;
2337  i++;
2338  if (i == (ssize_t) argc)
2339  ThrowConvertException(OptionError,"MissingArgument",option);
2340  if (IsGeometry(argv[i]) == MagickFalse)
2341  ThrowConvertInvalidArgumentException(option,argv[i]);
2342  break;
2343  }
2344  if (LocaleCompare("poly",option+1) == 0)
2345  {
2346  if (*option == '+')
2347  break;
2348  i++;
2349  if (i == (ssize_t) argc)
2350  ThrowConvertException(OptionError,"MissingArgument",option);
2351  if (IsGeometry(argv[i]) == MagickFalse)
2352  ThrowConvertInvalidArgumentException(option,argv[i]);
2353  break;
2354  }
2355  if (LocaleCompare("posterize",option+1) == 0)
2356  {
2357  if (*option == '+')
2358  break;
2359  i++;
2360  if (i == (ssize_t) argc)
2361  ThrowConvertException(OptionError,"MissingArgument",option);
2362  if (IsGeometry(argv[i]) == MagickFalse)
2363  ThrowConvertInvalidArgumentException(option,argv[i]);
2364  break;
2365  }
2366  if (LocaleCompare("precision",option+1) == 0)
2367  {
2368  if (*option == '+')
2369  break;
2370  i++;
2371  if (i == (ssize_t) argc)
2372  ThrowConvertException(OptionError,"MissingArgument",option);
2373  if (IsGeometry(argv[i]) == MagickFalse)
2374  ThrowConvertInvalidArgumentException(option,argv[i]);
2375  break;
2376  }
2377  if (LocaleCompare("preview",option+1) == 0)
2378  {
2379  ssize_t
2380  preview;
2381 
2382  if (*option == '+')
2383  break;
2384  i++;
2385  if (i == (ssize_t) argc)
2386  ThrowConvertException(OptionError,"MissingArgument",option);
2387  preview=ParseCommandOption(MagickPreviewOptions,MagickFalse,
2388  argv[i]);
2389  if (preview < 0)
2390  ThrowConvertException(OptionError,"UnrecognizedPreviewType",
2391  argv[i]);
2392  break;
2393  }
2394  if (LocaleCompare("print",option+1) == 0)
2395  {
2396  if (*option == '+')
2397  break;
2398  i++;
2399  if (i == (ssize_t) argc)
2400  ThrowConvertException(OptionError,"MissingArgument",option);
2401  break;
2402  }
2403  if (LocaleCompare("process",option+1) == 0)
2404  {
2405  if (*option == '+')
2406  break;
2407  i++;
2408  if (i == (ssize_t) argc)
2409  ThrowConvertException(OptionError,"MissingArgument",option);
2410  break;
2411  }
2412  if (LocaleCompare("profile",option+1) == 0)
2413  {
2414  i++;
2415  if (i == (ssize_t) argc)
2416  ThrowConvertException(OptionError,"MissingArgument",option);
2417  break;
2418  }
2419  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2420  }
2421  case 'q':
2422  {
2423  if (LocaleCompare("quality",option+1) == 0)
2424  {
2425  if (*option == '+')
2426  break;
2427  i++;
2428  if (i == (ssize_t) argc)
2429  ThrowConvertException(OptionError,"MissingArgument",option);
2430  if (IsGeometry(argv[i]) == MagickFalse)
2431  ThrowConvertInvalidArgumentException(option,argv[i]);
2432  break;
2433  }
2434  if (LocaleCompare("quantize",option+1) == 0)
2435  {
2436  ssize_t
2437  colorspace;
2438 
2439  if (*option == '+')
2440  break;
2441  i++;
2442  if (i == (ssize_t) argc)
2443  ThrowConvertException(OptionError,"MissingArgument",option);
2444  colorspace=ParseCommandOption(MagickColorspaceOptions,
2445  MagickFalse,argv[i]);
2446  if (colorspace < 0)
2447  ThrowConvertException(OptionError,"UnrecognizedColorspace",
2448  argv[i]);
2449  break;
2450  }
2451  if (LocaleCompare("quiet",option+1) == 0)
2452  break;
2453  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2454  }
2455  case 'r':
2456  {
2457  if (LocaleCompare("radial-blur",option+1) == 0 ||
2458  LocaleCompare("rotational-blur",option+1) == 0)
2459  {
2460  i++;
2461  if (i == (ssize_t) argc)
2462  ThrowConvertException(OptionError,"MissingArgument",option);
2463  if (IsGeometry(argv[i]) == MagickFalse)
2464  ThrowConvertInvalidArgumentException(option,argv[i]);
2465  break;
2466  }
2467  if (LocaleCompare("raise",option+1) == 0)
2468  {
2469  i++;
2470  if (i == (ssize_t) argc)
2471  ThrowConvertException(OptionError,"MissingArgument",option);
2472  if (IsGeometry(argv[i]) == MagickFalse)
2473  ThrowConvertInvalidArgumentException(option,argv[i]);
2474  break;
2475  }
2476  if (LocaleCompare("random-threshold",option+1) == 0)
2477  {
2478  if (*option == '+')
2479  break;
2480  i++;
2481  if (i == (ssize_t) argc)
2482  ThrowConvertException(OptionError,"MissingArgument",option);
2483  if (IsGeometry(argv[i]) == MagickFalse)
2484  ThrowConvertInvalidArgumentException(option,argv[i]);
2485  break;
2486  }
2487  if (LocaleCompare("recolor",option+1) == 0)
2488  {
2489  if (*option == '+')
2490  break;
2491  i++;
2492  if (i == (ssize_t) argc)
2493  ThrowConvertException(OptionError,"MissingArgument",option);
2494  if (IsGeometry(argv[i]) == MagickFalse)
2495  ThrowConvertInvalidArgumentException(option,argv[i]);
2496  break;
2497  }
2498  if (LocaleCompare("red-primary",option+1) == 0)
2499  {
2500  if (*option == '+')
2501  break;
2502  i++;
2503  if (i == (ssize_t) argc)
2504  ThrowConvertException(OptionError,"MissingArgument",option);
2505  if (IsGeometry(argv[i]) == MagickFalse)
2506  ThrowConvertInvalidArgumentException(option,argv[i]);
2507  break;
2508  }
2509  if (LocaleCompare("regard-warnings",option+1) == 0)
2510  break;
2511  if (LocaleCompare("region",option+1) == 0)
2512  {
2513  if (*option == '+')
2514  break;
2515  i++;
2516  if (i == (ssize_t) argc)
2517  ThrowConvertException(OptionError,"MissingArgument",option);
2518  if (IsGeometry(argv[i]) == MagickFalse)
2519  ThrowConvertInvalidArgumentException(option,argv[i]);
2520  break;
2521  }
2522  if (LocaleCompare("remap",option+1) == 0)
2523  {
2524  if (*option == '+')
2525  break;
2526  i++;
2527  if (i == (ssize_t) argc)
2528  ThrowConvertException(OptionError,"MissingArgument",option);
2529  break;
2530  }
2531  if (LocaleCompare("render",option+1) == 0)
2532  break;
2533  if (LocaleCompare("repage",option+1) == 0)
2534  {
2535  if (*option == '+')
2536  break;
2537  i++;
2538  if (i == (ssize_t) argc)
2539  ThrowConvertException(OptionError,"MissingArgument",option);
2540  if (IsGeometry(argv[i]) == MagickFalse)
2541  ThrowConvertInvalidArgumentException(option,argv[i]);
2542  break;
2543  }
2544  if (LocaleCompare("resample",option+1) == 0)
2545  {
2546  if (*option == '+')
2547  break;
2548  i++;
2549  if (i == (ssize_t) argc)
2550  ThrowConvertException(OptionError,"MissingArgument",option);
2551  if (IsGeometry(argv[i]) == MagickFalse)
2552  ThrowConvertInvalidArgumentException(option,argv[i]);
2553  break;
2554  }
2555  if (LocaleCompare("resize",option+1) == 0)
2556  {
2557  if (*option == '+')
2558  break;
2559  i++;
2560  if (i == (ssize_t) argc)
2561  ThrowConvertException(OptionError,"MissingArgument",option);
2562  if (IsGeometry(argv[i]) == MagickFalse)
2563  ThrowConvertInvalidArgumentException(option,argv[i]);
2564  break;
2565  }
2566  if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
2567  {
2568  respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
2569  break;
2570  }
2571  if (LocaleCompare("reverse",option+1) == 0)
2572  break;
2573  if (LocaleCompare("roll",option+1) == 0)
2574  {
2575  if (*option == '+')
2576  break;
2577  i++;
2578  if (i == (ssize_t) argc)
2579  ThrowConvertException(OptionError,"MissingArgument",option);
2580  if (IsGeometry(argv[i]) == MagickFalse)
2581  ThrowConvertInvalidArgumentException(option,argv[i]);
2582  break;
2583  }
2584  if (LocaleCompare("rotate",option+1) == 0)
2585  {
2586  i++;
2587  if (i == (ssize_t) argc)
2588  ThrowConvertException(OptionError,"MissingArgument",option);
2589  if (IsGeometry(argv[i]) == MagickFalse)
2590  ThrowConvertInvalidArgumentException(option,argv[i]);
2591  break;
2592  }
2593  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2594  }
2595  case 's':
2596  {
2597  if (LocaleCompare("sample",option+1) == 0)
2598  {
2599  if (*option == '+')
2600  break;
2601  i++;
2602  if (i == (ssize_t) argc)
2603  ThrowConvertException(OptionError,"MissingArgument",option);
2604  if (IsGeometry(argv[i]) == MagickFalse)
2605  ThrowConvertInvalidArgumentException(option,argv[i]);
2606  break;
2607  }
2608  if (LocaleCompare("sampling-factor",option+1) == 0)
2609  {
2610  if (*option == '+')
2611  break;
2612  i++;
2613  if (i == (ssize_t) argc)
2614  ThrowConvertException(OptionError,"MissingArgument",option);
2615  if (IsGeometry(argv[i]) == MagickFalse)
2616  ThrowConvertInvalidArgumentException(option,argv[i]);
2617  break;
2618  }
2619  if (LocaleCompare("scale",option+1) == 0)
2620  {
2621  if (*option == '+')
2622  break;
2623  i++;
2624  if (i == (ssize_t) argc)
2625  ThrowConvertException(OptionError,"MissingArgument",option);
2626  if (IsGeometry(argv[i]) == MagickFalse)
2627  ThrowConvertInvalidArgumentException(option,argv[i]);
2628  break;
2629  }
2630  if (LocaleCompare("scene",option+1) == 0)
2631  {
2632  if (*option == '+')
2633  break;
2634  i++;
2635  if (i == (ssize_t) argc)
2636  ThrowConvertException(OptionError,"MissingArgument",option);
2637  if (IsGeometry(argv[i]) == MagickFalse)
2638  ThrowConvertInvalidArgumentException(option,argv[i]);
2639  break;
2640  }
2641  if (LocaleCompare("seed",option+1) == 0)
2642  {
2643  if (*option == '+')
2644  break;
2645  i++;
2646  if (i == (ssize_t) argc)
2647  ThrowConvertException(OptionError,"MissingArgument",option);
2648  if (IsGeometry(argv[i]) == MagickFalse)
2649  ThrowConvertInvalidArgumentException(option,argv[i]);
2650  break;
2651  }
2652  if (LocaleCompare("segment",option+1) == 0)
2653  {
2654  if (*option == '+')
2655  break;
2656  i++;
2657  if (i == (ssize_t) argc)
2658  ThrowConvertException(OptionError,"MissingArgument",option);
2659  if (IsGeometry(argv[i]) == MagickFalse)
2660  ThrowConvertInvalidArgumentException(option,argv[i]);
2661  break;
2662  }
2663  if (LocaleCompare("selective-blur",option+1) == 0)
2664  {
2665  i++;
2666  if (i == (ssize_t) argc)
2667  ThrowConvertException(OptionError,"MissingArgument",option);
2668  if (IsGeometry(argv[i]) == MagickFalse)
2669  ThrowConvertInvalidArgumentException(option,argv[i]);
2670  break;
2671  }
2672  if (LocaleCompare("separate",option+1) == 0)
2673  break;
2674  if (LocaleCompare("sepia-tone",option+1) == 0)
2675  {
2676  if (*option == '+')
2677  break;
2678  i++;
2679  if (i == (ssize_t) argc)
2680  ThrowConvertException(OptionError,"MissingArgument",option);
2681  if (IsGeometry(argv[i]) == MagickFalse)
2682  ThrowConvertInvalidArgumentException(option,argv[i]);
2683  break;
2684  }
2685  if (LocaleCompare("set",option+1) == 0)
2686  {
2687  i++;
2688  if (i == (ssize_t) argc)
2689  ThrowConvertException(OptionError,"MissingArgument",option);
2690  if (*option == '+')
2691  break;
2692  i++;
2693  if (i == (ssize_t) argc)
2694  ThrowConvertException(OptionError,"MissingArgument",option);
2695  break;
2696  }
2697  if (LocaleCompare("shade",option+1) == 0)
2698  {
2699  i++;
2700  if (i == (ssize_t) argc)
2701  ThrowConvertException(OptionError,"MissingArgument",option);
2702  if (IsGeometry(argv[i]) == MagickFalse)
2703  ThrowConvertInvalidArgumentException(option,argv[i]);
2704  break;
2705  }
2706  if (LocaleCompare("shadow",option+1) == 0)
2707  {
2708  if (*option == '+')
2709  break;
2710  i++;
2711  if (i == (ssize_t) argc)
2712  ThrowConvertException(OptionError,"MissingArgument",option);
2713  if (IsGeometry(argv[i]) == MagickFalse)
2714  ThrowConvertInvalidArgumentException(option,argv[i]);
2715  break;
2716  }
2717  if (LocaleCompare("sharpen",option+1) == 0)
2718  {
2719  i++;
2720  if (i == (ssize_t) argc)
2721  ThrowConvertException(OptionError,"MissingArgument",option);
2722  if (IsGeometry(argv[i]) == MagickFalse)
2723  ThrowConvertInvalidArgumentException(option,argv[i]);
2724  break;
2725  }
2726  if (LocaleCompare("shave",option+1) == 0)
2727  {
2728  if (*option == '+')
2729  break;
2730  i++;
2731  if (i == (ssize_t) argc)
2732  ThrowConvertException(OptionError,"MissingArgument",option);
2733  if (IsGeometry(argv[i]) == MagickFalse)
2734  ThrowConvertInvalidArgumentException(option,argv[i]);
2735  break;
2736  }
2737  if (LocaleCompare("shear",option+1) == 0)
2738  {
2739  i++;
2740  if (i == (ssize_t) argc)
2741  ThrowConvertException(OptionError,"MissingArgument",option);
2742  if (IsGeometry(argv[i]) == MagickFalse)
2743  ThrowConvertInvalidArgumentException(option,argv[i]);
2744  break;
2745  }
2746  if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
2747  {
2748  i++;
2749  if (i == (ssize_t) argc)
2750  ThrowConvertException(OptionError,"MissingArgument",option);
2751  if (IsGeometry(argv[i]) == MagickFalse)
2752  ThrowConvertInvalidArgumentException(option,argv[i]);
2753  break;
2754  }
2755  if (LocaleCompare("size",option+1) == 0)
2756  {
2757  if (*option == '+')
2758  break;
2759  i++;
2760  if (i == (ssize_t) argc)
2761  ThrowConvertException(OptionError,"MissingArgument",option);
2762  if (IsGeometry(argv[i]) == MagickFalse)
2763  ThrowConvertInvalidArgumentException(option,argv[i]);
2764  break;
2765  }
2766  if (LocaleCompare("sketch",option+1) == 0)
2767  {
2768  if (*option == '+')
2769  break;
2770  i++;
2771  if (i == (ssize_t) argc)
2772  ThrowConvertException(OptionError,"MissingArgument",option);
2773  if (IsGeometry(argv[i]) == MagickFalse)
2774  ThrowConvertInvalidArgumentException(option,argv[i]);
2775  break;
2776  }
2777  if (LocaleCompare("smush",option+1) == 0)
2778  {
2779  i++;
2780  if (i == (ssize_t) argc)
2781  ThrowConvertException(OptionError,"MissingArgument",option);
2782  if (IsGeometry(argv[i]) == MagickFalse)
2783  ThrowConvertInvalidArgumentException(option,argv[i]);
2784  break;
2785  }
2786  if (LocaleCompare("solarize",option+1) == 0)
2787  {
2788  if (*option == '+')
2789  break;
2790  i++;
2791  if (i == (ssize_t) argc)
2792  ThrowConvertException(OptionError,"MissingArgument",option);
2793  if (IsGeometry(argv[i]) == MagickFalse)
2794  ThrowConvertInvalidArgumentException(option,argv[i]);
2795  break;
2796  }
2797  if (LocaleCompare("sparse-color",option+1) == 0)
2798  {
2799  ssize_t
2800  op;
2801 
2802  i++;
2803  if (i == (ssize_t) argc)
2804  ThrowConvertException(OptionError,"MissingArgument",option);
2805  op=ParseCommandOption(MagickSparseColorOptions,MagickFalse,argv[i]);
2806  if (op < 0)
2807  ThrowConvertException(OptionError,"UnrecognizedSparseColorMethod",
2808  argv[i]);
2809  i++;
2810  if (i == (ssize_t) argc)
2811  ThrowConvertException(OptionError,"MissingArgument",option);
2812  break;
2813  }
2814  if (LocaleCompare("splice",option+1) == 0)
2815  {
2816  if (*option == '+')
2817  break;
2818  i++;
2819  if (i == (ssize_t) argc)
2820  ThrowConvertException(OptionError,"MissingArgument",option);
2821  if (IsGeometry(argv[i]) == MagickFalse)
2822  ThrowConvertInvalidArgumentException(option,argv[i]);
2823  break;
2824  }
2825  if (LocaleCompare("spread",option+1) == 0)
2826  {
2827  if (*option == '+')
2828  break;
2829  i++;
2830  if ((i == (ssize_t) argc) ||
2831  (IsGeometry(argv[i]) == MagickFalse))
2832  ThrowConvertException(OptionError,"MissingArgument",option);
2833  break;
2834  }
2835  if (LocaleCompare("statistic",option+1) == 0)
2836  {
2837  ssize_t
2838  op;
2839 
2840  if (*option == '+')
2841  break;
2842  i++;
2843  if (i == (ssize_t) argc)
2844  ThrowConvertException(OptionError,"MissingArgument",option);
2845  op=ParseCommandOption(MagickStatisticOptions,MagickFalse,argv[i]);
2846  if (op < 0)
2847  ThrowConvertException(OptionError,"UnrecognizedStatisticType",
2848  argv[i]);
2849  i++;
2850  if (i == (ssize_t) argc)
2851  ThrowConvertException(OptionError,"MissingArgument",option);
2852  if (IsGeometry(argv[i]) == MagickFalse)
2853  ThrowConvertInvalidArgumentException(option,argv[i]);
2854  break;
2855  }
2856  if (LocaleCompare("stretch",option+1) == 0)
2857  {
2858  ssize_t
2859  stretch;
2860 
2861  if (*option == '+')
2862  break;
2863  i++;
2864  if (i == (ssize_t) argc)
2865  ThrowConvertException(OptionError,"MissingArgument",option);
2866  stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,
2867  argv[i]);
2868  if (stretch < 0)
2869  ThrowConvertException(OptionError,"UnrecognizedStyleType",
2870  argv[i]);
2871  break;
2872  }
2873  if (LocaleCompare("strip",option+1) == 0)
2874  break;
2875  if (LocaleCompare("stroke",option+1) == 0)
2876  {
2877  if (*option == '+')
2878  break;
2879  i++;
2880  if (i == (ssize_t) argc)
2881  ThrowConvertException(OptionError,"MissingArgument",option);
2882  break;
2883  }
2884  if (LocaleCompare("strokewidth",option+1) == 0)
2885  {
2886  if (*option == '+')
2887  break;
2888  i++;
2889  if (i == (ssize_t) argc)
2890  ThrowConvertException(OptionError,"MissingArgument",option);
2891  if (IsGeometry(argv[i]) == MagickFalse)
2892  ThrowConvertInvalidArgumentException(option,argv[i]);
2893  break;
2894  }
2895  if (LocaleCompare("style",option+1) == 0)
2896  {
2897  ssize_t
2898  style;
2899 
2900  if (*option == '+')
2901  break;
2902  i++;
2903  if (i == (ssize_t) argc)
2904  ThrowConvertException(OptionError,"MissingArgument",option);
2905  style=ParseCommandOption(MagickStyleOptions,MagickFalse,argv[i]);
2906  if (style < 0)
2907  ThrowConvertException(OptionError,"UnrecognizedStyleType",
2908  argv[i]);
2909  break;
2910  }
2911  if (LocaleCompare("support",option+1) == 0)
2912  {
2913  i++; /* deprecated */
2914  break;
2915  }
2916  if (LocaleCompare("swap",option+1) == 0)
2917  {
2918  if (*option == '+')
2919  break;
2920  i++;
2921  if (i == (ssize_t) argc)
2922  ThrowConvertException(OptionError,"MissingArgument",option);
2923  if (IsGeometry(argv[i]) == MagickFalse)
2924  ThrowConvertInvalidArgumentException(option,argv[i]);
2925  break;
2926  }
2927  if (LocaleCompare("swirl",option+1) == 0)
2928  {
2929  if (*option == '+')
2930  break;
2931  i++;
2932  if (i == (ssize_t) argc)
2933  ThrowConvertException(OptionError,"MissingArgument",option);
2934  if (IsGeometry(argv[i]) == MagickFalse)
2935  ThrowConvertInvalidArgumentException(option,argv[i]);
2936  break;
2937  }
2938  if (LocaleCompare("synchronize",option+1) == 0)
2939  break;
2940  ThrowConvertException(OptionError,"UnrecognizedOption",option)
2941  }
2942  case 't':
2943  {
2944  if (LocaleCompare("taint",option+1) == 0)
2945  break;
2946  if (LocaleCompare("texture",option+1) == 0)
2947  {
2948  if (*option == '+')
2949  break;
2950  i++;
2951  if (i == (ssize_t) argc)
2952  ThrowConvertException(OptionError,"MissingArgument",option);
2953  break;
2954  }
2955  if (LocaleCompare("thumbnail",option+1) == 0)
2956  {
2957  if (*option == '+')
2958  break;
2959  i++;
2960  if (i == (ssize_t) argc)
2961  ThrowConvertException(OptionError,"MissingArgument",option);
2962  if (IsGeometry(argv[i]) == MagickFalse)
2963  ThrowConvertInvalidArgumentException(option,argv[i]);
2964  break;
2965  }
2966  if (LocaleCompare("threshold",option+1) == 0)
2967  {
2968  if (*option == '+')
2969  break;
2970  i++;
2971  if (i == (ssize_t) argc)
2972  ThrowConvertException(OptionError,"MissingArgument",option);
2973  if (IsGeometry(argv[i]) == MagickFalse)
2974  ThrowConvertInvalidArgumentException(option,argv[i]);
2975  break;
2976  }
2977  if (LocaleCompare("tile",option+1) == 0)
2978  {
2979  if (*option == '+')
2980  break;
2981  i++;
2982  if (i == (ssize_t) argc)
2983  ThrowConvertException(OptionError,"MissingArgument",option);
2984  break;
2985  }
2986  if (LocaleCompare("tile-offset",option+1) == 0)
2987  {
2988  if (*option == '+')
2989  break;
2990  i++;
2991  if (i == (ssize_t) argc)
2992  ThrowConvertException(OptionError,"MissingArgument",option);
2993  if (IsGeometry(argv[i]) == MagickFalse)
2994  ThrowConvertInvalidArgumentException(option,argv[i]);
2995  break;
2996  }
2997  if (LocaleCompare("tint",option+1) == 0)
2998  {
2999  if (*option == '+')
3000  break;
3001  i++;
3002  if (i == (ssize_t) argc)
3003  ThrowConvertException(OptionError,"MissingArgument",option);
3004  if (IsGeometry(argv[i]) == MagickFalse)
3005  ThrowConvertInvalidArgumentException(option,argv[i]);
3006  break;
3007  }
3008  if (LocaleCompare("transform",option+1) == 0)
3009  break;
3010  if (LocaleCompare("transparent",option+1) == 0)
3011  {
3012  i++;
3013  if (i == (ssize_t) argc)
3014  ThrowConvertException(OptionError,"MissingArgument",option);
3015  break;
3016  }
3017  if (LocaleCompare("transparent-color",option+1) == 0)
3018  {
3019  if (*option == '+')
3020  break;
3021  i++;
3022  if (i == (ssize_t) argc)
3023  ThrowConvertException(OptionError,"MissingArgument",option);
3024  break;
3025  }
3026  if (LocaleCompare("transpose",option+1) == 0)
3027  break;
3028  if (LocaleCompare("transverse",option+1) == 0)
3029  break;
3030  if (LocaleCompare("treedepth",option+1) == 0)
3031  {
3032  if (*option == '+')
3033  break;
3034  i++;
3035  if (i == (ssize_t) argc)
3036  ThrowConvertException(OptionError,"MissingArgument",option);
3037  if (IsGeometry(argv[i]) == MagickFalse)
3038  ThrowConvertInvalidArgumentException(option,argv[i]);
3039  break;
3040  }
3041  if (LocaleCompare("trim",option+1) == 0)
3042  break;
3043  if (LocaleCompare("type",option+1) == 0)
3044  {
3045  ssize_t
3046  type;
3047 
3048  if (*option == '+')
3049  break;
3050  i++;
3051  if (i == (ssize_t) argc)
3052  ThrowConvertException(OptionError,"MissingArgument",option);
3053  type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
3054  if (type < 0)
3055  ThrowConvertException(OptionError,"UnrecognizedImageType",
3056  argv[i]);
3057  break;
3058  }
3059  ThrowConvertException(OptionError,"UnrecognizedOption",option)
3060  }
3061  case 'u':
3062  {
3063  if (LocaleCompare("undercolor",option+1) == 0)
3064  {
3065  if (*option == '+')
3066  break;
3067  i++;
3068  if (i == (ssize_t) argc)
3069  ThrowConvertException(OptionError,"MissingArgument",option);
3070  break;
3071  }
3072  if (LocaleCompare("unique-colors",option+1) == 0)
3073  break;
3074  if (LocaleCompare("units",option+1) == 0)
3075  {
3076  ssize_t
3077  units;
3078 
3079  if (*option == '+')
3080  break;
3081  i++;
3082  if (i == (ssize_t) argc)
3083  ThrowConvertException(OptionError,"MissingArgument",option);
3084  units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
3085  argv[i]);
3086  if (units < 0)
3087  ThrowConvertException(OptionError,"UnrecognizedUnitsType",
3088  argv[i]);
3089  break;
3090  }
3091  if (LocaleCompare("unsharp",option+1) == 0)
3092  {
3093  if (*option == '+')
3094  break;
3095  i++;
3096  if (i == (ssize_t) argc)
3097  ThrowConvertException(OptionError,"MissingArgument",option);
3098  if (IsGeometry(argv[i]) == MagickFalse)
3099  ThrowConvertInvalidArgumentException(option,argv[i]);
3100  break;
3101  }
3102  ThrowConvertException(OptionError,"UnrecognizedOption",option)
3103  }
3104  case 'v':
3105  {
3106  if (LocaleCompare("verbose",option+1) == 0)
3107  break;
3108  if ((LocaleCompare("version",option+1) == 0) ||
3109  (LocaleCompare("-version",option+1) == 0))
3110  {
3111  ListMagickVersion(stdout);
3112  break;
3113  }
3114  if (LocaleCompare("view",option+1) == 0)
3115  {
3116  if (*option == '+')
3117  break;
3118  i++;
3119  if (i == (ssize_t) argc)
3120  ThrowConvertException(OptionError,"MissingArgument",option);
3121  break;
3122  }
3123  if (LocaleCompare("vignette",option+1) == 0)
3124  {
3125  if (*option == '+')
3126  break;
3127  i++;
3128  if (i == (ssize_t) argc)
3129  ThrowConvertException(OptionError,"MissingArgument",option);
3130  if (IsGeometry(argv[i]) == MagickFalse)
3131  ThrowConvertInvalidArgumentException(option,argv[i]);
3132  break;
3133  }
3134  if (LocaleCompare("virtual-pixel",option+1) == 0)
3135  {
3136  ssize_t
3137  method;
3138 
3139  if (*option == '+')
3140  break;
3141  i++;
3142  if (i == (ssize_t) argc)
3143  ThrowConvertException(OptionError,"MissingArgument",option);
3144  method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
3145  argv[i]);
3146  if (method < 0)
3147  ThrowConvertException(OptionError,
3148  "UnrecognizedVirtualPixelMethod",argv[i]);
3149  break;
3150  }
3151  ThrowConvertException(OptionError,"UnrecognizedOption",option)
3152  }
3153  case 'w':
3154  {
3155  if (LocaleCompare("wave",option+1) == 0)
3156  {
3157  i++;
3158  if (i == (ssize_t) argc)
3159  ThrowConvertException(OptionError,"MissingArgument",option);
3160  if (IsGeometry(argv[i]) == MagickFalse)
3161  ThrowConvertInvalidArgumentException(option,argv[i]);
3162  break;
3163  }
3164  if (LocaleCompare("wavelet-denoise",option+1) == 0)
3165  {
3166  i++;
3167  if (i == (ssize_t) argc)
3168  ThrowConvertException(OptionError,"MissingArgument",option);
3169  if (IsGeometry(argv[i]) == MagickFalse)
3170  ThrowConvertInvalidArgumentException(option,argv[i]);
3171  break;
3172  }
3173  if (LocaleCompare("weight",option+1) == 0)
3174  {
3175  if (*option == '+')
3176  break;
3177  i++;
3178  if (i == (ssize_t) argc)
3179  ThrowConvertException(OptionError,"MissingArgument",option);
3180  break;
3181  }
3182  if (LocaleCompare("white-point",option+1) == 0)
3183  {
3184  if (*option == '+')
3185  break;
3186  i++;
3187  if (i == (ssize_t) argc)
3188  ThrowConvertException(OptionError,"MissingArgument",option);
3189  if (IsGeometry(argv[i]) == MagickFalse)
3190  ThrowConvertInvalidArgumentException(option,argv[i]);
3191  break;
3192  }
3193  if (LocaleCompare("white-threshold",option+1) == 0)
3194  {
3195  if (*option == '+')
3196  break;
3197  i++;
3198  if (i == (ssize_t) argc)
3199  ThrowConvertException(OptionError,"MissingArgument",option);
3200  if (IsGeometry(argv[i]) == MagickFalse)
3201  ThrowConvertInvalidArgumentException(option,argv[i]);
3202  break;
3203  }
3204  if (LocaleCompare("write",option+1) == 0)
3205  {
3206  i++;
3207  if (i == (ssize_t) argc)
3208  ThrowConvertException(OptionError,"MissingArgument",option);
3209  break;
3210  }
3211  ThrowConvertException(OptionError,"UnrecognizedOption",option)
3212  }
3213  case '?':
3214  break;
3215  default:
3216  ThrowConvertException(OptionError,"UnrecognizedOption",option)
3217  }
3218  fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
3219  FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
3220  if (fire != MagickFalse)
3221  FireImageStack(MagickTrue,MagickTrue,MagickTrue);
3222  }
3223  if (k != 0)
3224  ThrowConvertException(OptionError,"UnbalancedParenthesis",argv[i]);
3225  if (i-- != (ssize_t) (argc-1))
3226  ThrowConvertException(OptionError,"MissingAnImageFilename",argv[argc-1]);
3227  FinalizeImageSettings(image_info,image,MagickTrue);
3228  if (image == (Image *) NULL)
3229  ThrowConvertException(OptionError,"NoImagesDefined",argv[argc-1]);
3230  if (IsCommandOption(argv[argc-1]))
3231  ThrowConvertException(OptionError,"MissingAnImageFilename",argv[argc-1]);
3232  if (LocaleCompare(" ",argv[argc-1]) == 0) /* common line continuation error */
3233  ThrowConvertException(OptionError,"MissingAnImageFilename",argv[argc-1]);
3234  status&=WriteImages(image_info,image,argv[argc-1],exception);
3235  if (metadata != (char **) NULL)
3236  {
3237  char
3238  *text;
3239 
3240  text=InterpretImageProperties(image_info,image,format);
3241  InheritException(exception,&image->exception);
3242  if (text == (char *) NULL)
3243  ThrowConvertException(ResourceLimitError,"MemoryAllocationFailed",
3244  GetExceptionMessage(errno));
3245  (void) ConcatenateString(&(*metadata),text);
3246  text=DestroyString(text);
3247  }
3248  DestroyConvert();
3249  return(status != 0 ? MagickTrue : MagickFalse);
3250 }