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