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