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