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