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