Context Navigation

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

Revision 7737, 109.8 KB checked in by cristy, 13 months ago (diff)

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

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

Download in other formats: