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