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