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