Context Navigation

source: ImageMagick/branches/ImageMagick-6/wand/convert.c @ 8157

Revision 8157, 110.3 KB checked in by anthony, 12 months ago (diff)
Rename of 'bicubic' interpolation to more precise 'catrom'.

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: