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