MagickWand 7.1.2-32
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
mogrify.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% M M OOO GGGGG RRRR IIIII FFFFF Y Y %
7% MM MM O O G R R I F Y Y %
8% M M M O O G GGG RRRR I FFF Y %
9% M M O O G G R R I F Y %
10% M M OOO GGGG R R IIIII F Y %
11% %
12% %
13% MagickWand Module Methods %
14% %
15% Software Design %
16% Cristy %
17% March 2000 %
18% %
19% %
20% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
21% dedicated to making software imaging solutions freely available. %
22% %
23% You may not use this file except in compliance with the License. You may %
24% obtain a copy of the License at %
25% %
26% https://imagemagick.org/license/ %
27% %
28% Unless required by applicable law or agreed to in writing, software %
29% distributed under the License is distributed on an "AS IS" BASIS, %
30% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31% See the License for the specific language governing permissions and %
32% limitations under the License. %
33% %
34%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35%
36% Use the mogrify program to resize an image, blur, crop, despeckle, dither,
37% draw on, flip, join, re-sample, and much more. This tool is similar to
38% convert except that the original image file is overwritten (unless you
39% change the file suffix with the -format option) with any changes you
40% request.
41%
42% This embeds the legacy command-line parser as opposed to operation.c which
43% embeds the modern parser designed for the execution in a strict one option
44% at a time manner that is needed for 'pipelining and file scripting' of
45% options in IMv7.
46%
47*/
48␌
49/*
50 Include declarations.
51*/
52#include "MagickWand/studio.h"
53#include "MagickWand/MagickWand.h"
54#include "MagickWand/magick-wand-private.h"
55#include "MagickWand/mogrify-private.h"
56#include "MagickCore/blob-private.h"
57#include "MagickCore/color-private.h"
58#include "MagickCore/composite-private.h"
59#include "MagickCore/geometry-private.h"
60#include "MagickCore/image-private.h"
61#include "MagickCore/monitor-private.h"
62#include "MagickCore/profile-private.h"
63#include "MagickCore/string-private.h"
64#include "MagickCore/thread-private.h"
65#include "MagickCore/timer-private.h"
66#include "MagickCore/utility-private.h"
67␌
68/*
69 Constant declaration.
70*/
71static const char
72 MogrifyAlphaColor[] = "#bdbdbd", /* gray */
73 MogrifyBackgroundColor[] = "#ffffff", /* white */
74 MogrifyBorderColor[] = "#dfdfdf"; /* gray */
75␌
76/*
77 Define declarations.
78*/
79#define UndefinedCompressionQuality 0UL
80␌
81/*
82%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
83% %
84% %
85% %
86+ M o g r i f y I m a g e %
87% %
88% %
89% %
90%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
91%
92% MogrifyImage() applies simple single image processing options to a single
93% image that may be part of a large list, but also handles any 'region'
94% image handling.
95%
96% The image in the list may be modified in three different ways...
97%
98% * directly modified (EG: -negate, -gamma, -level, -annotate, -draw),
99% * replaced by a new image (EG: -spread, -resize, -rotate, -morphology)
100% * replace by a list of images (only the -separate option!)
101%
102% In each case the result is returned into the list, and a pointer to the
103% modified image (last image added if replaced by a list of images) is
104% returned.
105%
106% ASIDE: The -crop is present but restricted to non-tile single image crops
107%
108% This means if all the images are being processed (such as by
109% MogrifyImages(), next image to be processed will be as per the pointer
110% (*image)->next. Also the image list may grow as a result of some specific
111% operations but as images are never merged or deleted, it will never shrink
112% in length. Typically the list will remain the same length.
113%
114% WARNING: As the image pointed to may be replaced, the first image in the
115% list may also change. GetFirstImageInList() should be used by caller if
116% they wish return the Image pointer to the first image in list.
117%
118%
119% The format of the MogrifyImage method is:
120%
121% MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
122% const char **argv,Image **image)
123%
124% A description of each parameter follows:
125%
126% o image_info: the image info..
127%
128% o argc: Specifies a pointer to an integer describing the number of
129% elements in the argument vector.
130%
131% o argv: Specifies a pointer to a text array containing the command line
132% arguments.
133%
134% o image: the image.
135%
136% o exception: return any errors or warnings in this structure.
137%
138*/
139
140static inline Image *GetImageCache(const ImageInfo *image_info,const char *path,
141 ExceptionInfo *exception)
142{
143 char
144 key[MagickPathExtent];
145
146 ExceptionInfo
147 *sans_exception;
148
149 Image
150 *image;
151
152 ImageInfo
153 *read_info;
154
155 /*
156 Read an image into a image cache (for repeated usage) if not already in
157 cache. Then return the image that is in the cache.
158 */
159 (void) FormatLocaleString(key,MagickPathExtent,"cache:%s",path);
160 sans_exception=AcquireExceptionInfo();
161 image=(Image *) GetImageRegistry(ImageRegistryType,key,sans_exception);
162 sans_exception=DestroyExceptionInfo(sans_exception);
163 if (image != (Image *) NULL)
164 return(image);
165 read_info=CloneImageInfo(image_info);
166 (void) CopyMagickString(read_info->filename,path,MagickPathExtent);
167 image=ReadImage(read_info,exception);
168 read_info=DestroyImageInfo(read_info);
169 if (image != (Image *) NULL)
170 (void) SetImageRegistry(ImageRegistryType,key,image,exception);
171 return(image);
172}
173
174static inline MagickBooleanType IsPathWritable(const char *path)
175{
176 if (IsPathAccessible(path) == MagickFalse)
177 return(MagickFalse);
178 if (access_utf8(path,W_OK) != 0)
179 return(MagickFalse);
180 return(MagickTrue);
181}
182
183static MagickBooleanType MonitorProgress(const char *text,
184 const MagickOffsetType offset,const MagickSizeType extent,
185 void *wand_unused(client_data))
186{
187 char
188 message[MagickPathExtent],
189 tag[MagickPathExtent];
190
191 const char
192 *locale_message;
193
194 char
195 *p;
196
197 magick_unreferenced(client_data);
198
199 if ((extent <= 1) || (offset < 0) || (offset >= (MagickOffsetType) extent))
200 return(MagickTrue);
201 if ((offset != (MagickOffsetType) (extent-1)) && ((offset % 50) != 0))
202 return(MagickTrue);
203 (void) CopyMagickString(tag,text == (const char *) NULL ? "null" : text,
204 MagickPathExtent);
205 p=strrchr(tag,'/');
206 if (p != (char *) NULL)
207 *p='\0';
208 (void) FormatLocaleString(message,MagickPathExtent,"Monitor/%s",tag);
209 locale_message=GetLocaleMessage(message);
210 if (locale_message == message)
211 locale_message=tag;
212 if (p == (char *) NULL)
213 (void) FormatLocaleFile(stderr,"%s: %ld of %lu, %02ld%% complete\r",
214 locale_message,(long) offset,(unsigned long) extent,(long)
215 (100.0*offset*MagickSafeReciprocal((double) extent-1.0)));
216 else
217 (void) FormatLocaleFile(stderr,"%s[%s]: %ld of %lu, %02ld%% complete\r",
218 locale_message,p+1,(long) offset,(unsigned long) extent,(long)
219 (100.0*offset*MagickSafeReciprocal((double) extent-1.0)));
220 if (offset == (MagickOffsetType) (extent-1))
221 (void) FormatLocaleFile(stderr,"\n");
222 (void) fflush(stderr);
223 return(MagickTrue);
224}
225
226static Image *SparseColorOption(const Image *image,
227 const SparseColorMethod method,const char *arguments,
228 const MagickBooleanType color_from_image,ExceptionInfo *exception)
229{
230 char
231 token[MagickPathExtent];
232
233 const char
234 *p;
235
236 double
237 *sparse_arguments;
238
239 Image
240 *sparse_image;
241
242 MagickBooleanType
243 error;
244
245 PixelInfo
246 color;
247
248 size_t
249 x;
250
251 size_t
252 number_arguments,
253 number_colors;
254
255 /*
256 SparseColorOption() parses the complex -sparse-color argument into an an
257 array of floating point values then calls SparseColorImage(). Argument is
258 a complex mix of floating-point pixel coordinates, and color specifications
259 (or direct floating point numbers). The number of floats needed to
260 represent a color varies depending on the current channel setting.
261 */
262 assert(image != (Image *) NULL);
263 assert(image->signature == MagickCoreSignature);
264 assert(exception != (ExceptionInfo *) NULL);
265 assert(exception->signature == MagickCoreSignature);
266 if (IsEventLogging() != MagickFalse)
267 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
268 /*
269 Limit channels according to image - and add up number of color channel.
270 */
271 number_colors=0;
272 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
273 number_colors++;
274 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
275 number_colors++;
276 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
277 number_colors++;
278 if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
279 (image->colorspace == CMYKColorspace))
280 number_colors++;
281 if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
282 (image->alpha_trait != UndefinedPixelTrait))
283 number_colors++;
284
285 /*
286 Read string, to determine number of arguments needed,
287 */
288 p=arguments;
289 x=0;
290 while( *p != '\0' )
291 {
292 (void) GetNextToken(p,&p,MagickPathExtent,token);
293 if (*token == ',') continue;
294 if ( isalpha((int) ((unsigned char) *token)) || (*token == '#')) {
295 if ( color_from_image ) {
296 (void) ThrowMagickException(exception,GetMagickModule(),
297 OptionError, "InvalidArgument", "'%s': %s", "sparse-color",
298 "Color arg given, when colors are coming from image");
299 return( (Image *) NULL);
300 }
301 x += number_colors; /* color argument */
302 }
303 else {
304 x++; /* floating point argument */
305 }
306 }
307 error=MagickTrue;
308 if ( color_from_image ) {
309 /* just the control points are being given */
310 error = ( x % 2 != 0 ) ? MagickTrue : MagickFalse;
311 number_arguments=(x/2)*(2+number_colors);
312 }
313 else {
314 /* control points and color values */
315 error = ( x % (2+number_colors) != 0 ) ? MagickTrue : MagickFalse;
316 number_arguments=x;
317 }
318 if ( error ) {
319 (void) ThrowMagickException(exception,GetMagickModule(),
320 OptionError, "InvalidArgument", "'%s': %s", "sparse-color",
321 "Invalid number of Arguments");
322 return( (Image *) NULL);
323 }
324
325 /* Allocate and fill in the floating point arguments */
326 sparse_arguments=(double *) AcquireQuantumMemory(number_arguments,
327 sizeof(*sparse_arguments));
328 if (sparse_arguments == (double *) NULL) {
329 (void) ThrowMagickException(exception,GetMagickModule(),ResourceLimitError,
330 " MemoryAllocationFailed\n""%s","SparseColorOption");
331 return( (Image *) NULL);
332 }
333 (void) memset(sparse_arguments,0,number_arguments*
334 sizeof(*sparse_arguments));
335 p=arguments;
336 x=0;
337 while ((*p != '\0') && (x < number_arguments))
338 {
339 /* X coordinate */
340 *token=',';
341 while (*token == ',')
342 (void) GetNextToken(p,&p,MagickPathExtent,token);
343 if (*token == '\0') break;
344 if (isalpha((int) ((unsigned char) *token)) || (*token == '#'))
345 {
346 (void) ThrowMagickException(exception,GetMagickModule(),
347 OptionError, "InvalidArgument", "'%s': %s", "sparse-color",
348 "Color found, instead of X-coord");
349 error=MagickTrue;
350 break;
351 }
352 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
353 /* Y coordinate */
354 *token=',';
355 while (*token == ',')
356 (void) GetNextToken(p,&p,MagickPathExtent,token);
357 if (*token == '\0')
358 break;
359 if (isalpha((int) ((unsigned char) *token)) || (*token == '#'))
360 {
361 (void) ThrowMagickException(exception,GetMagickModule(),
362 OptionError, "InvalidArgument", "'%s': %s", "sparse-color",
363 "Color found, instead of Y-coord");
364 error = MagickTrue;
365 break;
366 }
367 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
368 /* color values for this control point */
369#if 0
370 if ( (color_from_image ) {
371 /* get color from image */
372 /* HOW??? */
373 }
374 else
375#endif
376 {
377 /* color name or function given in string argument */
378 *token=',';
379 while (*token == ',')
380 (void) GetNextToken(p,&p,MagickPathExtent,token);
381 if (*token == '\0')
382 break;
383 if (isalpha((int) ((unsigned char) *token)) || (*token == '#'))
384 {
385 /* Color string given */
386 (void) QueryColorCompliance(token,AllCompliance,&color,exception);
387 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
388 sparse_arguments[x++] = QuantumScale*color.red;
389 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
390 sparse_arguments[x++] = QuantumScale*color.green;
391 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
392 sparse_arguments[x++] = QuantumScale*color.blue;
393 if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
394 (image->colorspace == CMYKColorspace))
395 sparse_arguments[x++] = QuantumScale*color.black;
396 if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
397 (image->alpha_trait != UndefinedPixelTrait))
398 sparse_arguments[x++] = QuantumScale*color.alpha;
399 }
400 else {
401 /* Colors given as a set of floating point values - experimental */
402 /* NB: token contains the first floating point value to use! */
403 if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
404 {
405 while (*token == ',')
406 (void) GetNextToken(p,&p,MagickPathExtent,token);
407 if ((*token == '\0') || isalpha((int) ((unsigned char) *token)) ||
408 (*token == '#'))
409 break;
410 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
411 *token = ','; /* used this token - get another */
412 }
413 if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
414 {
415 while (*token == ',')
416 (void) GetNextToken(p,&p,MagickPathExtent,token);
417 if ((*token == '\0') || isalpha((int) ((unsigned char) *token)) ||
418 (*token == '#'))
419 break;
420 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
421 *token = ','; /* used this token - get another */
422 }
423 if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
424 {
425 while (*token == ',')
426 (void) GetNextToken(p,&p,MagickPathExtent,token);
427 if ((*token == '\0') || isalpha((int) ((unsigned char) *token)) ||
428 (*token == '#'))
429 break;
430 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
431 *token = ','; /* used this token - get another */
432 }
433 if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
434 (image->colorspace == CMYKColorspace))
435 {
436 while (*token == ',')
437 (void) GetNextToken(p,&p,MagickPathExtent,token);
438 if ((*token == '\0') || isalpha((int) ((unsigned char) *token)) ||
439 (*token == '#'))
440 break;
441 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
442 *token=','; /* used this token - get another */
443 }
444 if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
445 (image->alpha_trait != UndefinedPixelTrait))
446 {
447 while (*token == ',')
448 (void) GetNextToken(p,&p,MagickPathExtent,token);
449 if ((*token == '\0') || isalpha((int) ((unsigned char) *token)) ||
450 (*token == '#'))
451 break;
452 sparse_arguments[x++]=StringToDouble(token,(char **) NULL);
453 *token = ','; /* used this token - get another */
454 }
455 }
456 }
457 }
458 if ((number_arguments != x) && (!error))
459 {
460 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
461 " InvalidArgument","'%s': %s","sparse-color","Argument Parsing Error");
462 sparse_arguments=(double *) RelinquishMagickMemory(sparse_arguments);
463 return((Image *) NULL);
464 }
465 if (error)
466 return((Image *) NULL);
467 /*
468 Call the Interpolation function with the parsed arguments.
469 */
470 sparse_image=SparseColorImage(image,method,number_arguments,sparse_arguments,
471 exception);
472 sparse_arguments=(double *) RelinquishMagickMemory(sparse_arguments);
473 return( sparse_image );
474}
475
476WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
477 const char **argv,Image **image,ExceptionInfo *exception)
478{
479 CompositeOperator
480 compose;
481
482 const char
483 *format,
484 *option;
485
486 double
487 attenuate;
488
489 DrawInfo
490 *draw_info;
491
492 GeometryInfo
493 geometry_info;
494
495 ImageInfo
496 *mogrify_info;
497
498 MagickStatusType
499 status;
500
501 PixelInfo
502 fill;
503
504 MagickStatusType
505 flags;
506
507 PixelInterpolateMethod
508 interpolate_method;
509
510 QuantizeInfo
511 *quantize_info;
512
513 RectangleInfo
514 geometry,
515 region_geometry;
516
517 ssize_t
518 i;
519
520 /*
521 Initialize method variables.
522 */
523 assert(image_info != (const ImageInfo *) NULL);
524 assert(image_info->signature == MagickCoreSignature);
525 assert(image != (Image **) NULL);
526 assert((*image)->signature == MagickCoreSignature);
527 if (IsEventLogging() != MagickFalse)
528 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
529 if (argc < 0)
530 return(MagickTrue);
531 mogrify_info=CloneImageInfo(image_info);
532 draw_info=CloneDrawInfo(mogrify_info,(DrawInfo *) NULL);
533 quantize_info=AcquireQuantizeInfo(mogrify_info);
534 SetGeometryInfo(&geometry_info);
535 GetPixelInfo(*image,&fill);
536 fill=(*image)->background_color;
537 attenuate=1.0;
538 compose=(*image)->compose;
539 interpolate_method=UndefinedInterpolatePixel;
540 format=GetImageOption(mogrify_info,"format");
541 SetGeometry(*image,&region_geometry);
542 /*
543 Transmogrify the image.
544 */
545 for (i=0; i < (ssize_t) argc; i++)
546 {
547 Image
548 *mogrify_image;
549
550 ssize_t
551 count;
552
553 option=argv[i];
554 if (IsCommandOption(option) == MagickFalse)
555 continue;
556 count=MagickMax(ParseCommandOption(MagickCommandOptions,MagickFalse,option),
557 0L);
558 if ((i+count) >= (ssize_t) argc)
559 break;
560 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception);
561 mogrify_image=(Image *) NULL;
562 switch (*(option+1))
563 {
564 case 'a':
565 {
566 if (LocaleCompare("adaptive-blur",option+1) == 0)
567 {
568 /*
569 Adaptive blur image.
570 */
571 (void) SyncImageSettings(mogrify_info,*image,exception);
572 flags=ParseGeometry(argv[i+1],&geometry_info);
573 if ((flags & SigmaValue) == 0)
574 geometry_info.sigma=1.0;
575 mogrify_image=AdaptiveBlurImage(*image,geometry_info.rho,
576 geometry_info.sigma,exception);
577 break;
578 }
579 if (LocaleCompare("adaptive-resize",option+1) == 0)
580 {
581 /*
582 Adaptive resize image.
583 */
584 (void) SyncImageSettings(mogrify_info,*image,exception);
585 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
586 mogrify_image=AdaptiveResizeImage(*image,geometry.width,
587 geometry.height,exception);
588 break;
589 }
590 if (LocaleCompare("adaptive-sharpen",option+1) == 0)
591 {
592 /*
593 Adaptive sharpen image.
594 */
595 (void) SyncImageSettings(mogrify_info,*image,exception);
596 flags=ParseGeometry(argv[i+1],&geometry_info);
597 if ((flags & SigmaValue) == 0)
598 geometry_info.sigma=1.0;
599 mogrify_image=AdaptiveSharpenImage(*image,geometry_info.rho,
600 geometry_info.sigma,exception);
601 break;
602 }
603 if (LocaleCompare("affine",option+1) == 0)
604 {
605 /*
606 Affine matrix.
607 */
608 if (*option == '+')
609 {
610 GetAffineMatrix(&draw_info->affine);
611 break;
612 }
613 (void) ParseAffineGeometry(argv[i+1],&draw_info->affine,exception);
614 break;
615 }
616 if (LocaleCompare("alpha",option+1) == 0)
617 {
618 AlphaChannelOption
619 alpha_type;
620
621 (void) SyncImageSettings(mogrify_info,*image,exception);
622 alpha_type=(AlphaChannelOption) ParseCommandOption(
623 MagickAlphaChannelOptions,MagickFalse,argv[i+1]);
624 (void) SetImageAlphaChannel(*image,alpha_type,exception);
625 break;
626 }
627 if (LocaleCompare("annotate",option+1) == 0)
628 {
629 char
630 *text,
631 geometry_str[MagickPathExtent];
632
633 /*
634 Annotate image.
635 */
636 (void) SyncImageSettings(mogrify_info,*image,exception);
637 SetGeometryInfo(&geometry_info);
638 flags=ParseGeometry(argv[i+1],&geometry_info);
639 if ((flags & SigmaValue) == 0)
640 geometry_info.sigma=geometry_info.rho;
641 text=InterpretImageProperties(mogrify_info,*image,argv[i+2],
642 exception);
643 if (text == (char *) NULL)
644 break;
645 (void) CloneString(&draw_info->text,text);
646 text=DestroyString(text);
647 (void) FormatLocaleString(geometry_str,MagickPathExtent,"%+f%+f",
648 geometry_info.xi,geometry_info.psi);
649 (void) CloneString(&draw_info->geometry,geometry_str);
650 draw_info->affine.sx=cos(DegreesToRadians(
651 fmod(geometry_info.rho,360.0)));
652 draw_info->affine.rx=sin(DegreesToRadians(
653 fmod(geometry_info.rho,360.0)));
654 draw_info->affine.ry=(-sin(DegreesToRadians(
655 fmod(geometry_info.sigma,360.0))));
656 draw_info->affine.sy=cos(DegreesToRadians(
657 fmod(geometry_info.sigma,360.0)));
658 (void) AnnotateImage(*image,draw_info,exception);
659 break;
660 }
661 if (LocaleCompare("antialias",option+1) == 0)
662 {
663 draw_info->stroke_antialias=(*option == '-') ? MagickTrue :
664 MagickFalse;
665 draw_info->text_antialias=(*option == '-') ? MagickTrue :
666 MagickFalse;
667 break;
668 }
669 if (LocaleCompare("attenuate",option+1) == 0)
670 {
671 if (*option == '+')
672 {
673 attenuate=1.0;
674 break;
675 }
676 attenuate=StringToDouble(argv[i+1],(char **) NULL);
677 break;
678 }
679 if (LocaleCompare("auto-gamma",option+1) == 0)
680 {
681 /*
682 Auto Adjust Gamma of image based on its mean.
683 */
684 (void) SyncImageSettings(mogrify_info,*image,exception);
685 (void) AutoGammaImage(*image,exception);
686 break;
687 }
688 if (LocaleCompare("auto-level",option+1) == 0)
689 {
690 /*
691 Perfectly Normalize (max/min stretch) the image.
692 */
693 (void) SyncImageSettings(mogrify_info,*image,exception);
694 (void) AutoLevelImage(*image,exception);
695 break;
696 }
697 if (LocaleCompare("auto-orient",option+1) == 0)
698 {
699 (void) SyncImageSettings(mogrify_info,*image,exception);
700 mogrify_image=AutoOrientImage(*image,(*image)->orientation,
701 exception);
702 break;
703 }
704 if (LocaleCompare("auto-threshold",option+1) == 0)
705 {
706 AutoThresholdMethod
707 method;
708
709 (void) SyncImageSettings(mogrify_info,*image,exception);
710 method=(AutoThresholdMethod) ParseCommandOption(
711 MagickAutoThresholdOptions,MagickFalse,argv[i+1]);
712 (void) AutoThresholdImage(*image,method,exception);
713 break;
714 }
715 break;
716 }
717 case 'b':
718 {
719 if (LocaleCompare("bilateral-blur",option+1) == 0)
720 {
721 /*
722 Bilateral filter image.
723 */
724 (void) SyncImageSettings(mogrify_info,*image,exception);
725 flags=ParseGeometry(argv[i+1],&geometry_info);
726 if ((flags & SigmaValue) == 0)
727 geometry_info.sigma=geometry_info.rho;
728 if ((flags & XiValue) == 0)
729 geometry_info.xi=1.0*sqrt(geometry_info.rho*geometry_info.rho+
730 geometry_info.sigma*geometry_info.sigma);
731 if ((flags & PsiValue) == 0)
732 geometry_info.psi=0.25*sqrt(geometry_info.rho*geometry_info.rho+
733 geometry_info.sigma*geometry_info.sigma);
734 mogrify_image=BilateralBlurImage(*image,(size_t) geometry_info.rho,
735 (size_t) geometry_info.sigma,geometry_info.xi,geometry_info.psi,
736 exception);
737 break;
738 }
739 if (LocaleCompare("black-threshold",option+1) == 0)
740 {
741 /*
742 Black threshold image.
743 */
744 (void) SyncImageSettings(mogrify_info,*image,exception);
745 (void) BlackThresholdImage(*image,argv[i+1],exception);
746 break;
747 }
748 if (LocaleCompare("blue-shift",option+1) == 0)
749 {
750 /*
751 Blue shift image.
752 */
753 (void) SyncImageSettings(mogrify_info,*image,exception);
754 geometry_info.rho=1.5;
755 if (*option == '-')
756 flags=ParseGeometry(argv[i+1],&geometry_info);
757 mogrify_image=BlueShiftImage(*image,geometry_info.rho,exception);
758 break;
759 }
760 if (LocaleCompare("blur",option+1) == 0)
761 {
762 /*
763 Gaussian blur image.
764 */
765 (void) SyncImageSettings(mogrify_info,*image,exception);
766 flags=ParseGeometry(argv[i+1],&geometry_info);
767 if ((flags & SigmaValue) == 0)
768 geometry_info.sigma=1.0;
769 if ((flags & XiValue) == 0)
770 geometry_info.xi=0.0;
771 mogrify_image=BlurImage(*image,geometry_info.rho,
772 geometry_info.sigma,exception);
773 break;
774 }
775 if (LocaleCompare("border",option+1) == 0)
776 {
777 /*
778 Surround image with a border of solid color.
779 */
780 (void) SyncImageSettings(mogrify_info,*image,exception);
781 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
782 mogrify_image=BorderImage(*image,&geometry,compose,exception);
783 break;
784 }
785 if (LocaleCompare("bordercolor",option+1) == 0)
786 {
787 if (*option == '+')
788 {
789 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance,
790 &draw_info->border_color,exception);
791 break;
792 }
793 (void) QueryColorCompliance(argv[i+1],AllCompliance,
794 &draw_info->border_color,exception);
795 break;
796 }
797 if (LocaleCompare("box",option+1) == 0)
798 {
799 (void) QueryColorCompliance(argv[i+1],AllCompliance,
800 &draw_info->undercolor,exception);
801 break;
802 }
803 if (LocaleCompare("brightness-contrast",option+1) == 0)
804 {
805 double
806 brightness,
807 contrast;
808
809 /*
810 Brightness / contrast image.
811 */
812 (void) SyncImageSettings(mogrify_info,*image,exception);
813 flags=ParseGeometry(argv[i+1],&geometry_info);
814 brightness=geometry_info.rho;
815 contrast=0.0;
816 if ((flags & SigmaValue) != 0)
817 contrast=geometry_info.sigma;
818 (void) BrightnessContrastImage(*image,brightness,contrast,
819 exception);
820 break;
821 }
822 break;
823 }
824 case 'c':
825 {
826 if (LocaleCompare("canny",option+1) == 0)
827 {
828 /*
829 Detect edges in the image.
830 */
831 (void) SyncImageSettings(mogrify_info,*image,exception);
832 flags=ParseGeometry(argv[i+1],&geometry_info);
833 if ((flags & SigmaValue) == 0)
834 geometry_info.sigma=1.0;
835 if ((flags & XiValue) == 0)
836 geometry_info.xi=0.10;
837 if ((flags & PsiValue) == 0)
838 geometry_info.psi=0.30;
839 if ((flags & PercentValue) != 0)
840 {
841 geometry_info.xi/=100.0;
842 geometry_info.psi/=100.0;
843 }
844 mogrify_image=CannyEdgeImage(*image,geometry_info.rho,
845 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
846 break;
847 }
848 if (LocaleCompare("cdl",option+1) == 0)
849 {
850 char
851 *color_correction_collection;
852
853 /*
854 Color correct with a color decision list.
855 */
856 (void) SyncImageSettings(mogrify_info,*image,exception);
857 color_correction_collection=FileToString(argv[i+1],~0UL,exception);
858 if (color_correction_collection == (char *) NULL)
859 break;
860 (void) ColorDecisionListImage(*image,color_correction_collection,
861 exception);
862 break;
863 }
864 if (LocaleCompare("channel",option+1) == 0)
865 {
866 ChannelType
867 channel;
868
869 (void) SyncImageSettings(mogrify_info,*image,exception);
870 if (*option == '+')
871 {
872 (void) SetPixelChannelMask(*image,DefaultChannels);
873 break;
874 }
875 channel=(ChannelType) ParseChannelOption(argv[i+1]);
876 (void) SetPixelChannelMask(*image,channel);
877 break;
878 }
879 if (LocaleCompare("charcoal",option+1) == 0)
880 {
881 /*
882 Charcoal image.
883 */
884 (void) SyncImageSettings(mogrify_info,*image,exception);
885 flags=ParseGeometry(argv[i+1],&geometry_info);
886 if ((flags & SigmaValue) == 0)
887 geometry_info.sigma=1.0;
888 if ((flags & XiValue) == 0)
889 geometry_info.xi=1.0;
890 mogrify_image=CharcoalImage(*image,geometry_info.rho,
891 geometry_info.sigma,exception);
892 break;
893 }
894 if (LocaleCompare("chop",option+1) == 0)
895 {
896 /*
897 Chop the image.
898 */
899 (void) SyncImageSettings(mogrify_info,*image,exception);
900 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
901 mogrify_image=ChopImage(*image,&geometry,exception);
902 break;
903 }
904 if (LocaleCompare("clahe",option+1) == 0)
905 {
906 /*
907 Contrast limited adaptive histogram equalization.
908 */
909 (void) SyncImageSettings(mogrify_info,*image,exception);
910 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
911 flags=ParseGeometry(argv[i+1],&geometry_info);
912 (void) CLAHEImage(*image,geometry.width,geometry.height,
913 (size_t) geometry.x,geometry_info.psi,exception);
914 break;
915 }
916 if (LocaleCompare("clip",option+1) == 0)
917 {
918 (void) SyncImageSettings(mogrify_info,*image,exception);
919 if (*option == '+')
920 {
921 (void) SetImageMask(*image,WritePixelMask,(const Image *) NULL,
922 exception);
923 break;
924 }
925 (void) ClipImage(*image,exception);
926 break;
927 }
928 if (LocaleCompare("clip-mask",option+1) == 0)
929 {
930 Image
931 *clip_mask;
932
933 (void) SyncImageSettings(mogrify_info,*image,exception);
934 if (*option == '+')
935 {
936 /*
937 Remove a mask.
938 */
939 (void) SetImageMask(*image,WritePixelMask,(const Image *) NULL,
940 exception);
941 break;
942 }
943 /*
944 Set the image mask.
945 */
946 clip_mask=GetImageCache(mogrify_info,argv[i+1],exception);
947 if (clip_mask == (Image *) NULL)
948 break;
949 (void) SetImageMask(*image,WritePixelMask,clip_mask,exception);
950 clip_mask=DestroyImage(clip_mask);
951 break;
952 }
953 if (LocaleCompare("clip-path",option+1) == 0)
954 {
955 (void) SyncImageSettings(mogrify_info,*image,exception);
956 (void) ClipImagePath(*image,argv[i+1],*option == '-' ? MagickTrue :
957 MagickFalse,exception);
958 break;
959 }
960 if (LocaleCompare("colorize",option+1) == 0)
961 {
962 /*
963 Colorize the image.
964 */
965 (void) SyncImageSettings(mogrify_info,*image,exception);
966 mogrify_image=ColorizeImage(*image,argv[i+1],&fill,exception);
967 break;
968 }
969 if (LocaleCompare("color-matrix",option+1) == 0)
970 {
971 KernelInfo
972 *kernel;
973
974 (void) SyncImageSettings(mogrify_info,*image,exception);
975 kernel=AcquireKernelInfo(argv[i+1],exception);
976 if (kernel == (KernelInfo *) NULL)
977 break;
978 /* FUTURE: check on size of the matrix */
979 mogrify_image=ColorMatrixImage(*image,kernel,exception);
980 kernel=DestroyKernelInfo(kernel);
981 break;
982 }
983 if (LocaleCompare("colors",option+1) == 0)
984 {
985 /*
986 Reduce the number of colors in the image.
987 */
988 (void) SyncImageSettings(mogrify_info,*image,exception);
989 quantize_info->number_colors=StringToUnsignedLong(argv[i+1]);
990 if (quantize_info->number_colors == 0)
991 break;
992 if (((*image)->storage_class == DirectClass) ||
993 (*image)->colors > quantize_info->number_colors)
994 (void) QuantizeImage(quantize_info,*image,exception);
995 else
996 (void) CompressImageColormap(*image,exception);
997 break;
998 }
999 if (LocaleCompare("colorspace",option+1) == 0)
1000 {
1001 ColorspaceType
1002 colorspace;
1003
1004 (void) SyncImageSettings(mogrify_info,*image,exception);
1005 if (*option == '+')
1006 {
1007 (void) TransformImageColorspace(*image,sRGBColorspace,
1008 exception);
1009 break;
1010 }
1011 colorspace=(ColorspaceType) ParseCommandOption(
1012 MagickColorspaceOptions,MagickFalse,argv[i+1]);
1013 (void) TransformImageColorspace(*image,colorspace,exception);
1014 break;
1015 }
1016 if (LocaleCompare("color-threshold",option+1) == 0)
1017 {
1018 PixelInfo
1019 start,
1020 stop;
1021
1022 /*
1023 Color threshold image.
1024 */
1025 (void) SyncImageSettings(mogrify_info,*image,exception);
1026 if (*option == '+')
1027 (void) GetColorRange("white-black",&start,&stop,exception);
1028 else
1029 (void) GetColorRange(argv[i+1],&start,&stop,exception);
1030 (void) ColorThresholdImage(*image,&start,&stop,exception);
1031 break;
1032 }
1033 if (LocaleCompare("compose",option+1) == 0)
1034 {
1035 (void) SyncImageSettings(mogrify_info,*image,exception);
1036 compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
1037 MagickFalse,argv[i+1]);
1038 break;
1039 }
1040 if (LocaleCompare("connected-components",option+1) == 0)
1041 {
1042 (void) SyncImageSettings(mogrify_info,*image,exception);
1043 mogrify_image=ConnectedComponentsImage(*image,(size_t)
1044 StringToInteger(argv[i+1]),(CCObjectInfo **) NULL,exception);
1045 break;
1046 }
1047 if (LocaleCompare("contrast",option+1) == 0)
1048 {
1049 (void) SyncImageSettings(mogrify_info,*image,exception);
1050 (void) ContrastImage(*image,(*option == '-') ? MagickTrue :
1051 MagickFalse,exception);
1052 break;
1053 }
1054 if (LocaleCompare("contrast-stretch",option+1) == 0)
1055 {
1056 double
1057 black_point,
1058 white_point;
1059
1060 /*
1061 Contrast stretch image.
1062 */
1063 (void) SyncImageSettings(mogrify_info,*image,exception);
1064 flags=ParseGeometry(argv[i+1],&geometry_info);
1065 black_point=geometry_info.rho;
1066 white_point=(flags & SigmaValue) != 0 ? geometry_info.sigma :
1067 black_point;
1068 if ((flags & PercentValue) != 0)
1069 {
1070 black_point*=(double) (*image)->columns*(*image)->rows/100.0;
1071 white_point*=(double) (*image)->columns*(*image)->rows/100.0;
1072 }
1073 white_point=(double) (*image)->columns*(*image)->rows-
1074 white_point;
1075 (void) ContrastStretchImage(*image,black_point,white_point,
1076 exception);
1077 break;
1078 }
1079 if (LocaleCompare("convolve",option+1) == 0)
1080 {
1081 double
1082 gamma;
1083
1084 KernelInfo
1085 *kernel_info;
1086
1087 ssize_t
1088 j;
1089
1090 size_t
1091 extent;
1092
1093 (void) SyncImageSettings(mogrify_info,*image,exception);
1094 kernel_info=AcquireKernelInfo(argv[i+1],exception);
1095 if (kernel_info == (KernelInfo *) NULL)
1096 break;
1097 extent=kernel_info->width*kernel_info->height;
1098 gamma=0.0;
1099 for (j=0; j < (ssize_t) extent; j++)
1100 gamma+=kernel_info->values[j];
1101 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
1102 for (j=0; j < (ssize_t) extent; j++)
1103 kernel_info->values[j]*=gamma;
1104 mogrify_image=MorphologyImage(*image,CorrelateMorphology,1,
1105 kernel_info,exception);
1106 kernel_info=DestroyKernelInfo(kernel_info);
1107 break;
1108 }
1109 if (LocaleCompare("crop",option+1) == 0)
1110 {
1111 /*
1112 Crop a image to a smaller size
1113 */
1114 (void) SyncImageSettings(mogrify_info,*image,exception);
1115 mogrify_image=CropImageToTiles(*image,argv[i+1],exception);
1116 break;
1117 }
1118 if (LocaleCompare("cycle",option+1) == 0)
1119 {
1120 /*
1121 Cycle an image colormap.
1122 */
1123 (void) SyncImageSettings(mogrify_info,*image,exception);
1124 (void) CycleColormapImage(*image,(ssize_t) StringToLong(argv[i+1]),
1125 exception);
1126 break;
1127 }
1128 break;
1129 }
1130 case 'd':
1131 {
1132 if (LocaleCompare("decipher",option+1) == 0)
1133 {
1134 StringInfo
1135 *passkey;
1136
1137 /*
1138 Decipher pixels.
1139 */
1140 (void) SyncImageSettings(mogrify_info,*image,exception);
1141 passkey=FileToStringInfo(argv[i+1],~0UL,exception);
1142 if (passkey != (StringInfo *) NULL)
1143 {
1144 (void) PasskeyDecipherImage(*image,passkey,exception);
1145 passkey=DestroyStringInfo(passkey);
1146 }
1147 break;
1148 }
1149 if (LocaleCompare("density",option+1) == 0)
1150 {
1151 /*
1152 Set image density.
1153 */
1154 (void) CloneString(&draw_info->density,argv[i+1]);
1155 break;
1156 }
1157 if (LocaleCompare("depth",option+1) == 0)
1158 {
1159 (void) SyncImageSettings(mogrify_info,*image,exception);
1160 if (*option == '+')
1161 {
1162 (void) SetImageDepth(*image,MAGICKCORE_QUANTUM_DEPTH,exception);
1163 break;
1164 }
1165 (void) SetImageDepth(*image,StringToUnsignedLong(argv[i+1]),
1166 exception);
1167 break;
1168 }
1169 if (LocaleCompare("deskew",option+1) == 0)
1170 {
1171 double
1172 threshold;
1173
1174 /*
1175 Straighten the image.
1176 */
1177 (void) SyncImageSettings(mogrify_info,*image,exception);
1178 if (*option == '+')
1179 threshold=40.0*(double) QuantumRange/100.0;
1180 else
1181 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+
1182 1.0);
1183 mogrify_image=DeskewImage(*image,threshold,exception);
1184 break;
1185 }
1186 if (LocaleCompare("despeckle",option+1) == 0)
1187 {
1188 /*
1189 Reduce the speckles within an image.
1190 */
1191 (void) SyncImageSettings(mogrify_info,*image,exception);
1192 mogrify_image=DespeckleImage(*image,exception);
1193 break;
1194 }
1195 if (LocaleCompare("display",option+1) == 0)
1196 {
1197 (void) CloneString(&draw_info->server_name,argv[i+1]);
1198 break;
1199 }
1200 if (LocaleCompare("distort",option+1) == 0)
1201 {
1202 char
1203 *args,
1204 token[MagickPathExtent];
1205
1206 const char
1207 *p;
1208
1209 DistortMethod
1210 method;
1211
1212 double
1213 *arguments;
1214
1215 ssize_t
1216 x;
1217
1218 size_t
1219 number_arguments;
1220
1221 /*
1222 Distort image.
1223 */
1224 (void) SyncImageSettings(mogrify_info,*image,exception);
1225 method=(DistortMethod) ParseCommandOption(MagickDistortOptions,
1226 MagickFalse,argv[i+1]);
1227 if (method == ResizeDistortion)
1228 {
1229 double
1230 resize_args[2];
1231
1232 /*
1233 Special Case - Argument is actually a resize geometry!
1234 Convert that to an appropriate distortion argument array.
1235 */
1236 (void) ParseRegionGeometry(*image,argv[i+2],&geometry,
1237 exception);
1238 resize_args[0]=(double) geometry.width;
1239 resize_args[1]=(double) geometry.height;
1240 mogrify_image=DistortImage(*image,method,(size_t)2,
1241 resize_args,MagickTrue,exception);
1242 break;
1243 }
1244 args=InterpretImageProperties(mogrify_info,*image,argv[i+2],
1245 exception);
1246 if (args == (char *) NULL)
1247 break;
1248 p=(char *) args;
1249 for (x=0; *p != '\0'; x++)
1250 {
1251 (void) GetNextToken(p,&p,MagickPathExtent,token);
1252 if (*token == ',')
1253 (void) GetNextToken(p,&p,MagickPathExtent,token);
1254 }
1255 number_arguments=(size_t) x;
1256 arguments=(double *) AcquireQuantumMemory(number_arguments,
1257 sizeof(*arguments));
1258 if (arguments == (double *) NULL)
1259 ThrowWandFatalException(ResourceLimitFatalError,
1260 "MemoryAllocationFailed",(*image)->filename);
1261 (void) memset(arguments,0,number_arguments*
1262 sizeof(*arguments));
1263 p=(char *) args;
1264 for (x=0; (x < (ssize_t) number_arguments) && (*p != '\0'); x++)
1265 {
1266 (void) GetNextToken(p,&p,MagickPathExtent,token);
1267 if (*token == ',')
1268 (void) GetNextToken(p,&p,MagickPathExtent,token);
1269 arguments[x]=StringToDouble(token,(char **) NULL);
1270 }
1271 args=DestroyString(args);
1272 mogrify_image=DistortImage(*image,method,number_arguments,arguments,
1273 (*option == '+') ? MagickTrue : MagickFalse,exception);
1274 arguments=(double *) RelinquishMagickMemory(arguments);
1275 break;
1276 }
1277 if (LocaleCompare("dither",option+1) == 0)
1278 {
1279 if (*option == '+')
1280 {
1281 quantize_info->dither_method=NoDitherMethod;
1282 break;
1283 }
1284 quantize_info->dither_method=(DitherMethod) ParseCommandOption(
1285 MagickDitherOptions,MagickFalse,argv[i+1]);
1286 break;
1287 }
1288 if (LocaleCompare("draw",option+1) == 0)
1289 {
1290 /*
1291 Draw image.
1292 */
1293 (void) SyncImageSettings(mogrify_info,*image,exception);
1294 (void) CloneString(&draw_info->primitive,argv[i+1]);
1295 (void) DrawImage(*image,draw_info,exception);
1296 break;
1297 }
1298 break;
1299 }
1300 case 'e':
1301 {
1302 if (LocaleCompare("edge",option+1) == 0)
1303 {
1304 /*
1305 Enhance edges in the image.
1306 */
1307 (void) SyncImageSettings(mogrify_info,*image,exception);
1308 flags=ParseGeometry(argv[i+1],&geometry_info);
1309 mogrify_image=EdgeImage(*image,geometry_info.rho,exception);
1310 break;
1311 }
1312 if (LocaleCompare("emboss",option+1) == 0)
1313 {
1314 /*
1315 Emboss image.
1316 */
1317 (void) SyncImageSettings(mogrify_info,*image,exception);
1318 flags=ParseGeometry(argv[i+1],&geometry_info);
1319 if ((flags & SigmaValue) == 0)
1320 geometry_info.sigma=1.0;
1321 mogrify_image=EmbossImage(*image,geometry_info.rho,
1322 geometry_info.sigma,exception);
1323 break;
1324 }
1325 if (LocaleCompare("encipher",option+1) == 0)
1326 {
1327 StringInfo
1328 *passkey;
1329
1330 /*
1331 Encipher pixels.
1332 */
1333 (void) SyncImageSettings(mogrify_info,*image,exception);
1334 passkey=FileToStringInfo(argv[i+1],~0UL,exception);
1335 if (passkey != (StringInfo *) NULL)
1336 {
1337 (void) PasskeyEncipherImage(*image,passkey,exception);
1338 passkey=DestroyStringInfo(passkey);
1339 }
1340 break;
1341 }
1342 if (LocaleCompare("encoding",option+1) == 0)
1343 {
1344 (void) CloneString(&draw_info->encoding,argv[i+1]);
1345 break;
1346 }
1347 if (LocaleCompare("enhance",option+1) == 0)
1348 {
1349 /*
1350 Enhance image.
1351 */
1352 (void) SyncImageSettings(mogrify_info,*image,exception);
1353 mogrify_image=EnhanceImage(*image,exception);
1354 break;
1355 }
1356 if (LocaleCompare("equalize",option+1) == 0)
1357 {
1358 /*
1359 Equalize image.
1360 */
1361 (void) SyncImageSettings(mogrify_info,*image,exception);
1362 (void) EqualizeImage(*image,exception);
1363 break;
1364 }
1365 if (LocaleCompare("evaluate",option+1) == 0)
1366 {
1367 double
1368 constant;
1369
1370 MagickEvaluateOperator
1371 op;
1372
1373 (void) SyncImageSettings(mogrify_info,*image,exception);
1374 op=(MagickEvaluateOperator) ParseCommandOption(
1375 MagickEvaluateOptions,MagickFalse,argv[i+1]);
1376 constant=StringToDoubleInterval(argv[i+2],(double) QuantumRange+
1377 1.0);
1378 (void) EvaluateImage(*image,op,constant,exception);
1379 break;
1380 }
1381 if (LocaleCompare("extent",option+1) == 0)
1382 {
1383 /*
1384 Set the image extent.
1385 */
1386 (void) SyncImageSettings(mogrify_info,*image,exception);
1387 flags=ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
1388 if (geometry.width == 0)
1389 geometry.width=(*image)->columns;
1390 if (geometry.height == 0)
1391 geometry.height=(*image)->rows;
1392 mogrify_image=ExtentImage(*image,&geometry,exception);
1393 break;
1394 }
1395 break;
1396 }
1397 case 'f':
1398 {
1399 if (LocaleCompare("family",option+1) == 0)
1400 {
1401 if (*option == '+')
1402 {
1403 if (draw_info->family != (char *) NULL)
1404 draw_info->family=DestroyString(draw_info->family);
1405 break;
1406 }
1407 (void) SetImageOption(image_info,option+1,argv[i+1]);
1408 (void) CloneString(&draw_info->family,argv[i+1]);
1409 break;
1410 }
1411 if (LocaleCompare("features",option+1) == 0)
1412 {
1413 if (*option == '+')
1414 {
1415 (void) DeleteImageArtifact(*image,"identify:features");
1416 break;
1417 }
1418 (void) SetImageArtifact(*image,"identify:features",argv[i+1]);
1419 (void) SetImageArtifact(*image,"verbose","true");
1420 break;
1421 }
1422 if (LocaleCompare("fill",option+1) == 0)
1423 {
1424 ExceptionInfo
1425 *sans;
1426
1427 PixelInfo
1428 color;
1429
1430 GetPixelInfo(*image,&fill);
1431 if (*option == '+')
1432 {
1433 (void) QueryColorCompliance("none",AllCompliance,&fill,
1434 exception);
1435 draw_info->fill=fill;
1436 if (draw_info->fill_pattern != (Image *) NULL)
1437 draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern);
1438 break;
1439 }
1440 sans=AcquireExceptionInfo();
1441 status=QueryColorCompliance(argv[i+1],AllCompliance,&color,sans);
1442 sans=DestroyExceptionInfo(sans);
1443 if (status == MagickFalse)
1444 draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1],
1445 exception);
1446 else
1447 draw_info->fill=fill=color;
1448 break;
1449 }
1450 if (LocaleCompare("flip",option+1) == 0)
1451 {
1452 /*
1453 Flip image scanlines.
1454 */
1455 (void) SyncImageSettings(mogrify_info,*image,exception);
1456 mogrify_image=FlipImage(*image,exception);
1457 break;
1458 }
1459 if (LocaleCompare("floodfill",option+1) == 0)
1460 {
1461 PixelInfo
1462 target;
1463
1464 /*
1465 Floodfill image.
1466 */
1467 (void) SyncImageSettings(mogrify_info,*image,exception);
1468 (void) ParsePageGeometry(*image,argv[i+1],&geometry,exception);
1469 (void) QueryColorCompliance(argv[i+2],AllCompliance,&target,
1470 exception);
1471 (void) FloodfillPaintImage(*image,draw_info,&target,geometry.x,
1472 geometry.y,*option == '-' ? MagickFalse : MagickTrue,exception);
1473 break;
1474 }
1475 if (LocaleCompare("flop",option+1) == 0)
1476 {
1477 /*
1478 Flop image scanlines.
1479 */
1480 (void) SyncImageSettings(mogrify_info,*image,exception);
1481 mogrify_image=FlopImage(*image,exception);
1482 break;
1483 }
1484 if (LocaleCompare("font",option+1) == 0)
1485 {
1486 if (*option == '+')
1487 {
1488 if (draw_info->font != (char *) NULL)
1489 draw_info->font=DestroyString(draw_info->font);
1490 break;
1491 }
1492 (void) CloneString(&draw_info->font,argv[i+1]);
1493 break;
1494 }
1495 if (LocaleCompare("format",option+1) == 0)
1496 {
1497 format=argv[i+1];
1498 break;
1499 }
1500 if (LocaleCompare("frame",option+1) == 0)
1501 {
1502 FrameInfo
1503 frame_info;
1504
1505 /*
1506 Surround image with an ornamental border.
1507 */
1508 (void) SyncImageSettings(mogrify_info,*image,exception);
1509 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
1510 frame_info.width=geometry.width;
1511 frame_info.height=geometry.height;
1512 frame_info.outer_bevel=geometry.x;
1513 frame_info.inner_bevel=geometry.y;
1514 frame_info.x=(ssize_t) frame_info.width;
1515 frame_info.y=(ssize_t) frame_info.height;
1516 frame_info.width=(*image)->columns+2*frame_info.width;
1517 frame_info.height=(*image)->rows+2*frame_info.height;
1518 mogrify_image=FrameImage(*image,&frame_info,compose,exception);
1519 break;
1520 }
1521 if (LocaleCompare("function",option+1) == 0)
1522 {
1523 char
1524 *arguments,
1525 token[MagickPathExtent];
1526
1527 const char
1528 *p;
1529
1530 double
1531 *parameters;
1532
1533 MagickFunction
1534 function;
1535
1536 ssize_t
1537 x;
1538
1539 size_t
1540 number_parameters;
1541
1542 /*
1543 Function Modify Image Values
1544 */
1545 (void) SyncImageSettings(mogrify_info,*image,exception);
1546 function=(MagickFunction) ParseCommandOption(MagickFunctionOptions,
1547 MagickFalse,argv[i+1]);
1548 arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2],
1549 exception);
1550 if (arguments == (char *) NULL)
1551 break;
1552 p=(char *) arguments;
1553 for (x=0; *p != '\0'; x++)
1554 {
1555 (void) GetNextToken(p,&p,MagickPathExtent,token);
1556 if (*token == ',')
1557 (void) GetNextToken(p,&p,MagickPathExtent,token);
1558 }
1559 number_parameters=(size_t) x;
1560 parameters=(double *) AcquireQuantumMemory(number_parameters,
1561 sizeof(*parameters));
1562 if (parameters == (double *) NULL)
1563 ThrowWandFatalException(ResourceLimitFatalError,
1564 "MemoryAllocationFailed",(*image)->filename);
1565 (void) memset(parameters,0,number_parameters*
1566 sizeof(*parameters));
1567 p=(char *) arguments;
1568 for (x=0; (x < (ssize_t) number_parameters) && (*p != '\0'); x++)
1569 {
1570 (void) GetNextToken(p,&p,MagickPathExtent,token);
1571 if (*token == ',')
1572 (void) GetNextToken(p,&p,MagickPathExtent,token);
1573 parameters[x]=StringToDouble(token,(char **) NULL);
1574 }
1575 arguments=DestroyString(arguments);
1576 (void) FunctionImage(*image,function,number_parameters,parameters,
1577 exception);
1578 parameters=(double *) RelinquishMagickMemory(parameters);
1579 break;
1580 }
1581 break;
1582 }
1583 case 'g':
1584 {
1585 if (LocaleCompare("gamma",option+1) == 0)
1586 {
1587 /*
1588 Gamma image.
1589 */
1590 (void) SyncImageSettings(mogrify_info,*image,exception);
1591 if (*option == '+')
1592 (*image)->gamma=StringToDouble(argv[i+1],(char **) NULL);
1593 else
1594 (void) GammaImage(*image,StringToDouble(argv[i+1],(char **) NULL),
1595 exception);
1596 break;
1597 }
1598 if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
1599 (LocaleCompare("gaussian",option+1) == 0))
1600 {
1601 /*
1602 Gaussian blur image.
1603 */
1604 (void) SyncImageSettings(mogrify_info,*image,exception);
1605 flags=ParseGeometry(argv[i+1],&geometry_info);
1606 if ((flags & SigmaValue) == 0)
1607 geometry_info.sigma=1.0;
1608 mogrify_image=GaussianBlurImage(*image,geometry_info.rho,
1609 geometry_info.sigma,exception);
1610 break;
1611 }
1612 if (LocaleCompare("geometry",option+1) == 0)
1613 {
1614 /*
1615 Record Image offset, Resize last image.
1616 */
1617 (void) SyncImageSettings(mogrify_info,*image,exception);
1618 if (*option == '+')
1619 {
1620 if ((*image)->geometry != (char *) NULL)
1621 (*image)->geometry=DestroyString((*image)->geometry);
1622 break;
1623 }
1624 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
1625 if (((flags & XValue) != 0) || ((flags & YValue) != 0))
1626 (void) CloneString(&(*image)->geometry,argv[i+1]);
1627 else
1628 mogrify_image=ResizeImage(*image,geometry.width,geometry.height,
1629 (*image)->filter,exception);
1630 break;
1631 }
1632 if (LocaleCompare("gravity",option+1) == 0)
1633 {
1634 if (*option == '+')
1635 {
1636 draw_info->gravity=UndefinedGravity;
1637 break;
1638 }
1639 draw_info->gravity=(GravityType) ParseCommandOption(
1640 MagickGravityOptions,MagickFalse,argv[i+1]);
1641 break;
1642 }
1643 if (LocaleCompare("grayscale",option+1) == 0)
1644 {
1645 PixelIntensityMethod
1646 method;
1647
1648 (void) SyncImageSettings(mogrify_info,*image,exception);
1649 method=(PixelIntensityMethod) ParseCommandOption(
1650 MagickPixelIntensityOptions,MagickFalse,argv[i+1]);
1651 (void) GrayscaleImage(*image,method,exception);
1652 break;
1653 }
1654 break;
1655 }
1656 case 'h':
1657 {
1658 if (LocaleCompare("highlight-color",option+1) == 0)
1659 {
1660 (void) SetImageArtifact(*image,"compare:highlight-color",argv[i+1]);
1661 break;
1662 }
1663 if (LocaleCompare("hough-lines",option+1) == 0)
1664 {
1665 /*
1666 Detect edges in the image.
1667 */
1668 (void) SyncImageSettings(mogrify_info,*image,exception);
1669 flags=ParseGeometry(argv[i+1],&geometry_info);
1670 if ((flags & SigmaValue) == 0)
1671 geometry_info.sigma=geometry_info.rho;
1672 if ((flags & XiValue) == 0)
1673 geometry_info.xi=40;
1674 mogrify_image=HoughLineImage(*image,(size_t) geometry_info.rho,
1675 (size_t) geometry_info.sigma,(size_t) geometry_info.xi,exception);
1676 break;
1677 }
1678 break;
1679 }
1680 case 'i':
1681 {
1682 if (LocaleCompare("identify",option+1) == 0)
1683 {
1684 char
1685 *text;
1686
1687 (void) SyncImageSettings(mogrify_info,*image,exception);
1688 if (format == (char *) NULL)
1689 {
1690 (void) IdentifyImage(*image,stdout,mogrify_info->verbose,
1691 exception);
1692 break;
1693 }
1694 text=InterpretImageProperties(mogrify_info,*image,format,exception);
1695 if (text == (char *) NULL)
1696 break;
1697 (void) fputs(text,stdout);
1698 text=DestroyString(text);
1699 break;
1700 }
1701 if (LocaleCompare("illuminant",option+1) == 0)
1702 {
1703 (void) SetImageArtifact(*image,"color:illuminant",argv[i+1]);
1704 break;
1705 }
1706 if (LocaleCompare("implode",option+1) == 0)
1707 {
1708 /*
1709 Implode image.
1710 */
1711 (void) SyncImageSettings(mogrify_info,*image,exception);
1712 (void) ParseGeometry(argv[i+1],&geometry_info);
1713 mogrify_image=ImplodeImage(*image,geometry_info.rho,
1714 interpolate_method,exception);
1715 break;
1716 }
1717 if (LocaleCompare("integral",option+1) == 0)
1718 {
1719 (void) SyncImageSettings(mogrify_info,*image,exception);
1720 mogrify_image=IntegralImage(*image,exception);
1721 break;
1722 }
1723 if (LocaleCompare("interline-spacing",option+1) == 0)
1724 {
1725 if (*option == '+')
1726 (void) ParseGeometry("0",&geometry_info);
1727 else
1728 (void) ParseGeometry(argv[i+1],&geometry_info);
1729 draw_info->interline_spacing=geometry_info.rho;
1730 break;
1731 }
1732 if (LocaleCompare("interpolate",option+1) == 0)
1733 {
1734 interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
1735 MagickInterpolateOptions,MagickFalse,argv[i+1]);
1736 break;
1737 }
1738 if (LocaleCompare("interword-spacing",option+1) == 0)
1739 {
1740 if (*option == '+')
1741 (void) ParseGeometry("0",&geometry_info);
1742 else
1743 (void) ParseGeometry(argv[i+1],&geometry_info);
1744 draw_info->interword_spacing=geometry_info.rho;
1745 break;
1746 }
1747 if (LocaleCompare("interpolative-resize",option+1) == 0)
1748 {
1749 /*
1750 Interpolative resize image.
1751 */
1752 (void) SyncImageSettings(mogrify_info,*image,exception);
1753 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
1754 mogrify_image=InterpolativeResizeImage(*image,geometry.width,
1755 geometry.height,interpolate_method,exception);
1756 break;
1757 }
1758 break;
1759 }
1760 case 'k':
1761 {
1762 if (LocaleCompare("kerning",option+1) == 0)
1763 {
1764 if (*option == '+')
1765 (void) ParseGeometry("0",&geometry_info);
1766 else
1767 (void) ParseGeometry(argv[i+1],&geometry_info);
1768 draw_info->kerning=geometry_info.rho;
1769 break;
1770 }
1771 if (LocaleCompare("kmeans",option+1) == 0)
1772 {
1773 /*
1774 K-means clustering.
1775 */
1776 (void) SyncImageSettings(mogrify_info,*image,exception);
1777 flags=ParseGeometry(argv[i+1],&geometry_info);
1778 if ((flags & SigmaValue) == 0)
1779 geometry_info.sigma=300.0;
1780 if ((flags & XiValue) == 0)
1781 geometry_info.xi=0.0001;
1782 (void) KmeansImage(*image,(size_t) geometry_info.rho,
1783 (size_t) geometry_info.sigma,geometry_info.xi,exception);
1784 break;
1785 }
1786 if (LocaleCompare("kuwahara",option+1) == 0)
1787 {
1788 /*
1789 Edge preserving blur.
1790 */
1791 (void) SyncImageSettings(mogrify_info,*image,exception);
1792 flags=ParseGeometry(argv[i+1],&geometry_info);
1793 if ((flags & SigmaValue) == 0)
1794 geometry_info.sigma=geometry_info.rho-0.5;
1795 mogrify_image=KuwaharaImage(*image,geometry_info.rho,
1796 geometry_info.sigma,exception);
1797 break;
1798 }
1799 break;
1800 }
1801 case 'l':
1802 {
1803 if (LocaleCompare("lat",option+1) == 0)
1804 {
1805 /*
1806 Local adaptive threshold image.
1807 */
1808 (void) SyncImageSettings(mogrify_info,*image,exception);
1809 flags=ParseGeometry(argv[i+1],&geometry_info);
1810 if ((flags & PercentValue) != 0)
1811 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
1812 mogrify_image=AdaptiveThresholdImage(*image,(size_t)
1813 geometry_info.rho,(size_t) geometry_info.sigma,(double)
1814 geometry_info.xi,exception);
1815 break;
1816 }
1817 if (LocaleCompare("level",option+1) == 0)
1818 {
1819 double
1820 black_point,
1821 gamma,
1822 white_point;
1823
1824 /*
1825 Parse levels.
1826 */
1827 (void) SyncImageSettings(mogrify_info,*image,exception);
1828 flags=ParseGeometry(argv[i+1],&geometry_info);
1829 black_point=geometry_info.rho;
1830 white_point=(double) QuantumRange;
1831 if ((flags & SigmaValue) != 0)
1832 white_point=geometry_info.sigma;
1833 gamma=1.0;
1834 if ((flags & XiValue) != 0)
1835 gamma=geometry_info.xi;
1836 if ((flags & PercentValue) != 0)
1837 {
1838 black_point*=(double) QuantumRange/100.0;
1839 white_point*=(double) QuantumRange/100.0;
1840 }
1841 if ((flags & SigmaValue) == 0)
1842 white_point=(double) QuantumRange-black_point;
1843 if ((*option == '+') || ((flags & AspectValue) != 0))
1844 (void) LevelizeImage(*image,black_point,white_point,gamma,
1845 exception);
1846 else
1847 (void) LevelImage(*image,black_point,white_point,gamma,exception);
1848 break;
1849 }
1850 if (LocaleCompare("level-colors",option+1) == 0)
1851 {
1852 char
1853 token[MagickPathExtent];
1854
1855 const char
1856 *p;
1857
1858 PixelInfo
1859 black_point,
1860 white_point;
1861
1862 p=(const char *) argv[i+1];
1863 (void) GetNextToken(p,&p,MagickPathExtent,token); /* get black point color */
1864 if ((isalpha((int) ((unsigned char) *token)) != 0) || ((*token == '#') != 0))
1865 (void) QueryColorCompliance(token,AllCompliance,&black_point,
1866 exception);
1867 else
1868 (void) QueryColorCompliance("#000000",AllCompliance,&black_point,
1869 exception);
1870 if (isalpha((int) ((unsigned char) *token)) || (*token == '#'))
1871 (void) GetNextToken(p,&p,MagickPathExtent,token);
1872 if (*token == '\0')
1873 white_point=black_point; /* set everything to that color */
1874 else
1875 {
1876 if ((isalpha((int) ((unsigned char) *token)) == 0) && ((*token == '#') == 0))
1877 (void) GetNextToken(p,&p,MagickPathExtent,token); /* Get white point color. */
1878 if ((isalpha((int) ((unsigned char) *token)) != 0) || ((*token == '#') != 0))
1879 (void) QueryColorCompliance(token,AllCompliance,&white_point,
1880 exception);
1881 else
1882 (void) QueryColorCompliance("#ffffff",AllCompliance,
1883 &white_point,exception);
1884 }
1885 (void) LevelImageColors(*image,&black_point,&white_point,
1886 *option == '+' ? MagickTrue : MagickFalse,exception);
1887 break;
1888 }
1889 if (LocaleCompare("linear-stretch",option+1) == 0)
1890 {
1891 double
1892 black_point,
1893 white_point;
1894
1895 (void) SyncImageSettings(mogrify_info,*image,exception);
1896 flags=ParseGeometry(argv[i+1],&geometry_info);
1897 black_point=geometry_info.rho;
1898 white_point=(double) (*image)->columns*(*image)->rows;
1899 if ((flags & SigmaValue) != 0)
1900 white_point=geometry_info.sigma;
1901 if ((flags & PercentValue) != 0)
1902 {
1903 black_point*=(double) (*image)->columns*(*image)->rows/100.0;
1904 white_point*=(double) (*image)->columns*(*image)->rows/100.0;
1905 }
1906 if ((flags & SigmaValue) == 0)
1907 white_point=(double) (*image)->columns*(*image)->rows-
1908 black_point;
1909 (void) LinearStretchImage(*image,black_point,white_point,exception);
1910 break;
1911 }
1912 if (LocaleCompare("liquid-rescale",option+1) == 0)
1913 {
1914 /*
1915 Liquid rescale image.
1916 */
1917 (void) SyncImageSettings(mogrify_info,*image,exception);
1918 flags=ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
1919 if ((flags & XValue) == 0)
1920 geometry.x=1;
1921 if ((flags & YValue) == 0)
1922 geometry.y=0;
1923 mogrify_image=LiquidRescaleImage(*image,geometry.width,
1924 geometry.height,1.0*geometry.x,1.0*geometry.y,exception);
1925 break;
1926 }
1927 if (LocaleCompare("local-contrast",option+1) == 0)
1928 {
1929 (void) SyncImageSettings(mogrify_info,*image,exception);
1930 flags=ParseGeometry(argv[i+1],&geometry_info);
1931 if ((flags & RhoValue) == 0)
1932 geometry_info.rho=10;
1933 if ((flags & SigmaValue) == 0)
1934 geometry_info.sigma=12.5;
1935 mogrify_image=LocalContrastImage(*image,geometry_info.rho,
1936 geometry_info.sigma,exception);
1937 break;
1938 }
1939 if (LocaleCompare("lowlight-color",option+1) == 0)
1940 {
1941 (void) SetImageArtifact(*image,"compare:lowlight-color",argv[i+1]);
1942 break;
1943 }
1944 break;
1945 }
1946 case 'm':
1947 {
1948 if (LocaleCompare("magnify",option+1) == 0)
1949 {
1950 /*
1951 Double image size.
1952 */
1953 (void) SyncImageSettings(mogrify_info,*image,exception);
1954 mogrify_image=MagnifyImage(*image,exception);
1955 break;
1956 }
1957 if (LocaleCompare("map",option+1) == 0)
1958 {
1959 Image
1960 *remap_image;
1961
1962 /*
1963 Transform image colors to match this set of colors.
1964 */
1965 (void) SyncImageSettings(mogrify_info,*image,exception);
1966 if (*option == '+')
1967 break;
1968 remap_image=GetImageCache(mogrify_info,argv[i+1],exception);
1969 if (remap_image == (Image *) NULL)
1970 break;
1971 (void) RemapImage(quantize_info,*image,remap_image,exception);
1972 remap_image=DestroyImage(remap_image);
1973 break;
1974 }
1975 if (LocaleCompare("mask",option+1) == 0)
1976 {
1977 Image
1978 *mask;
1979
1980 (void) SyncImageSettings(mogrify_info,*image,exception);
1981 if (*option == '+')
1982 {
1983 /*
1984 Remove a mask.
1985 */
1986 (void) SetImageMask(*image,WritePixelMask,(const Image *) NULL,
1987 exception);
1988 break;
1989 }
1990 /*
1991 Set the image mask.
1992 */
1993 mask=GetImageCache(mogrify_info,argv[i+1],exception);
1994 if (mask == (Image *) NULL)
1995 break;
1996 (void) SetImageMask(*image,WritePixelMask,mask,exception);
1997 mask=DestroyImage(mask);
1998 break;
1999 }
2000 if (LocaleCompare("matte",option+1) == 0)
2001 {
2002 (void) SetImageAlphaChannel(*image,(*option == '-') ?
2003 SetAlphaChannel : DeactivateAlphaChannel,exception);
2004 break;
2005 }
2006 if (LocaleCompare("mean-shift",option+1) == 0)
2007 {
2008 /*
2009 Detect edges in the image.
2010 */
2011 (void) SyncImageSettings(mogrify_info,*image,exception);
2012 flags=ParseGeometry(argv[i+1],&geometry_info);
2013 if ((flags & SigmaValue) == 0)
2014 geometry_info.sigma=geometry_info.rho;
2015 if ((flags & XiValue) == 0)
2016 geometry_info.xi=0.10*(double) QuantumRange;
2017 if ((flags & PercentValue) != 0)
2018 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
2019 mogrify_image=MeanShiftImage(*image,(size_t) geometry_info.rho,
2020 (size_t) geometry_info.sigma,geometry_info.xi,exception);
2021 break;
2022 }
2023 if (LocaleCompare("median",option+1) == 0)
2024 {
2025 /*
2026 Median filter image.
2027 */
2028 (void) SyncImageSettings(mogrify_info,*image,exception);
2029 flags=ParseGeometry(argv[i+1],&geometry_info);
2030 if ((flags & SigmaValue) == 0)
2031 geometry_info.sigma=geometry_info.rho;
2032 mogrify_image=StatisticImage(*image,MedianStatistic,(size_t)
2033 geometry_info.rho,(size_t) geometry_info.sigma,exception);
2034 break;
2035 }
2036 if (LocaleCompare("mode",option+1) == 0)
2037 {
2038 /*
2039 Mode image.
2040 */
2041 (void) SyncImageSettings(mogrify_info,*image,exception);
2042 flags=ParseGeometry(argv[i+1],&geometry_info);
2043 if ((flags & SigmaValue) == 0)
2044 geometry_info.sigma=geometry_info.rho;
2045 mogrify_image=StatisticImage(*image,ModeStatistic,(size_t)
2046 geometry_info.rho,(size_t) geometry_info.sigma,exception);
2047 break;
2048 }
2049 if (LocaleCompare("modulate",option+1) == 0)
2050 {
2051 (void) SyncImageSettings(mogrify_info,*image,exception);
2052 (void) ModulateImage(*image,argv[i+1],exception);
2053 break;
2054 }
2055 if (LocaleCompare("moments",option+1) == 0)
2056 {
2057 if (*option == '+')
2058 {
2059 (void) DeleteImageArtifact(*image,"identify:moments");
2060 break;
2061 }
2062 (void) SetImageArtifact(*image,"identify:moments",argv[i+1]);
2063 (void) SetImageArtifact(*image,"verbose","true");
2064 break;
2065 }
2066 if (LocaleCompare("monitor",option+1) == 0)
2067 {
2068 if (*option == '+')
2069 {
2070 (void) SetImageProgressMonitor(*image,
2071 (MagickProgressMonitor) NULL,(void *) NULL);
2072 break;
2073 }
2074 (void) SetImageProgressMonitor(*image,MonitorProgress,
2075 (void *) NULL);
2076 break;
2077 }
2078 if (LocaleCompare("monochrome",option+1) == 0)
2079 {
2080 (void) SyncImageSettings(mogrify_info,*image,exception);
2081 (void) SetImageType(*image,BilevelType,exception);
2082 break;
2083 }
2084 if (LocaleCompare("morphology",option+1) == 0)
2085 {
2086 char
2087 token[MagickPathExtent];
2088
2089 const char
2090 *p;
2091
2092 KernelInfo
2093 *kernel;
2094
2095 MorphologyMethod
2096 method;
2097
2098 ssize_t
2099 iterations;
2100
2101 /*
2102 Morphological Image Operation
2103 */
2104 (void) SyncImageSettings(mogrify_info,*image,exception);
2105 p=argv[i+1];
2106 (void) GetNextToken(p,&p,MagickPathExtent,token);
2107 method=(MorphologyMethod) ParseCommandOption(
2108 MagickMorphologyOptions,MagickFalse,token);
2109 iterations=1L;
2110 (void) GetNextToken(p,&p,MagickPathExtent,token);
2111 if ((*p == ':') || (*p == ','))
2112 (void) GetNextToken(p,&p,MagickPathExtent,token);
2113 if ((*p != '\0'))
2114 iterations=(ssize_t) StringToLong(p);
2115 kernel=AcquireKernelInfo(argv[i+2],exception);
2116 if (kernel == (KernelInfo *) NULL)
2117 {
2118 (void) ThrowMagickException(exception,GetMagickModule(),
2119 OptionError,"UnabletoParseKernel","morphology");
2120 status=MagickFalse;
2121 break;
2122 }
2123 mogrify_image=MorphologyImage(*image,method,iterations,kernel,
2124 exception);
2125 kernel=DestroyKernelInfo(kernel);
2126 break;
2127 }
2128 if (LocaleCompare("motion-blur",option+1) == 0)
2129 {
2130 /*
2131 Motion blur image.
2132 */
2133 (void) SyncImageSettings(mogrify_info,*image,exception);
2134 flags=ParseGeometry(argv[i+1],&geometry_info);
2135 if ((flags & SigmaValue) == 0)
2136 geometry_info.sigma=1.0;
2137 mogrify_image=MotionBlurImage(*image,geometry_info.rho,
2138 geometry_info.sigma,geometry_info.xi,exception);
2139 break;
2140 }
2141 break;
2142 }
2143 case 'n':
2144 {
2145 if (LocaleCompare("negate",option+1) == 0)
2146 {
2147 (void) SyncImageSettings(mogrify_info,*image,exception);
2148 (void) NegateImage(*image,*option == '+' ? MagickTrue :
2149 MagickFalse,exception);
2150 break;
2151 }
2152 if (LocaleCompare("noise",option+1) == 0)
2153 {
2154 (void) SyncImageSettings(mogrify_info,*image,exception);
2155 if (*option == '-')
2156 {
2157 flags=ParseGeometry(argv[i+1],&geometry_info);
2158 if ((flags & SigmaValue) == 0)
2159 geometry_info.sigma=geometry_info.rho;
2160 mogrify_image=StatisticImage(*image,NonpeakStatistic,(size_t)
2161 geometry_info.rho,(size_t) geometry_info.sigma,exception);
2162 }
2163 else
2164 {
2165 NoiseType
2166 noise;
2167
2168 noise=(NoiseType) ParseCommandOption(MagickNoiseOptions,
2169 MagickFalse,argv[i+1]);
2170 mogrify_image=AddNoiseImage(*image,noise,attenuate,exception);
2171 }
2172 break;
2173 }
2174 if (LocaleCompare("normalize",option+1) == 0)
2175 {
2176 (void) SyncImageSettings(mogrify_info,*image,exception);
2177 (void) NormalizeImage(*image,exception);
2178 break;
2179 }
2180 break;
2181 }
2182 case 'o':
2183 {
2184 if (LocaleCompare("opaque",option+1) == 0)
2185 {
2186 PixelInfo
2187 target;
2188
2189 (void) SyncImageSettings(mogrify_info,*image,exception);
2190 (void) QueryColorCompliance(argv[i+1],AllCompliance,&target,
2191 exception);
2192 (void) OpaquePaintImage(*image,&target,&fill,*option == '-' ?
2193 MagickFalse : MagickTrue,exception);
2194 break;
2195 }
2196 if (LocaleCompare("ordered-dither",option+1) == 0)
2197 {
2198 (void) SyncImageSettings(mogrify_info,*image,exception);
2199 (void) OrderedDitherImage(*image,argv[i+1],exception);
2200 break;
2201 }
2202 break;
2203 }
2204 case 'p':
2205 {
2206 if (LocaleCompare("paint",option+1) == 0)
2207 {
2208 (void) SyncImageSettings(mogrify_info,*image,exception);
2209 (void) ParseGeometry(argv[i+1],&geometry_info);
2210 mogrify_image=OilPaintImage(*image,geometry_info.rho,
2211 geometry_info.sigma,exception);
2212 break;
2213 }
2214 if (LocaleCompare("perceptible",option+1) == 0)
2215 {
2216 /*
2217 Perceptible image.
2218 */
2219 (void) SyncImageSettings(mogrify_info,*image,exception);
2220 (void) PerceptibleImage(*image,StringToDouble(argv[i+1],
2221 (char **) NULL),exception);
2222 break;
2223 }
2224 if (LocaleCompare("pointsize",option+1) == 0)
2225 {
2226 if (*option == '+')
2227 (void) ParseGeometry("12",&geometry_info);
2228 else
2229 (void) ParseGeometry(argv[i+1],&geometry_info);
2230 draw_info->pointsize=geometry_info.rho;
2231 break;
2232 }
2233 if (LocaleCompare("polaroid",option+1) == 0)
2234 {
2235 const char
2236 *caption;
2237
2238 double
2239 angle;
2240
2241 RandomInfo
2242 *random_info;
2243
2244 /*
2245 Simulate a Polaroid picture.
2246 */
2247 (void) SyncImageSettings(mogrify_info,*image,exception);
2248 random_info=AcquireRandomInfo();
2249 angle=22.5*(GetPseudoRandomValue(random_info)-0.5);
2250 random_info=DestroyRandomInfo(random_info);
2251 if (*option == '-')
2252 {
2253 SetGeometryInfo(&geometry_info);
2254 flags=ParseGeometry(argv[i+1],&geometry_info);
2255 angle=geometry_info.rho;
2256 }
2257 caption=GetImageProperty(*image,"caption",exception);
2258 mogrify_image=PolaroidImage(*image,draw_info,caption,angle,
2259 interpolate_method,exception);
2260 break;
2261 }
2262 if (LocaleCompare("posterize",option+1) == 0)
2263 {
2264 /*
2265 Posterize image.
2266 */
2267 (void) SyncImageSettings(mogrify_info,*image,exception);
2268 (void) PosterizeImage(*image,StringToUnsignedLong(argv[i+1]),
2269 quantize_info->dither_method,exception);
2270 break;
2271 }
2272 if (LocaleCompare("preview",option+1) == 0)
2273 {
2274 PreviewType
2275 preview_type;
2276
2277 /*
2278 Preview image.
2279 */
2280 (void) SyncImageSettings(mogrify_info,*image,exception);
2281 if (*option == '+')
2282 preview_type=UndefinedPreview;
2283 else
2284 preview_type=(PreviewType) ParseCommandOption(
2285 MagickPreviewOptions,MagickFalse,argv[i+1]);
2286 mogrify_image=PreviewImage(*image,preview_type,exception);
2287 break;
2288 }
2289 if (LocaleCompare("profile",option+1) == 0)
2290 {
2291 const char
2292 *name;
2293
2294 const StringInfo
2295 *profile;
2296
2297 ExceptionInfo
2298 *sans_exception;
2299
2300 Image
2301 *profile_image;
2302
2303 ImageInfo
2304 *profile_info;
2305
2306 (void) SyncImageSettings(mogrify_info,*image,exception);
2307 if (*option == '+')
2308 {
2309 /*
2310 Remove a profile from the image.
2311 */
2312 (void) ProfileImage(*image,argv[i+1],(const unsigned char *)
2313 NULL,0,exception);
2314 break;
2315 }
2316 /*
2317 Associate a profile with the image.
2318 */
2319 profile_info=CloneImageInfo(mogrify_info);
2320 profile=GetImageProfile(*image,"iptc");
2321 if (profile != (StringInfo *) NULL)
2322 profile_info->profile=(void *) CloneStringInfo(profile);
2323 sans_exception=AcquireExceptionInfo();
2324 profile_image=GetImageCache(profile_info,argv[i+1],sans_exception);
2325 sans_exception=DestroyExceptionInfo(sans_exception);
2326 profile_info=DestroyImageInfo(profile_info);
2327 if (profile_image == (Image *) NULL)
2328 {
2329 StringInfo
2330 *file_data;
2331
2332 profile_info=CloneImageInfo(mogrify_info);
2333 (void) CopyMagickString(profile_info->filename,argv[i+1],
2334 MagickPathExtent);
2335 file_data=FileToStringInfo(profile_info->filename,~0UL,
2336 exception);
2337 if (file_data != (StringInfo *) NULL)
2338 {
2339 (void) SetImageInfo(profile_info,0,exception);
2340 (void) ProfileImage(*image,profile_info->magick,
2341 GetStringInfoDatum(file_data),
2342 GetStringInfoLength(file_data),exception);
2343 file_data=DestroyStringInfo(file_data);
2344 }
2345 profile_info=DestroyImageInfo(profile_info);
2346 break;
2347 }
2348 ResetImageProfileIterator(profile_image);
2349 name=GetNextImageProfile(profile_image);
2350 while (name != (const char *) NULL)
2351 {
2352 profile=GetImageProfile(profile_image,name);
2353 if (profile != (StringInfo *) NULL)
2354 (void) ProfileImage(*image,name,GetStringInfoDatum(profile),
2355 (size_t) GetStringInfoLength(profile),exception);
2356 name=GetNextImageProfile(profile_image);
2357 }
2358 profile_image=DestroyImage(profile_image);
2359 break;
2360 }
2361 break;
2362 }
2363 case 'q':
2364 {
2365 if (LocaleCompare("quantize",option+1) == 0)
2366 {
2367 if (*option == '+')
2368 {
2369 quantize_info->colorspace=UndefinedColorspace;
2370 break;
2371 }
2372 quantize_info->colorspace=(ColorspaceType) ParseCommandOption(
2373 MagickColorspaceOptions,MagickFalse,argv[i+1]);
2374 break;
2375 }
2376 break;
2377 }
2378 case 'r':
2379 {
2380 if (LocaleCompare("rotational-blur",option+1) == 0)
2381 {
2382 /*
2383 Rotational blur image.
2384 */
2385 (void) SyncImageSettings(mogrify_info,*image,exception);
2386 flags=ParseGeometry(argv[i+1],&geometry_info);
2387 mogrify_image=RotationalBlurImage(*image,geometry_info.rho,
2388 exception);
2389 break;
2390 }
2391 if (LocaleCompare("raise",option+1) == 0)
2392 {
2393 /*
2394 Surround image with a raise of solid color.
2395 */
2396 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
2397 (void) RaiseImage(*image,&geometry,*option == '-' ? MagickTrue :
2398 MagickFalse,exception);
2399 break;
2400 }
2401 if (LocaleCompare("random-threshold",option+1) == 0)
2402 {
2403 /*
2404 Random threshold image.
2405 */
2406 double
2407 min_threshold,
2408 max_threshold;
2409
2410 (void) SyncImageSettings(mogrify_info,*image,exception);
2411 min_threshold=0.0;
2412 max_threshold=(double) QuantumRange;
2413 flags=ParseGeometry(argv[i+1],&geometry_info);
2414 min_threshold=geometry_info.rho;
2415 max_threshold=geometry_info.sigma;
2416 if ((flags & SigmaValue) == 0)
2417 max_threshold=min_threshold;
2418 if (strchr(argv[i+1],'%') != (char *) NULL)
2419 {
2420 max_threshold*=0.01*(double) QuantumRange;
2421 min_threshold*=0.01*(double) QuantumRange;
2422 }
2423 (void) RandomThresholdImage(*image,min_threshold,max_threshold,
2424 exception);
2425 break;
2426 }
2427 if (LocaleCompare("range-threshold",option+1) == 0)
2428 {
2429 /*
2430 Range threshold image.
2431 */
2432 (void) SyncImageSettings(mogrify_info,*image,exception);
2433 flags=ParseGeometry(argv[i+1],&geometry_info);
2434 if ((flags & SigmaValue) == 0)
2435 geometry_info.sigma=geometry_info.rho;
2436 if ((flags & XiValue) == 0)
2437 geometry_info.xi=geometry_info.sigma;
2438 if ((flags & PsiValue) == 0)
2439 geometry_info.psi=geometry_info.xi;
2440 if (strchr(argv[i+1],'%') != (char *) NULL)
2441 {
2442 geometry_info.rho*=0.01*(double) QuantumRange;
2443 geometry_info.sigma*=0.01*(double) QuantumRange;
2444 geometry_info.xi*=0.01*(double) QuantumRange;
2445 geometry_info.psi*=0.01*(double) QuantumRange;
2446 }
2447 (void) RangeThresholdImage(*image,geometry_info.rho,
2448 geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
2449 break;
2450 }
2451 if (LocaleCompare("read-mask",option+1) == 0)
2452 {
2453 Image
2454 *mask;
2455
2456 (void) SyncImageSettings(mogrify_info,*image,exception);
2457 if (*option == '+')
2458 {
2459 /*
2460 Remove a mask.
2461 */
2462 (void) SetImageMask(*image,ReadPixelMask,(const Image *) NULL,
2463 exception);
2464 break;
2465 }
2466 /*
2467 Set the image mask.
2468 */
2469 mask=GetImageCache(mogrify_info,argv[i+1],exception);
2470 if (mask == (Image *) NULL)
2471 break;
2472 (void) SetImageMask(*image,ReadPixelMask,mask,exception);
2473 mask=DestroyImage(mask);
2474 break;
2475 }
2476 if (LocaleCompare("region",option+1) == 0)
2477 {
2478 /*
2479 Apply read mask as defined by a region geometry.
2480 */
2481 (void) SyncImageSettings(mogrify_info,*image,exception);
2482 if (*option == '+')
2483 {
2484 (void) SetImageRegionMask(*image,WritePixelMask,
2485 (const RectangleInfo *) NULL,exception);
2486 break;
2487 }
2488 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
2489 (void) SetImageRegionMask(*image,WritePixelMask,&geometry,
2490 exception);
2491 break;
2492 }
2493 if (LocaleCompare("render",option+1) == 0)
2494 {
2495 (void) SyncImageSettings(mogrify_info,*image,exception);
2496 draw_info->render=(*option == '+') ? MagickTrue : MagickFalse;
2497 break;
2498 }
2499 if (LocaleCompare("remap",option+1) == 0)
2500 {
2501 Image
2502 *remap_image;
2503
2504 /*
2505 Transform image colors to match this set of colors.
2506 */
2507 (void) SyncImageSettings(mogrify_info,*image,exception);
2508 if (*option == '+')
2509 break;
2510 remap_image=GetImageCache(mogrify_info,argv[i+1],exception);
2511 if (remap_image == (Image *) NULL)
2512 break;
2513 (void) RemapImage(quantize_info,*image,remap_image,exception);
2514 remap_image=DestroyImage(remap_image);
2515 break;
2516 }
2517 if (LocaleCompare("repage",option+1) == 0)
2518 {
2519 if (*option == '+')
2520 {
2521 (void) ParseAbsoluteGeometry("0x0+0+0",&(*image)->page);
2522 break;
2523 }
2524 (void) ResetImagePage(*image,argv[i+1]);
2525 break;
2526 }
2527 if (LocaleCompare("resample",option+1) == 0)
2528 {
2529 /*
2530 Resample image.
2531 */
2532 (void) SyncImageSettings(mogrify_info,*image,exception);
2533 flags=ParseGeometry(argv[i+1],&geometry_info);
2534 if ((flags & SigmaValue) == 0)
2535 geometry_info.sigma=geometry_info.rho;
2536 mogrify_image=ResampleImage(*image,geometry_info.rho,
2537 geometry_info.sigma,(*image)->filter,exception);
2538 break;
2539 }
2540 if (LocaleCompare("reshape",option+1) == 0)
2541 {
2542 /*
2543 Reshape image.
2544 */
2545 (void) SyncImageSettings(mogrify_info,*image,exception);
2546 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2547 (void) ReshapePixelCache(*image,geometry.width,geometry.height,
2548 exception);
2549 break;
2550 }
2551 if (LocaleCompare("resize",option+1) == 0)
2552 {
2553 /*
2554 Resize image.
2555 */
2556 (void) SyncImageSettings(mogrify_info,*image,exception);
2557 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2558 mogrify_image=ResizeImage(*image,geometry.width,geometry.height,
2559 (*image)->filter,exception);
2560 break;
2561 }
2562 if (LocaleCompare("roll",option+1) == 0)
2563 {
2564 /*
2565 Roll image.
2566 */
2567 (void) SyncImageSettings(mogrify_info,*image,exception);
2568 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
2569 if ((flags & PercentValue) != 0)
2570 {
2571 geometry.x*=(ssize_t) ((*image)->columns/100.0);
2572 geometry.y*=(ssize_t) ((*image)->rows/100.0);
2573 }
2574 mogrify_image=RollImage(*image,geometry.x,geometry.y,exception);
2575 break;
2576 }
2577 if (LocaleCompare("rotate",option+1) == 0)
2578 {
2579 char
2580 *rotation;
2581
2582 /*
2583 Check for conditional image rotation.
2584 */
2585 (void) SyncImageSettings(mogrify_info,*image,exception);
2586 if (strchr(argv[i+1],'>') != (char *) NULL)
2587 if ((*image)->columns <= (*image)->rows)
2588 break;
2589 if (strchr(argv[i+1],'<') != (char *) NULL)
2590 if ((*image)->columns >= (*image)->rows)
2591 break;
2592 /*
2593 Rotate image.
2594 */
2595 rotation=ConstantString(argv[i+1]);
2596 (void) SubstituteString(&rotation,">","");
2597 (void) SubstituteString(&rotation,"<","");
2598 (void) ParseGeometry(rotation,&geometry_info);
2599 rotation=DestroyString(rotation);
2600 mogrify_image=RotateImage(*image,geometry_info.rho,exception);
2601 break;
2602 }
2603 break;
2604 }
2605 case 's':
2606 {
2607 if (LocaleCompare("sample",option+1) == 0)
2608 {
2609 /*
2610 Sample image with pixel replication.
2611 */
2612 (void) SyncImageSettings(mogrify_info,*image,exception);
2613 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2614 mogrify_image=SampleImage(*image,geometry.width,geometry.height,
2615 exception);
2616 break;
2617 }
2618 if (LocaleCompare("scale",option+1) == 0)
2619 {
2620 /*
2621 Resize image.
2622 */
2623 (void) SyncImageSettings(mogrify_info,*image,exception);
2624 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
2625 mogrify_image=ScaleImage(*image,geometry.width,geometry.height,
2626 exception);
2627 break;
2628 }
2629 if (LocaleCompare("selective-blur",option+1) == 0)
2630 {
2631 /*
2632 Selectively blur pixels within a contrast threshold.
2633 */
2634 (void) SyncImageSettings(mogrify_info,*image,exception);
2635 flags=ParseGeometry(argv[i+1],&geometry_info);
2636 if ((flags & PercentValue) != 0)
2637 geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
2638 mogrify_image=SelectiveBlurImage(*image,geometry_info.rho,
2639 geometry_info.sigma,geometry_info.xi,exception);
2640 break;
2641 }
2642 if (LocaleCompare("separate",option+1) == 0)
2643 {
2644 /*
2645 Break channels into separate images.
2646 */
2647 (void) SyncImageSettings(mogrify_info,*image,exception);
2648 mogrify_image=SeparateImages(*image,exception);
2649 break;
2650 }
2651 if (LocaleCompare("sepia-tone",option+1) == 0)
2652 {
2653 double
2654 threshold;
2655
2656 /*
2657 Sepia-tone image.
2658 */
2659 (void) SyncImageSettings(mogrify_info,*image,exception);
2660 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+
2661 1.0);
2662 mogrify_image=SepiaToneImage(*image,threshold,exception);
2663 break;
2664 }
2665 if (LocaleCompare("segment",option+1) == 0)
2666 {
2667 /*
2668 Segment image.
2669 */
2670 (void) SyncImageSettings(mogrify_info,*image,exception);
2671 flags=ParseGeometry(argv[i+1],&geometry_info);
2672 if ((flags & SigmaValue) == 0)
2673 geometry_info.sigma=1.0;
2674 (void) SegmentImage(*image,(*image)->colorspace,
2675 mogrify_info->verbose,geometry_info.rho,geometry_info.sigma,
2676 exception);
2677 break;
2678 }
2679 if (LocaleCompare("set",option+1) == 0)
2680 {
2681 char
2682 *value;
2683
2684 /*
2685 Set image option.
2686 */
2687 if (*option == '+')
2688 {
2689 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
2690 (void) DeleteImageRegistry(argv[i+1]+9);
2691 else
2692 if (LocaleNCompare(argv[i+1],"option:",7) == 0)
2693 {
2694 (void) DeleteImageOption(mogrify_info,argv[i+1]+7);
2695 (void) DeleteImageArtifact(*image,argv[i+1]+7);
2696 }
2697 else
2698 (void) DeleteImageProperty(*image,argv[i+1]);
2699 break;
2700 }
2701 value=InterpretImageProperties(mogrify_info,*image,argv[i+2],
2702 exception);
2703 if (value == (char *) NULL)
2704 break;
2705 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
2706 (void) SetImageRegistry(StringRegistryType,argv[i+1]+9,value,
2707 exception);
2708 else
2709 if (LocaleNCompare(argv[i+1],"option:",7) == 0)
2710 {
2711 (void) SetImageOption(image_info,argv[i+1]+7,value);
2712 (void) SetImageOption(mogrify_info,argv[i+1]+7,value);
2713 (void) SetImageArtifact(*image,argv[i+1]+7,value);
2714 }
2715 else
2716 if (LocaleCompare(argv[i+1],"profile") == 0)
2717 {
2718 StringInfo
2719 *profile = (StringInfo *) NULL;
2720
2721 (void) CopyMagickString(image_info->filename,value,
2722 MagickPathExtent);
2723 (void) SetImageInfo(image_info,1,exception);
2724 if (LocaleCompare(image_info->filename,"-") != 0)
2725 profile=FileToStringInfo(image_info->filename,~0UL,
2726 exception);
2727 if (profile != (StringInfo *) NULL)
2728 {
2729 SetStringInfoName(profile,image_info->magick);
2730 status=SetImageProfilePrivate(*image,profile,exception);
2731 }
2732 }
2733 else
2734 (void) SetImageProperty(*image,argv[i+1],value,exception);
2735 value=DestroyString(value);
2736 break;
2737 }
2738 if (LocaleCompare("shade",option+1) == 0)
2739 {
2740 /*
2741 Shade image.
2742 */
2743 (void) SyncImageSettings(mogrify_info,*image,exception);
2744 flags=ParseGeometry(argv[i+1],&geometry_info);
2745 if ((flags & SigmaValue) == 0)
2746 geometry_info.sigma=1.0;
2747 mogrify_image=ShadeImage(*image,(*option == '-') ? MagickTrue :
2748 MagickFalse,geometry_info.rho,geometry_info.sigma,exception);
2749 break;
2750 }
2751 if (LocaleCompare("shadow",option+1) == 0)
2752 {
2753 /*
2754 Shadow image.
2755 */
2756 (void) SyncImageSettings(mogrify_info,*image,exception);
2757 flags=ParseGeometry(argv[i+1],&geometry_info);
2758 if ((flags & SigmaValue) == 0)
2759 geometry_info.sigma=1.0;
2760 if ((flags & XiValue) == 0)
2761 geometry_info.xi=4.0;
2762 if ((flags & PsiValue) == 0)
2763 geometry_info.psi=4.0;
2764 mogrify_image=ShadowImage(*image,geometry_info.rho,
2765 geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),
2766 (ssize_t) ceil(geometry_info.psi-0.5),exception);
2767 break;
2768 }
2769 if (LocaleCompare("sharpen",option+1) == 0)
2770 {
2771 /*
2772 Sharpen image.
2773 */
2774 (void) SyncImageSettings(mogrify_info,*image,exception);
2775 flags=ParseGeometry(argv[i+1],&geometry_info);
2776 if ((flags & SigmaValue) == 0)
2777 geometry_info.sigma=1.0;
2778 if ((flags & XiValue) == 0)
2779 geometry_info.xi=0.0;
2780 mogrify_image=SharpenImage(*image,geometry_info.rho,
2781 geometry_info.sigma,exception);
2782 break;
2783 }
2784 if (LocaleCompare("shave",option+1) == 0)
2785 {
2786 /*
2787 Shave the image edges.
2788 */
2789 (void) SyncImageSettings(mogrify_info,*image,exception);
2790 flags=ParsePageGeometry(*image,argv[i+1],&geometry,exception);
2791 mogrify_image=ShaveImage(*image,&geometry,exception);
2792 break;
2793 }
2794 if (LocaleCompare("shear",option+1) == 0)
2795 {
2796 /*
2797 Shear image.
2798 */
2799 (void) SyncImageSettings(mogrify_info,*image,exception);
2800 flags=ParseGeometry(argv[i+1],&geometry_info);
2801 if ((flags & SigmaValue) == 0)
2802 geometry_info.sigma=geometry_info.rho;
2803 mogrify_image=ShearImage(*image,geometry_info.rho,
2804 geometry_info.sigma,exception);
2805 break;
2806 }
2807 if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
2808 {
2809 /*
2810 Sigmoidal non-linearity contrast control.
2811 */
2812 (void) SyncImageSettings(mogrify_info,*image,exception);
2813 flags=ParseGeometry(argv[i+1],&geometry_info);
2814 if ((flags & SigmaValue) == 0)
2815 geometry_info.sigma=(double) QuantumRange/2.0;
2816 if ((flags & PercentValue) != 0)
2817 geometry_info.sigma=(double) QuantumRange*geometry_info.sigma/
2818 100.0;
2819 (void) SigmoidalContrastImage(*image,(*option == '-') ?
2820 MagickTrue : MagickFalse,geometry_info.rho,geometry_info.sigma,
2821 exception);
2822 break;
2823 }
2824 if (LocaleCompare("sketch",option+1) == 0)
2825 {
2826 /*
2827 Sketch image.
2828 */
2829 (void) SyncImageSettings(mogrify_info,*image,exception);
2830 flags=ParseGeometry(argv[i+1],&geometry_info);
2831 if ((flags & SigmaValue) == 0)
2832 geometry_info.sigma=1.0;
2833 mogrify_image=SketchImage(*image,geometry_info.rho,
2834 geometry_info.sigma,geometry_info.xi,exception);
2835 break;
2836 }
2837 if (LocaleCompare("solarize",option+1) == 0)
2838 {
2839 double
2840 threshold;
2841
2842 (void) SyncImageSettings(mogrify_info,*image,exception);
2843 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+
2844 1.0);
2845 (void) SolarizeImage(*image,threshold,exception);
2846 break;
2847 }
2848 if (LocaleCompare("sort-pixels",option+1) == 0)
2849 {
2850 /*
2851 Sort each scanline in scending order of intensity.
2852 */
2853 (void) SyncImageSettings(mogrify_info,*image,exception);
2854 (void) SortImagePixels(*image,exception);
2855 break;
2856 }
2857 if (LocaleCompare("sparse-color",option+1) == 0)
2858 {
2859 SparseColorMethod
2860 method;
2861
2862 char
2863 *arguments;
2864
2865 /*
2866 Sparse Color Interpolated Gradient
2867 */
2868 (void) SyncImageSettings(mogrify_info,*image,exception);
2869 method=(SparseColorMethod) ParseCommandOption(
2870 MagickSparseColorOptions,MagickFalse,argv[i+1]);
2871 arguments=InterpretImageProperties(mogrify_info,*image,argv[i+2],
2872 exception);
2873 if (arguments == (char *) NULL)
2874 break;
2875 mogrify_image=SparseColorOption(*image,method,arguments,
2876 option[0] == '+' ? MagickTrue : MagickFalse,exception);
2877 arguments=DestroyString(arguments);
2878 break;
2879 }
2880 if (LocaleCompare("splice",option+1) == 0)
2881 {
2882 /*
2883 Splice a solid color into the image.
2884 */
2885 (void) SyncImageSettings(mogrify_info,*image,exception);
2886 (void) ParseGravityGeometry(*image,argv[i+1],&geometry,exception);
2887 mogrify_image=SpliceImage(*image,&geometry,exception);
2888 break;
2889 }
2890 if (LocaleCompare("spread",option+1) == 0)
2891 {
2892 /*
2893 Spread an image.
2894 */
2895 (void) SyncImageSettings(mogrify_info,*image,exception);
2896 (void) ParseGeometry(argv[i+1],&geometry_info);
2897 mogrify_image=SpreadImage(*image,interpolate_method,
2898 geometry_info.rho,exception);
2899 break;
2900 }
2901 if (LocaleCompare("statistic",option+1) == 0)
2902 {
2903 StatisticType
2904 type;
2905
2906 (void) SyncImageSettings(mogrify_info,*image,exception);
2907 type=(StatisticType) ParseCommandOption(MagickStatisticOptions,
2908 MagickFalse,argv[i+1]);
2909 (void) ParseGeometry(argv[i+2],&geometry_info);
2910 mogrify_image=StatisticImage(*image,type,(size_t) geometry_info.rho,
2911 (size_t) geometry_info.sigma,exception);
2912 break;
2913 }
2914 if (LocaleCompare("stretch",option+1) == 0)
2915 {
2916 if (*option == '+')
2917 {
2918 draw_info->stretch=UndefinedStretch;
2919 break;
2920 }
2921 draw_info->stretch=(StretchType) ParseCommandOption(
2922 MagickStretchOptions,MagickFalse,argv[i+1]);
2923 break;
2924 }
2925 if (LocaleCompare("strip",option+1) == 0)
2926 {
2927 /*
2928 Strip image of profiles and comments.
2929 */
2930 (void) SyncImageSettings(mogrify_info,*image,exception);
2931 (void) StripImage(*image,exception);
2932 break;
2933 }
2934 if (LocaleCompare("stroke",option+1) == 0)
2935 {
2936 ExceptionInfo
2937 *sans;
2938
2939 PixelInfo
2940 color;
2941
2942 if (*option == '+')
2943 {
2944 (void) QueryColorCompliance("none",AllCompliance,
2945 &draw_info->stroke,exception);
2946 if (draw_info->stroke_pattern != (Image *) NULL)
2947 draw_info->stroke_pattern=DestroyImage(
2948 draw_info->stroke_pattern);
2949 break;
2950 }
2951 sans=AcquireExceptionInfo();
2952 status=QueryColorCompliance(argv[i+1],AllCompliance,&color,sans);
2953 sans=DestroyExceptionInfo(sans);
2954 if (status == MagickFalse)
2955 draw_info->stroke_pattern=GetImageCache(mogrify_info,argv[i+1],
2956 exception);
2957 else
2958 draw_info->stroke=color;
2959 break;
2960 }
2961 if (LocaleCompare("strokewidth",option+1) == 0)
2962 {
2963 draw_info->stroke_width=StringToDouble(argv[i+1],(char **) NULL);
2964 break;
2965 }
2966 if (LocaleCompare("style",option+1) == 0)
2967 {
2968 if (*option == '+')
2969 {
2970 draw_info->style=UndefinedStyle;
2971 break;
2972 }
2973 draw_info->style=(StyleType) ParseCommandOption(MagickStyleOptions,
2974 MagickFalse,argv[i+1]);
2975 break;
2976 }
2977 if (LocaleCompare("swirl",option+1) == 0)
2978 {
2979 /*
2980 Swirl image.
2981 */
2982 (void) SyncImageSettings(mogrify_info,*image,exception);
2983 (void) ParseGeometry(argv[i+1],&geometry_info);
2984 mogrify_image=SwirlImage(*image,geometry_info.rho,
2985 interpolate_method,exception);
2986 break;
2987 }
2988 break;
2989 }
2990 case 't':
2991 {
2992 if (LocaleCompare("threshold",option+1) == 0)
2993 {
2994 double
2995 threshold;
2996
2997 /*
2998 Threshold image.
2999 */
3000 (void) SyncImageSettings(mogrify_info,*image,exception);
3001 if (*option == '+')
3002 threshold=(double) QuantumRange/2;
3003 else
3004 threshold=StringToDoubleInterval(argv[i+1],(double) QuantumRange+
3005 1.0);
3006 (void) BilevelImage(*image,threshold,exception);
3007 break;
3008 }
3009 if (LocaleCompare("thumbnail",option+1) == 0)
3010 {
3011 /*
3012 Thumbnail image.
3013 */
3014 (void) SyncImageSettings(mogrify_info,*image,exception);
3015 (void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
3016 mogrify_image=ThumbnailImage(*image,geometry.width,geometry.height,
3017 exception);
3018 break;
3019 }
3020 if (LocaleCompare("tile",option+1) == 0)
3021 {
3022 if (*option == '+')
3023 {
3024 if (draw_info->fill_pattern != (Image *) NULL)
3025 draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern);
3026 break;
3027 }
3028 draw_info->fill_pattern=GetImageCache(mogrify_info,argv[i+1],
3029 exception);
3030 break;
3031 }
3032 if (LocaleCompare("tint",option+1) == 0)
3033 {
3034 /*
3035 Tint the image.
3036 */
3037 (void) SyncImageSettings(mogrify_info,*image,exception);
3038 mogrify_image=TintImage(*image,argv[i+1],&fill,exception);
3039 break;
3040 }
3041 if (LocaleCompare("transform",option+1) == 0)
3042 {
3043 /*
3044 Affine transform image.
3045 */
3046 (void) SyncImageSettings(mogrify_info,*image,exception);
3047 mogrify_image=AffineTransformImage(*image,&draw_info->affine,
3048 exception);
3049 break;
3050 }
3051 if (LocaleCompare("transparent",option+1) == 0)
3052 {
3053 PixelInfo
3054 target;
3055
3056 (void) SyncImageSettings(mogrify_info,*image,exception);
3057 (void) QueryColorCompliance(argv[i+1],AllCompliance,&target,
3058 exception);
3059 (void) TransparentPaintImage(*image,&target,(Quantum)
3060 TransparentAlpha,*option == '-' ? MagickFalse : MagickTrue,
3061 exception);
3062 break;
3063 }
3064 if (LocaleCompare("transpose",option+1) == 0)
3065 {
3066 /*
3067 Transpose image scanlines.
3068 */
3069 (void) SyncImageSettings(mogrify_info,*image,exception);
3070 mogrify_image=TransposeImage(*image,exception);
3071 break;
3072 }
3073 if (LocaleCompare("transverse",option+1) == 0)
3074 {
3075 /*
3076 Transverse image scanlines.
3077 */
3078 (void) SyncImageSettings(mogrify_info,*image,exception);
3079 mogrify_image=TransverseImage(*image,exception);
3080 break;
3081 }
3082 if (LocaleCompare("treedepth",option+1) == 0)
3083 {
3084 quantize_info->tree_depth=StringToUnsignedLong(argv[i+1]);
3085 break;
3086 }
3087 if (LocaleCompare("trim",option+1) == 0)
3088 {
3089 /*
3090 Trim image.
3091 */
3092 (void) SyncImageSettings(mogrify_info,*image,exception);
3093 mogrify_image=TrimImage(*image,exception);
3094 break;
3095 }
3096 if (LocaleCompare("type",option+1) == 0)
3097 {
3098 ImageType
3099 type;
3100
3101 (void) SyncImageSettings(mogrify_info,*image,exception);
3102 if (*option == '+')
3103 type=UndefinedType;
3104 else
3105 type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
3106 argv[i+1]);
3107 (*image)->type=UndefinedType;
3108 (void) SetImageType(*image,type,exception);
3109 break;
3110 }
3111 break;
3112 }
3113 case 'u':
3114 {
3115 if (LocaleCompare("undercolor",option+1) == 0)
3116 {
3117 (void) QueryColorCompliance(argv[i+1],AllCompliance,
3118 &draw_info->undercolor,exception);
3119 break;
3120 }
3121 if (LocaleCompare("unique",option+1) == 0)
3122 {
3123 if (*option == '+')
3124 {
3125 (void) DeleteImageArtifact(*image,"identify:unique-colors");
3126 break;
3127 }
3128 (void) SetImageArtifact(*image,"identify:unique-colors","true");
3129 (void) SetImageArtifact(*image,"verbose","true");
3130 break;
3131 }
3132 if (LocaleCompare("unique-colors",option+1) == 0)
3133 {
3134 /*
3135 Unique image colors.
3136 */
3137 (void) SyncImageSettings(mogrify_info,*image,exception);
3138 mogrify_image=UniqueImageColors(*image,exception);
3139 break;
3140 }
3141 if (LocaleCompare("unsharp",option+1) == 0)
3142 {
3143 /*
3144 Unsharp mask image.
3145 */
3146 (void) SyncImageSettings(mogrify_info,*image,exception);
3147 flags=ParseGeometry(argv[i+1],&geometry_info);
3148 if ((flags & SigmaValue) == 0)
3149 geometry_info.sigma=1.0;
3150 if ((flags & XiValue) == 0)
3151 geometry_info.xi=1.0;
3152 if ((flags & PsiValue) == 0)
3153 geometry_info.psi=0.05;
3154 mogrify_image=UnsharpMaskImage(*image,geometry_info.rho,
3155 geometry_info.sigma,geometry_info.xi,geometry_info.psi,
3156 exception);
3157 break;
3158 }
3159 break;
3160 }
3161 case 'v':
3162 {
3163 if (LocaleCompare("verbose",option+1) == 0)
3164 {
3165 (void) SetImageArtifact(*image,option+1,
3166 *option == '+' ? "false" : "true");
3167 break;
3168 }
3169 if (LocaleCompare("vignette",option+1) == 0)
3170 {
3171 /*
3172 Vignette image.
3173 */
3174 (void) SyncImageSettings(mogrify_info,*image,exception);
3175 flags=ParseGeometry(argv[i+1],&geometry_info);
3176 if ((flags & SigmaValue) == 0)
3177 geometry_info.sigma=1.0;
3178 if ((flags & XiValue) == 0)
3179 geometry_info.xi=0.1*(*image)->columns;
3180 if ((flags & PsiValue) == 0)
3181 geometry_info.psi=0.1*(*image)->rows;
3182 if ((flags & PercentValue) != 0)
3183 {
3184 geometry_info.xi*=(double) (*image)->columns/100.0;
3185 geometry_info.psi*=(double) (*image)->rows/100.0;
3186 }
3187 mogrify_image=VignetteImage(*image,geometry_info.rho,
3188 geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),
3189 (ssize_t) ceil(geometry_info.psi-0.5),exception);
3190 break;
3191 }
3192 if (LocaleCompare("virtual-pixel",option+1) == 0)
3193 {
3194 if (*option == '+')
3195 {
3196 (void) SetImageVirtualPixelMethod(*image,
3197 UndefinedVirtualPixelMethod,exception);
3198 break;
3199 }
3200 (void) SetImageVirtualPixelMethod(*image,(VirtualPixelMethod)
3201 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
3202 argv[i+1]),exception);
3203 break;
3204 }
3205 break;
3206 }
3207 case 'w':
3208 {
3209 if (LocaleCompare("wave",option+1) == 0)
3210 {
3211 /*
3212 Wave image.
3213 */
3214 (void) SyncImageSettings(mogrify_info,*image,exception);
3215 flags=ParseGeometry(argv[i+1],&geometry_info);
3216 if ((flags & SigmaValue) == 0)
3217 geometry_info.sigma=1.0;
3218 mogrify_image=WaveImage(*image,geometry_info.rho,
3219 geometry_info.sigma,interpolate_method,exception);
3220 break;
3221 }
3222 if (LocaleCompare("wavelet-denoise",option+1) == 0)
3223 {
3224 /*
3225 Wavelet denoise image.
3226 */
3227 (void) SyncImageSettings(mogrify_info,*image,exception);
3228 flags=ParseGeometry(argv[i+1],&geometry_info);
3229 if ((flags & PercentValue) != 0)
3230 {
3231 geometry_info.rho=(double) QuantumRange*geometry_info.rho/100.0;
3232 geometry_info.sigma=(double) QuantumRange*geometry_info.sigma/
3233 100.0;
3234 }
3235 if ((flags & SigmaValue) == 0)
3236 geometry_info.sigma=0.0;
3237 mogrify_image=WaveletDenoiseImage(*image,geometry_info.rho,
3238 geometry_info.sigma,exception);
3239 break;
3240 }
3241 if (LocaleCompare("weight",option+1) == 0)
3242 {
3243 ssize_t
3244 weight;
3245
3246 weight=ParseCommandOption(MagickWeightOptions,MagickFalse,
3247 argv[i+1]);
3248 if (weight == -1)
3249 weight=(ssize_t) StringToUnsignedLong(argv[i+1]);
3250 draw_info->weight=(size_t) weight;
3251 break;
3252 }
3253 if (LocaleCompare("white-balance",option+1) == 0)
3254 {
3255 /*
3256 White balance image.
3257 */
3258 (void) SyncImageSettings(mogrify_info,*image,exception);
3259 (void) WhiteBalanceImage(*image,exception);
3260 break;
3261 }
3262 if (LocaleCompare("white-threshold",option+1) == 0)
3263 {
3264 /*
3265 White threshold image.
3266 */
3267 (void) SyncImageSettings(mogrify_info,*image,exception);
3268 (void) WhiteThresholdImage(*image,argv[i+1],exception);
3269 break;
3270 }
3271 if (LocaleCompare("write-mask",option+1) == 0)
3272 {
3273 Image
3274 *mask;
3275
3276 (void) SyncImageSettings(mogrify_info,*image,exception);
3277 if (*option == '+')
3278 {
3279 /*
3280 Remove a mask.
3281 */
3282 (void) SetImageMask(*image,WritePixelMask,(const Image *) NULL,
3283 exception);
3284 break;
3285 }
3286 /*
3287 Set the image mask.
3288 */
3289 mask=GetImageCache(mogrify_info,argv[i+1],exception);
3290 if (mask == (Image *) NULL)
3291 break;
3292 (void) SetImageMask(*image,WritePixelMask,mask,exception);
3293 mask=DestroyImage(mask);
3294 break;
3295 }
3296 if (LocaleCompare("word-break",option+1) == 0)
3297 {
3298 (void) SetImageOption(image_info,option+1,argv[i+1]);
3299 break;
3300 }
3301 break;
3302 }
3303 default:
3304 break;
3305 }
3306 /*
3307 Replace current image with any image that was generated
3308 */
3309 if (mogrify_image != (Image *) NULL)
3310 ReplaceImageInListReturnLast(image,mogrify_image);
3311 i+=count;
3312 }
3313 /*
3314 Free resources.
3315 */
3316 quantize_info=DestroyQuantizeInfo(quantize_info);
3317 draw_info=DestroyDrawInfo(draw_info);
3318 mogrify_info=DestroyImageInfo(mogrify_info);
3319 status=(MagickStatusType) (exception->severity < ErrorException ? 1 : 0);
3320 return(status == 0 ? MagickFalse : MagickTrue);
3321}
3322␌
3323/*
3324%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3325% %
3326% %
3327% %
3328+ M o g r i f y I m a g e C o m m a n d %
3329% %
3330% %
3331% %
3332%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3333%
3334% MogrifyImageCommand() transforms an image or a sequence of images. These
3335% transforms include image scaling, image rotation, color reduction, and
3336% others. The transmogrified image overwrites the original image.
3337%
3338% The format of the MogrifyImageCommand method is:
3339%
3340% MagickBooleanType MogrifyImageCommand(ImageInfo *image_info,int argc,
3341% const char **argv,char **metadata,ExceptionInfo *exception)
3342%
3343% A description of each parameter follows:
3344%
3345% o image_info: the image info.
3346%
3347% o argc: the number of elements in the argument vector.
3348%
3349% o argv: A text array containing the command line arguments.
3350%
3351% o metadata: any metadata is returned here.
3352%
3353% o exception: return any errors or warnings in this structure.
3354%
3355*/
3356
3357static MagickBooleanType MogrifyUsage(void)
3358{
3359 static const char
3360 channel_operators[] =
3361 " -channel-fx expression\n"
3362 " exchange, extract, or transfer one or more image channels\n"
3363 " -separate separate an image channel into a grayscale image",
3364 miscellaneous[] =
3365 " -debug events display copious debugging information\n"
3366 " -distribute-cache port\n"
3367 " distributed pixel cache spanning one or more servers\n"
3368 " -help print program options\n"
3369 " -list type print a list of supported option arguments\n"
3370 " -log format format of debugging information\n"
3371 " -version print version information",
3372 operators[] =
3373 " -adaptive-blur geometry\n"
3374 " adaptively blur pixels; decrease effect near edges\n"
3375 " -adaptive-resize geometry\n"
3376 " adaptively resize image using 'mesh' interpolation\n"
3377 " -adaptive-sharpen geometry\n"
3378 " adaptively sharpen pixels; increase effect near edges\n"
3379 " -alpha option on, activate, off, deactivate, set, opaque, copy\n"
3380 " transparent, extract, background, or shape\n"
3381 " -annotate geometry text\n"
3382 " annotate the image with text\n"
3383 " -auto-gamma automagically adjust gamma level of image\n"
3384 " -auto-level automagically adjust color levels of image\n"
3385 " -auto-orient automagically orient (rotate) image\n"
3386 " -auto-threshold method\n"
3387 " automatically perform image thresholding\n"
3388 " -bench iterations measure performance\n"
3389 " -bilateral-blur geometry\n"
3390 " non-linear, edge-preserving, and noise-reducing smoothing filter\n"
3391 " -black-threshold value\n"
3392 " force all pixels below the threshold into black\n"
3393 " -blue-shift simulate a scene at nighttime in the moonlight\n"
3394 " -blur geometry reduce image noise and reduce detail levels\n"
3395 " -border geometry surround image with a border of color\n"
3396 " -bordercolor color border color\n"
3397 " -brightness-contrast geometry\n"
3398 " improve brightness / contrast of the image\n"
3399 " -canny geometry detect edges in the image\n"
3400 " -cdl filename color correct with a color decision list\n"
3401 " -channel mask set the image channel mask\n"
3402 " -charcoal geometry simulate a charcoal drawing\n"
3403 " -chop geometry remove pixels from the image interior\n"
3404 " -clahe geometry contrast limited adaptive histogram equalization\n"
3405 " -clamp keep pixel values in range (0-QuantumRange)\n"
3406 " -clip clip along the first path from the 8BIM profile\n"
3407 " -clip-mask filename associate a clip mask with the image\n"
3408 " -clip-path id clip along a named path from the 8BIM profile\n"
3409 " -colorize value colorize the image with the fill color\n"
3410 " -color-matrix matrix apply color correction to the image\n"
3411 " -colors value preferred number of colors in the image\n"
3412 " -color-threshold start_color-stop_color\n"
3413 " force all pixels in the color range to white otherwise black\n"
3414 " -connected-components connectivity\n"
3415 " connected-components uniquely labeled\n"
3416 " -contrast enhance or reduce the image contrast\n"
3417 " -contrast-stretch geometry\n"
3418 " improve contrast by 'stretching' the intensity range\n"
3419 " -convolve coefficients\n"
3420 " apply a convolution kernel to the image\n"
3421 " -cycle amount cycle the image colormap\n"
3422 " -decipher filename convert cipher pixels to plain pixels\n"
3423 " -deskew threshold straighten an image\n"
3424 " -despeckle reduce the speckles within an image\n"
3425 " -distort method args\n"
3426 " distort images according to given method ad args\n"
3427 " -draw string annotate the image with a graphic primitive\n"
3428 " -edge radius apply a filter to detect edges in the image\n"
3429 " -encipher filename convert plain pixels to cipher pixels\n"
3430 " -emboss radius emboss an image\n"
3431 " -enhance apply a digital filter to enhance a noisy image\n"
3432 " -equalize perform histogram equalization to an image\n"
3433 " -evaluate operator value\n"
3434 " evaluate an arithmetic, relational, or logical expression\n"
3435 " -extent geometry set the image size\n"
3436 " -extract geometry extract area from image\n"
3437 " -fft implements the discrete Fourier transform (DFT)\n"
3438 " -flip flip image vertically\n"
3439 " -floodfill geometry color\n"
3440 " floodfill the image with color\n"
3441 " -flop flop image horizontally\n"
3442 " -frame geometry surround image with an ornamental border\n"
3443 " -function name parameters\n"
3444 " apply function over image values\n"
3445 " -gamma value level of gamma correction\n"
3446 " -gaussian-blur geometry\n"
3447 " reduce image noise and reduce detail levels\n"
3448 " -geometry geometry preferred size or location of the image\n"
3449 " -grayscale method convert image to grayscale\n"
3450 " -hough-lines geometry\n"
3451 " identify lines in the image\n"
3452 " -identify identify the format and characteristics of the image\n"
3453 " -ift implements the inverse discrete Fourier transform (DFT)\n"
3454 " -implode amount implode image pixels about the center\n"
3455 " -integral calculate the sum of values (pixel values) in the image\n"
3456 " -interpolative-resize geometry\n"
3457 " resize image using interpolation\n"
3458 " -kmeans geometry K means color reduction\n"
3459 " -kuwahara geometry edge preserving noise reduction filter\n"
3460 " -lat geometry local adaptive thresholding\n"
3461 " -level value adjust the level of image contrast\n"
3462 " -level-colors color,color\n"
3463 " level image with the given colors\n"
3464 " -linear-stretch geometry\n"
3465 " improve contrast by 'stretching with saturation'\n"
3466 " -liquid-rescale geometry\n"
3467 " rescale image with seam-carving\n"
3468 " -local-contrast geometry\n"
3469 " enhance local contrast\n"
3470 " -magnify double the size of the image with pixel art scaling\n"
3471 " -mean-shift geometry delineate arbitrarily shaped clusters in the image\n"
3472 " -median geometry apply a median filter to the image\n"
3473 " -mode geometry make each pixel the 'predominant color' of the\n"
3474 " neighborhood\n"
3475 " -modulate value vary the brightness, saturation, and hue\n"
3476 " -monochrome transform image to black and white\n"
3477 " -morphology method kernel\n"
3478 " apply a morphology method to the image\n"
3479 " -motion-blur geometry\n"
3480 " simulate motion blur\n"
3481 " -negate replace every pixel with its complementary color \n"
3482 " -noise geometry add or reduce noise in an image\n"
3483 " -normalize transform image to span the full range of colors\n"
3484 " -opaque color change this color to the fill color\n"
3485 " -ordered-dither NxN\n"
3486 " add a noise pattern to the image with specific\n"
3487 " amplitudes\n"
3488 " -paint radius simulate an oil painting\n"
3489 " -perceptible epsilon\n"
3490 " pixel value less than |epsilon| become epsilon or\n"
3491 " -epsilon\n"
3492 " -polaroid angle simulate a Polaroid picture\n"
3493 " -posterize levels reduce the image to a limited number of color levels\n"
3494 " -profile filename add, delete, or apply an image profile\n"
3495 " -quantize colorspace reduce colors in this colorspace\n"
3496 " -raise value lighten/darken image edges to create a 3-D effect\n"
3497 " -random-threshold low,high\n"
3498 " random threshold the image\n"
3499 " -range-threshold values\n"
3500 " perform either hard or soft thresholding within some range of values in an image\n"
3501 " -region geometry apply options to a portion of the image\n"
3502 " -render render vector graphics\n"
3503 " -repage geometry size and location of an image canvas\n"
3504 " -resample geometry change the resolution of an image\n"
3505 " -reshape geometry reshape the image\n"
3506 " -resize geometry resize the image\n"
3507 " -roll geometry roll an image vertically or horizontally\n"
3508 " -rotate degrees apply Paeth rotation to the image\n"
3509 " -rotational-blur angle\n"
3510 " rotational blur the image\n"
3511 " -sample geometry scale image with pixel sampling\n"
3512 " -scale geometry scale the image\n"
3513 " -segment values segment an image\n"
3514 " -selective-blur geometry\n"
3515 " selectively blur pixels within a contrast threshold\n"
3516 " -sepia-tone threshold\n"
3517 " simulate a sepia-toned photo\n"
3518 " -set property value set an image property\n"
3519 " -shade degrees shade the image using a distant light source\n"
3520 " -shadow geometry simulate an image shadow\n"
3521 " -sharpen geometry sharpen the image\n"
3522 " -shave geometry shave pixels from the image edges\n"
3523 " -shear geometry slide one edge of the image along the X or Y axis\n"
3524 " -sigmoidal-contrast geometry\n"
3525 " increase the contrast without saturating highlights or\n"
3526 " shadows\n"
3527 " -sketch geometry simulate a pencil sketch\n"
3528 " -solarize threshold negate all pixels above the threshold level\n"
3529 " -sort-pixels sort each scanline in ascending order of intensity\n"
3530 " -sparse-color method args\n"
3531 " fill in a image based on a few color points\n"
3532 " -splice geometry splice the background color into the image\n"
3533 " -spread radius displace image pixels by a random amount\n"
3534 " -statistic type radius\n"
3535 " replace each pixel with corresponding statistic from the neighborhood\n"
3536 " -strip strip image of all profiles and comments\n"
3537 " -swirl degrees swirl image pixels about the center\n"
3538 " -threshold value threshold the image\n"
3539 " -thumbnail geometry create a thumbnail of the image\n"
3540 " -tile filename tile image when filling a graphic primitive\n"
3541 " -tint value tint the image with the fill color\n"
3542 " -transform affine transform image\n"
3543 " -transparent color make this color transparent within the image\n"
3544 " -transpose flip image vertically and rotate 90 degrees\n"
3545 " -transverse flop image horizontally and rotate 270 degrees\n"
3546 " -trim trim image edges\n"
3547 " -type type image type\n"
3548 " -unique-colors discard all but one of any pixel color\n"
3549 " -unsharp geometry sharpen the image\n"
3550 " -vignette geometry soften the edges of the image in vignette style\n"
3551 " -wave geometry alter an image along a sine wave\n"
3552 " -wavelet-denoise threshold\n"
3553 " removes noise from the image using a wavelet transform\n"
3554 " -white-balance automagically adjust white balance of image\n"
3555 " -white-threshold value\n"
3556 " force all pixels above the threshold into white",
3557 sequence_operators[] =
3558 " -affinity filename transform image colors to match this set of colors\n"
3559 " -append append an image sequence\n"
3560 " -clut apply a color lookup table to the image\n"
3561 " -coalesce merge a sequence of images\n"
3562 " -combine combine a sequence of images\n"
3563 " -compare mathematically and visually annotate the difference between an image and its reconstruction\n"
3564 " -complex operator perform complex mathematics on an image sequence\n"
3565 " -composite composite image\n"
3566 " -copy geometry offset\n"
3567 " copy pixels from one area of an image to another\n"
3568 " -crop geometry cut out a rectangular region of the image\n"
3569 " -deconstruct break down an image sequence into constituent parts\n"
3570 " -evaluate-sequence operator\n"
3571 " evaluate an arithmetic, relational, or logical expression\n"
3572 " -flatten flatten a sequence of images\n"
3573 " -fx expression apply mathematical expression to an image channel(s)\n"
3574 " -hald-clut apply a Hald color lookup table to the image\n"
3575 " -layers method optimize, merge, or compare image layers\n"
3576 " -morph value morph an image sequence\n"
3577 " -mosaic create a mosaic from an image sequence\n"
3578 " -poly terms build a polynomial from the image sequence and the corresponding\n"
3579 " terms (coefficients and degree pairs).\n"
3580 " -print string interpret string and print to console\n"
3581 " -process arguments process the image with a custom image filter\n"
3582 " -smush geometry smush an image sequence together\n"
3583 " -write filename write images to this file",
3584 settings[] =
3585 " -adjoin join images into a single multi-image file\n"
3586 " -affine matrix affine transform matrix\n"
3587 " -alpha option activate, deactivate, reset, or set the alpha channel\n"
3588 " -antialias remove pixel-aliasing\n"
3589 " -authenticate password\n"
3590 " decipher image with this password\n"
3591 " -attenuate value lessen (or intensify) when adding noise to an image\n"
3592 " -background color background color\n"
3593 " -bias value add bias when convolving an image\n"
3594 " -black-point-compensation\n"
3595 " use black point compensation\n"
3596 " -blue-primary point chromaticity blue primary point\n"
3597 " -bordercolor color border color\n"
3598 " -caption string assign a caption to an image\n"
3599 " -colorspace type alternate image colorspace\n"
3600 " -comment string annotate image with comment\n"
3601 " -compose operator set image composite operator\n"
3602 " -compress type type of pixel compression when writing the image\n"
3603 " -define format:option=value\n"
3604 " define one or more image format options\n"
3605 " -delay value display the next image after pausing\n"
3606 " -density geometry horizontal and vertical density of the image\n"
3607 " -depth value image depth\n"
3608 " -direction type render text right-to-left or left-to-right\n"
3609 " -display server get image or font from this X server\n"
3610 " -dispose method layer disposal method\n"
3611 " -dither method apply error diffusion to image\n"
3612 " -encoding type text encoding type\n"
3613 " -endian type endianness (MSB or LSB) of the image\n"
3614 " -family name render text with this font family\n"
3615 " -features distance analyze image features (e.g. contrast, correlation)\n"
3616 " -fill color color to use when filling a graphic primitive\n"
3617 " -filter type use this filter when resizing an image\n"
3618 " -font name render text with this font\n"
3619 " -format \"string\" output formatted image characteristics\n"
3620 " -fuzz distance colors within this distance are considered equal\n"
3621 " -gravity type horizontal and vertical text placement\n"
3622 " -green-primary point chromaticity green primary point\n"
3623 " -illuminant type reference illuminant\n"
3624 " -intensity method method to generate an intensity value from a pixel\n"
3625 " -intent type type of rendering intent when managing the image color\n"
3626 " -interlace type type of image interlacing scheme\n"
3627 " -interline-spacing value\n"
3628 " set the space between two text lines\n"
3629 " -interpolate method pixel color interpolation method\n"
3630 " -interword-spacing value\n"
3631 " set the space between two words\n"
3632 " -kerning value set the space between two letters\n"
3633 " -label string assign a label to an image\n"
3634 " -limit type value pixel cache resource limit\n"
3635 " -loop iterations add Netscape loop extension to your GIF animation\n"
3636 " -matte store matte channel if the image has one\n"
3637 " -mattecolor color frame color\n"
3638 " -monitor monitor progress\n"
3639 " -orient type image orientation\n"
3640 " -page geometry size and location of an image canvas (setting)\n"
3641 " -path path write images to this path on disk\n"
3642 " -ping efficiently determine image attributes\n"
3643 " -pointsize value font point size\n"
3644 " -precision value maximum number of significant digits to print\n"
3645 " -preview type image preview type\n"
3646 " -quality value JPEG/MIFF/PNG compression level\n"
3647 " -quiet suppress all warning messages\n"
3648 " -read-mask filename associate a read mask with the image\n"
3649 " -red-primary point chromaticity red primary point\n"
3650 " -regard-warnings pay attention to warning messages\n"
3651 " -remap filename transform image colors to match this set of colors\n"
3652 " -respect-parentheses settings remain in effect until parenthesis boundary\n"
3653 " -sampling-factor geometry\n"
3654 " horizontal and vertical sampling factor\n"
3655 " -scene value image scene number\n"
3656 " -seed value seed a new sequence of pseudo-random numbers\n"
3657 " -size geometry width and height of image\n"
3658 " -stretch type render text with this font stretch\n"
3659 " -stroke color graphic primitive stroke color\n"
3660 " -strokewidth value graphic primitive stroke width\n"
3661 " -style type render text with this font style\n"
3662 " -synchronize synchronize image to storage device\n"
3663 " -taint declare the image as modified\n"
3664 " -texture filename name of texture to tile onto the image background\n"
3665 " -tile-offset geometry\n"
3666 " tile offset\n"
3667 " -treedepth value color tree depth\n"
3668 " -transparent-color color\n"
3669 " transparent color\n"
3670 " -undercolor color annotation bounding box color\n"
3671 " -units type the units of image resolution\n"
3672 " -verbose print detailed information about the image\n"
3673 " -view FlashPix viewing transforms\n"
3674 " -virtual-pixel method\n"
3675 " virtual pixel access method\n"
3676 " -weight type render text with this font weight\n"
3677 " -white-point point chromaticity white point\n"
3678 " -word-break type sets whether line breaks appear wherever the text would otherwise overflow"
3679 " -write-mask filename associate a write mask with the image",
3680 stack_operators[] =
3681 " -delete indexes delete the image from the image sequence\n"
3682 " -duplicate count,indexes\n"
3683 " duplicate an image one or more times\n"
3684 " -insert index insert last image into the image sequence\n"
3685 " -reverse reverse image sequence\n"
3686 " -swap indexes swap two images in the image sequence";
3687
3688 ListMagickVersion(stdout);
3689 (void) printf("Usage: %s [options ...] file [ [options ...] file ...]\n",
3690 GetClientName());
3691 (void) fprintf(stdout,"\nImage Settings:\n");
3692 (void) fputs(settings,stdout);
3693 (void) fprintf(stdout,"\nImage Operators:\n");
3694 (void) fputs(operators,stdout);
3695 (void) fprintf(stdout,"\nImage Channel Operators:\n");
3696 (void) fputs(channel_operators,stdout);
3697 (void) fprintf(stdout,"\nImage Sequence Operators:\n");
3698 (void) fputs(sequence_operators,stdout);
3699 (void) fprintf(stdout,"\nImage Stack Operators:\n");
3700 (void) fputs(stack_operators,stdout);
3701 (void) fprintf(stdout,"\nMiscellaneous Options:\n");
3702 (void) fputs(miscellaneous,stdout);
3703 (void) fprintf(stdout,
3704 "\nBy default, the image format of 'file' is determined by its magic\n");
3705 (void) fprintf(stdout,
3706 "number. To specify a particular image format, precede the filename\n");
3707 (void) fprintf(stdout,
3708 "with an image format name and a colon (i.e. ps:image) or specify the\n");
3709 (void) fprintf(stdout,
3710 "image type as the filename suffix (i.e. image.ps). Specify 'file' as\n");
3711 (void) fprintf(stdout,"'-' for standard input or output.\n");
3712 return(MagickTrue);
3713}
3714
3715WandExport MagickBooleanType MogrifyImageCommand(ImageInfo *image_info,
3716 int argc,char **argv,char **wand_unused(metadata),ExceptionInfo *exception)
3717{
3718#define DestroyMogrify() \
3719{ \
3720 if (format != (char *) NULL) \
3721 format=DestroyString(format); \
3722 if (path != (char *) NULL) \
3723 path=DestroyString(path); \
3724 DestroyImageStack(); \
3725 for (i=0; i < (ssize_t) argc; i++) \
3726 argv[i]=DestroyString(argv[i]); \
3727 argv=(char **) RelinquishMagickMemory(argv); \
3728}
3729#define ThrowMogrifyException(asperity,tag,option) \
3730{ \
3731 char *message = GetExceptionMessage(errno); \
3732 (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag, \
3733 "`%s'",option == (char *) NULL ? message : option); \
3734 message=DestroyString(message); \
3735 DestroyMogrify(); \
3736 return(MagickFalse); \
3737}
3738#define ThrowMogrifyInvalidArgumentException(option,argument) \
3739{ \
3740 (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
3741 "InvalidArgument","'%s': %s",argument,option); \
3742 DestroyMogrify(); \
3743 return(MagickFalse); \
3744}
3745
3746 char
3747 *format,
3748 *option,
3749 *path;
3750
3751 Image
3752 *image;
3753
3754 ImageStack
3755 image_stack[MaxImageStackDepth+1];
3756
3757 MagickBooleanType
3758 global_colormap;
3759
3760 MagickBooleanType
3761 fire,
3762 pend,
3763 respect_parentheses;
3764
3765 MagickStatusType
3766 status;
3767
3768 ssize_t
3769 i;
3770
3771 ssize_t
3772 j,
3773 k;
3774
3775 wand_unreferenced(metadata);
3776
3777 /*
3778 Set defaults.
3779 */
3780 assert(image_info != (ImageInfo *) NULL);
3781 assert(image_info->signature == MagickCoreSignature);
3782 if (IsEventLogging() != MagickFalse)
3783 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3784 assert(exception != (ExceptionInfo *) NULL);
3785 if (argc == 2)
3786 {
3787 option=argv[1];
3788 if ((LocaleCompare("version",option+1) == 0) ||
3789 (LocaleCompare("-version",option+1) == 0))
3790 {
3791 ListMagickVersion(stdout);
3792 return(MagickTrue);
3793 }
3794 }
3795 if (argc < 2)
3796 {
3797 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
3798 "MissingArgument","%s","");
3799 (void) MogrifyUsage();
3800 return(MagickFalse);
3801 }
3802 format=(char *) NULL;
3803 path=(char *) NULL;
3804 global_colormap=MagickFalse;
3805 k=0;
3806 j=1;
3807 NewImageStack();
3808 option=(char *) NULL;
3809 pend=MagickFalse;
3810 respect_parentheses=MagickFalse;
3811 status=MagickTrue;
3812 /*
3813 Parse command line.
3814 */
3815 ReadCommandlLine(argc,&argv);
3816 status=ExpandFilenames(&argc,&argv);
3817 if (status == MagickFalse)
3818 ThrowMogrifyException(ResourceLimitError,"MemoryAllocationFailed",
3819 (char *) NULL);
3820 for (i=1; i < (ssize_t) argc; i++)
3821 {
3822 option=argv[i];
3823 if (LocaleCompare(option,"(") == 0)
3824 {
3825 FireImageStack(MagickFalse,MagickTrue,pend);
3826 if (k == MaxImageStackDepth)
3827 ThrowMogrifyException(OptionError,"ParenthesisNestedTooDeeply",
3828 option);
3829 PushImageStack();
3830 continue;
3831 }
3832 if (LocaleCompare(option,")") == 0)
3833 {
3834 FireImageStack(MagickFalse,MagickTrue,MagickTrue);
3835 if (k == 0)
3836 ThrowMogrifyException(OptionError,"UnableToParseExpression",option);
3837 PopImageStack();
3838 continue;
3839 }
3840 if (IsCommandOption(option) == MagickFalse)
3841 {
3842 char
3843 backup_filename[MagickPathExtent],
3844 *filename,
3845 magic[MagickPathExtent];
3846
3847 Image
3848 *images;
3849
3850 struct stat
3851 properties;
3852
3853 /*
3854 Option is a file name: begin by reading image from specified file.
3855 */
3856 FireImageStack(MagickFalse,MagickFalse,pend);
3857 filename=argv[i];
3858 if ((LocaleCompare(filename,"--") == 0) && (i < ((ssize_t) argc-1)))
3859 filename=argv[++i];
3860 images=ReadImages(image_info,filename,exception);
3861 status&=(MagickStatusType) (images != (Image *) NULL) &&
3862 (exception->severity < ErrorException);
3863 if (images == (Image *) NULL)
3864 continue;
3865 properties=(*GetBlobProperties(images));
3866 if (format != (char *) NULL)
3867 GetPathComponent(images->magick_filename,
3868 BasePathSansCompressExtension,images->filename);
3869 if (path != (char *) NULL)
3870 {
3871 GetPathComponent(option,TailPath,filename);
3872 (void) FormatLocaleString(images->filename,MagickPathExtent,
3873 "%s%c%s",path,*DirectorySeparator,filename);
3874 }
3875 if (format != (char *) NULL)
3876 AppendImageFormat(format,images->filename);
3877 AppendImageStack(images);
3878 FinalizeImageSettings(image_info,image,MagickFalse);
3879 if (image == (Image *) NULL)
3880 continue;
3881 if (global_colormap != MagickFalse)
3882 {
3883 QuantizeInfo
3884 *quantize_info;
3885
3886 quantize_info=AcquireQuantizeInfo(image_info);
3887 (void) RemapImages(quantize_info,images,(Image *) NULL,exception);
3888 quantize_info=DestroyQuantizeInfo(quantize_info);
3889 }
3890 *backup_filename='\0';
3891 *magic='\0';
3892 GetPathComponent(filename,MagickPath,magic);
3893 if (*magic != '\0')
3894 {
3895 char
3896 name[MagickPathExtent];
3897
3898 if (format != (char *) NULL)
3899 (void) CopyMagickString(magic,format,MagickPathExtent);
3900 (void) FormatLocaleString(name,MagickPathExtent,"%s:%s",magic,
3901 image->filename);
3902 (void) CopyMagickString(image->filename,name,MagickPathExtent);
3903 }
3904 if ((LocaleCompare(image->filename,"-") != 0) &&
3905 (IsPathWritable(image->filename) != MagickFalse))
3906 {
3907 int
3908 file = -1;
3909
3910 RandomInfo
3911 *random_info;
3912
3913 /*
3914 Generate a temporary filename to write the new image to.
3915 */
3916 random_info=AcquireRandomInfo();
3917 (void) CopyMagickString(backup_filename,image->filename,
3918 MagickPathExtent);
3919 for (j=0; j < TMP_MAX; j++)
3920 {
3921 StringInfo
3922 *key_info;
3923
3924 unsigned char
3925 *key_bytes;
3926
3927 key_info=GetRandomKey(random_info,4);
3928 if (key_info == (StringInfo *) NULL)
3929 break;
3930 key_bytes=GetStringInfoDatum(key_info);
3931 (void) FormatLocaleString(backup_filename,MagickPathExtent,
3932 "%s-%02x%02x%02x%02x~",image->filename,key_bytes[0],
3933 key_bytes[1],key_bytes[2],key_bytes[3]);
3934 key_info=DestroyStringInfo(key_info);
3935 file=open_utf8(backup_filename,O_RDWR | O_CLOEXEC | O_CREAT | O_EXCL |
3936 O_BINARY | O_NOFOLLOW,S_MODE);
3937 if ((file >= 0) || (errno != EEXIST))
3938 break;
3939 }
3940 random_info=DestroyRandomInfo(random_info);
3941 if (file < 0)
3942 *backup_filename='\0';
3943 else
3944 file=close_utf8(file)-1;
3945 }
3946 /*
3947 Write transmogrified image to disk.
3948 */
3949 image_info->synchronize=MagickTrue;
3950 {
3951 Image *clone_image = CloneImageList(image,exception);
3952 if (clone_image != (Image *) NULL)
3953 {
3954 status&=(MagickStatusType) WriteImages(image_info,clone_image,
3955 (*backup_filename != '\0') ? backup_filename :
3956 clone_image->filename,exception);
3957 clone_image=DestroyImageList(clone_image);
3958 }
3959 }
3960 if (status != MagickFalse)
3961 {
3962 {
3963 MagickBooleanType
3964 preserve_timestamp;
3965
3966 preserve_timestamp=IsStringTrue(GetImageOption(image_info,
3967 "preserve-timestamp"));
3968 if (preserve_timestamp != MagickFalse)
3969 (void) set_file_timestamp(image->filename,&properties);
3970 }
3971 if (*backup_filename != '\0')
3972 {
3973 if (rename_utf8(backup_filename,image->filename) != 0)
3974 status=MagickFalse;
3975 }
3976 }
3977 else
3978 if (*backup_filename != '\0')
3979 (void) remove_utf8(backup_filename);
3980 RemoveAllImageStack();
3981 continue;
3982 }
3983 pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
3984 switch (*(option+1))
3985 {
3986 case 'a':
3987 {
3988 if (LocaleCompare("adaptive-blur",option+1) == 0)
3989 {
3990 i++;
3991 if (i == (ssize_t) argc)
3992 ThrowMogrifyException(OptionError,"MissingArgument",option);
3993 if (IsGeometry(argv[i]) == MagickFalse)
3994 ThrowMogrifyInvalidArgumentException(option,argv[i]);
3995 break;
3996 }
3997 if (LocaleCompare("adaptive-resize",option+1) == 0)
3998 {
3999 i++;
4000 if (i == (ssize_t) argc)
4001 ThrowMogrifyException(OptionError,"MissingArgument",option);
4002 if (IsGeometry(argv[i]) == MagickFalse)
4003 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4004 break;
4005 }
4006 if (LocaleCompare("adaptive-sharpen",option+1) == 0)
4007 {
4008 i++;
4009 if (i == (ssize_t) argc)
4010 ThrowMogrifyException(OptionError,"MissingArgument",option);
4011 if (IsGeometry(argv[i]) == MagickFalse)
4012 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4013 break;
4014 }
4015 if (LocaleCompare("affine",option+1) == 0)
4016 {
4017 if (*option == '+')
4018 break;
4019 i++;
4020 if (i == (ssize_t) argc)
4021 ThrowMogrifyException(OptionError,"MissingArgument",option);
4022 break;
4023 }
4024 if (LocaleCompare("alpha",option+1) == 0)
4025 {
4026 ssize_t
4027 type;
4028
4029 if (*option == '+')
4030 break;
4031 i++;
4032 if (i == (ssize_t) argc)
4033 ThrowMogrifyException(OptionError,"MissingArgument",option);
4034 type=ParseCommandOption(MagickAlphaChannelOptions,MagickFalse,
4035 argv[i]);
4036 if (type < 0)
4037 ThrowMogrifyException(OptionError,
4038 "UnrecognizedAlphaChannelOption",argv[i]);
4039 break;
4040 }
4041 if (LocaleCompare("annotate",option+1) == 0)
4042 {
4043 if (*option == '+')
4044 break;
4045 i++;
4046 if (i == (ssize_t) argc)
4047 ThrowMogrifyException(OptionError,"MissingArgument",option);
4048 if (IsGeometry(argv[i]) == MagickFalse)
4049 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4050 if (i == (ssize_t) argc)
4051 ThrowMogrifyException(OptionError,"MissingArgument",option);
4052 i++;
4053 break;
4054 }
4055 if (LocaleCompare("antialias",option+1) == 0)
4056 break;
4057 if (LocaleCompare("append",option+1) == 0)
4058 break;
4059 if (LocaleCompare("attenuate",option+1) == 0)
4060 {
4061 if (*option == '+')
4062 break;
4063 i++;
4064 if (i == (ssize_t) argc)
4065 ThrowMogrifyException(OptionError,"MissingArgument",option);
4066 if (IsGeometry(argv[i]) == MagickFalse)
4067 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4068 break;
4069 }
4070 if (LocaleCompare("authenticate",option+1) == 0)
4071 {
4072 if (*option == '+')
4073 break;
4074 i++;
4075 if (i == (ssize_t) argc)
4076 ThrowMogrifyException(OptionError,"MissingArgument",option);
4077 break;
4078 }
4079 if (LocaleCompare("auto-gamma",option+1) == 0)
4080 break;
4081 if (LocaleCompare("auto-level",option+1) == 0)
4082 break;
4083 if (LocaleCompare("auto-orient",option+1) == 0)
4084 break;
4085 if (LocaleCompare("auto-threshold",option+1) == 0)
4086 {
4087 ssize_t
4088 method;
4089
4090 if (*option == '+')
4091 break;
4092 i++;
4093 if (i == (ssize_t) argc)
4094 ThrowMogrifyException(OptionError,"MissingArgument",option);
4095 method=ParseCommandOption(MagickAutoThresholdOptions,MagickFalse,
4096 argv[i]);
4097 if (method < 0)
4098 ThrowMogrifyException(OptionError,"UnrecognizedThresholdMethod",
4099 argv[i]);
4100 break;
4101 }
4102 if (LocaleCompare("average",option+1) == 0)
4103 break;
4104 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4105 }
4106 case 'b':
4107 {
4108 if (LocaleCompare("background",option+1) == 0)
4109 {
4110 if (*option == '+')
4111 break;
4112 i++;
4113 if (i == (ssize_t) argc)
4114 ThrowMogrifyException(OptionError,"MissingArgument",option);
4115 break;
4116 }
4117 if (LocaleCompare("bias",option+1) == 0)
4118 {
4119 if (*option == '+')
4120 break;
4121 i++;
4122 if (i == (ssize_t) argc)
4123 ThrowMogrifyException(OptionError,"MissingArgument",option);
4124 if (IsGeometry(argv[i]) == MagickFalse)
4125 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4126 break;
4127 }
4128 if (LocaleCompare("bilateral-blur",option+1) == 0)
4129 {
4130 if (*option == '+')
4131 break;
4132 i++;
4133 if (i == (ssize_t) argc)
4134 ThrowMogrifyException(OptionError,"MissingArgument",option);
4135 if (IsGeometry(argv[i]) == MagickFalse)
4136 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4137 break;
4138 }
4139 if (LocaleCompare("black-point-compensation",option+1) == 0)
4140 break;
4141 if (LocaleCompare("black-threshold",option+1) == 0)
4142 {
4143 if (*option == '+')
4144 break;
4145 i++;
4146 if (i == (ssize_t) argc)
4147 ThrowMogrifyException(OptionError,"MissingArgument",option);
4148 if (IsGeometry(argv[i]) == MagickFalse)
4149 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4150 break;
4151 }
4152 if (LocaleCompare("blue-primary",option+1) == 0)
4153 {
4154 if (*option == '+')
4155 break;
4156 i++;
4157 if (i == (ssize_t) argc)
4158 ThrowMogrifyException(OptionError,"MissingArgument",option);
4159 if (IsGeometry(argv[i]) == MagickFalse)
4160 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4161 break;
4162 }
4163 if (LocaleCompare("blue-shift",option+1) == 0)
4164 {
4165 i++;
4166 if (i == (ssize_t) argc)
4167 ThrowMogrifyException(OptionError,"MissingArgument",option);
4168 if (IsGeometry(argv[i]) == MagickFalse)
4169 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4170 break;
4171 }
4172 if (LocaleCompare("blur",option+1) == 0)
4173 {
4174 i++;
4175 if (i == (ssize_t) argc)
4176 ThrowMogrifyException(OptionError,"MissingArgument",option);
4177 if (IsGeometry(argv[i]) == MagickFalse)
4178 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4179 break;
4180 }
4181 if (LocaleCompare("border",option+1) == 0)
4182 {
4183 if (*option == '+')
4184 break;
4185 i++;
4186 if (i == (ssize_t) argc)
4187 ThrowMogrifyException(OptionError,"MissingArgument",option);
4188 if (IsGeometry(argv[i]) == MagickFalse)
4189 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4190 break;
4191 }
4192 if (LocaleCompare("bordercolor",option+1) == 0)
4193 {
4194 if (*option == '+')
4195 break;
4196 i++;
4197 if (i == (ssize_t) argc)
4198 ThrowMogrifyException(OptionError,"MissingArgument",option);
4199 break;
4200 }
4201 if (LocaleCompare("box",option+1) == 0)
4202 {
4203 if (*option == '+')
4204 break;
4205 i++;
4206 if (i == (ssize_t) argc)
4207 ThrowMogrifyException(OptionError,"MissingArgument",option);
4208 break;
4209 }
4210 if (LocaleCompare("brightness-contrast",option+1) == 0)
4211 {
4212 i++;
4213 if (i == (ssize_t) argc)
4214 ThrowMogrifyException(OptionError,"MissingArgument",option);
4215 if (IsGeometry(argv[i]) == MagickFalse)
4216 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4217 break;
4218 }
4219 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4220 }
4221 case 'c':
4222 {
4223 if (LocaleCompare("cache",option+1) == 0)
4224 {
4225 if (*option == '+')
4226 break;
4227 i++;
4228 if (i == (ssize_t) argc)
4229 ThrowMogrifyException(OptionError,"MissingArgument",option);
4230 if (IsGeometry(argv[i]) == MagickFalse)
4231 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4232 break;
4233 }
4234 if (LocaleCompare("canny",option+1) == 0)
4235 {
4236 if (*option == '+')
4237 break;
4238 i++;
4239 if (i == (ssize_t) argc)
4240 ThrowMogrifyException(OptionError,"MissingArgument",option);
4241 if (IsGeometry(argv[i]) == MagickFalse)
4242 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4243 break;
4244 }
4245 if (LocaleCompare("caption",option+1) == 0)
4246 {
4247 if (*option == '+')
4248 break;
4249 i++;
4250 if (i == (ssize_t) argc)
4251 ThrowMogrifyException(OptionError,"MissingArgument",option);
4252 break;
4253 }
4254 if (LocaleCompare("channel",option+1) == 0)
4255 {
4256 ssize_t
4257 channel;
4258
4259 if (*option == '+')
4260 break;
4261 i++;
4262 if (i == (ssize_t) argc)
4263 ThrowMogrifyException(OptionError,"MissingArgument",option);
4264 channel=ParseChannelOption(argv[i]);
4265 if (channel < 0)
4266 ThrowMogrifyException(OptionError,"UnrecognizedChannelType",
4267 argv[i]);
4268 break;
4269 }
4270 if (LocaleCompare("channel-fx",option+1) == 0)
4271 {
4272 ssize_t
4273 channel;
4274
4275 if (*option == '+')
4276 break;
4277 i++;
4278 if (i == (ssize_t) argc)
4279 ThrowMogrifyException(OptionError,"MissingArgument",option);
4280 channel=ParsePixelChannelOption(argv[i]);
4281 if (channel < 0)
4282 ThrowMogrifyException(OptionError,"UnrecognizedChannelType",
4283 argv[i]);
4284 break;
4285 }
4286 if (LocaleCompare("cdl",option+1) == 0)
4287 {
4288 if (*option == '+')
4289 break;
4290 i++;
4291 if (i == (ssize_t) argc)
4292 ThrowMogrifyException(OptionError,"MissingArgument",option);
4293 break;
4294 }
4295 if (LocaleCompare("charcoal",option+1) == 0)
4296 {
4297 if (*option == '+')
4298 break;
4299 i++;
4300 if (i == (ssize_t) argc)
4301 ThrowMogrifyException(OptionError,"MissingArgument",option);
4302 if (IsGeometry(argv[i]) == MagickFalse)
4303 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4304 break;
4305 }
4306 if (LocaleCompare("chop",option+1) == 0)
4307 {
4308 if (*option == '+')
4309 break;
4310 i++;
4311 if (i == (ssize_t) argc)
4312 ThrowMogrifyException(OptionError,"MissingArgument",option);
4313 if (IsGeometry(argv[i]) == MagickFalse)
4314 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4315 break;
4316 }
4317 if (LocaleCompare("clahe",option+1) == 0)
4318 {
4319 if (*option == '+')
4320 break;
4321 i++;
4322 if (i == (ssize_t) argc)
4323 ThrowMogrifyException(OptionError,"MissingArgument",option);
4324 if (IsGeometry(argv[i]) == MagickFalse)
4325 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4326 break;
4327 }
4328 if (LocaleCompare("clamp",option+1) == 0)
4329 break;
4330 if (LocaleCompare("clip",option+1) == 0)
4331 break;
4332 if (LocaleCompare("clip-mask",option+1) == 0)
4333 {
4334 if (*option == '+')
4335 break;
4336 i++;
4337 if (i == (ssize_t) argc)
4338 ThrowMogrifyException(OptionError,"MissingArgument",option);
4339 break;
4340 }
4341 if (LocaleCompare("clut",option+1) == 0)
4342 break;
4343 if (LocaleCompare("coalesce",option+1) == 0)
4344 break;
4345 if (LocaleCompare("colorize",option+1) == 0)
4346 {
4347 if (*option == '+')
4348 break;
4349 i++;
4350 if (i == (ssize_t) argc)
4351 ThrowMogrifyException(OptionError,"MissingArgument",option);
4352 if (IsGeometry(argv[i]) == MagickFalse)
4353 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4354 break;
4355 }
4356 if (LocaleCompare("color-matrix",option+1) == 0)
4357 {
4358 KernelInfo
4359 *kernel_info;
4360
4361 if (*option == '+')
4362 break;
4363 i++;
4364 if (i == (ssize_t) argc)
4365 ThrowMogrifyException(OptionError,"MissingArgument",option);
4366 kernel_info=AcquireKernelInfo(argv[i],exception);
4367 if (kernel_info == (KernelInfo *) NULL)
4368 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4369 kernel_info=DestroyKernelInfo(kernel_info);
4370 break;
4371 }
4372 if (LocaleCompare("colors",option+1) == 0)
4373 {
4374 if (*option == '+')
4375 break;
4376 i++;
4377 if (i == (ssize_t) argc)
4378 ThrowMogrifyException(OptionError,"MissingArgument",option);
4379 if (IsGeometry(argv[i]) == MagickFalse)
4380 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4381 break;
4382 }
4383 if (LocaleCompare("colorspace",option+1) == 0)
4384 {
4385 ssize_t
4386 colorspace;
4387
4388 if (*option == '+')
4389 break;
4390 i++;
4391 if (i == (ssize_t) argc)
4392 ThrowMogrifyException(OptionError,"MissingArgument",option);
4393 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
4394 argv[i]);
4395 if (colorspace < 0)
4396 ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
4397 argv[i]);
4398 break;
4399 }
4400 if (LocaleCompare("color-threshold",option+1) == 0)
4401 {
4402 if (*option == '+')
4403 break;
4404 i++;
4405 if (i == (ssize_t) argc)
4406 ThrowMogrifyException(OptionError,"MissingArgument",option);
4407 break;
4408 }
4409 if (LocaleCompare("combine",option+1) == 0)
4410 {
4411 ssize_t
4412 colorspace;
4413
4414 if (*option == '+')
4415 break;
4416 i++;
4417 if (i == (ssize_t) argc)
4418 ThrowMogrifyException(OptionError,"MissingArgument",option);
4419 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
4420 argv[i]);
4421 if (colorspace < 0)
4422 ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
4423 argv[i]);
4424 break;
4425 }
4426 if (LocaleCompare("comment",option+1) == 0)
4427 {
4428 if (*option == '+')
4429 break;
4430 i++;
4431 if (i == (ssize_t) argc)
4432 ThrowMogrifyException(OptionError,"MissingArgument",option);
4433 break;
4434 }
4435 if (LocaleCompare("compare",option+1) == 0)
4436 break;
4437 if (LocaleCompare("compose",option+1) == 0)
4438 {
4439 ssize_t
4440 compose;
4441
4442 if (*option == '+')
4443 break;
4444 i++;
4445 if (i == (ssize_t) argc)
4446 ThrowMogrifyException(OptionError,"MissingArgument",option);
4447 compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
4448 argv[i]);
4449 if (compose < 0)
4450 ThrowMogrifyException(OptionError,"UnrecognizedComposeOperator",
4451 argv[i]);
4452 break;
4453 }
4454 if (LocaleCompare("composite",option+1) == 0)
4455 break;
4456 if (LocaleCompare("compress",option+1) == 0)
4457 {
4458 ssize_t
4459 compress;
4460
4461 if (*option == '+')
4462 break;
4463 i++;
4464 if (i == (ssize_t) argc)
4465 ThrowMogrifyException(OptionError,"MissingArgument",option);
4466 compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
4467 argv[i]);
4468 if (compress < 0)
4469 ThrowMogrifyException(OptionError,"UnrecognizedImageCompression",
4470 argv[i]);
4471 break;
4472 }
4473 if (LocaleCompare("concurrent",option+1) == 0)
4474 break;
4475 if (LocaleCompare("connected-components",option+1) == 0)
4476 {
4477 i++;
4478 if (i == (ssize_t) argc)
4479 ThrowMogrifyException(OptionError,"MissingArgument",option);
4480 if (IsGeometry(argv[i]) == MagickFalse)
4481 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4482 break;
4483 }
4484 if (LocaleCompare("contrast",option+1) == 0)
4485 break;
4486 if (LocaleCompare("contrast-stretch",option+1) == 0)
4487 {
4488 i++;
4489 if (i == (ssize_t) argc)
4490 ThrowMogrifyException(OptionError,"MissingArgument",option);
4491 if (IsGeometry(argv[i]) == MagickFalse)
4492 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4493 break;
4494 }
4495 if (LocaleCompare("convolve",option+1) == 0)
4496 {
4497 KernelInfo
4498 *kernel_info;
4499
4500 if (*option == '+')
4501 break;
4502 i++;
4503 if (i == (ssize_t) argc)
4504 ThrowMogrifyException(OptionError,"MissingArgument",option);
4505 kernel_info=AcquireKernelInfo(argv[i],exception);
4506 if (kernel_info == (KernelInfo *) NULL)
4507 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4508 kernel_info=DestroyKernelInfo(kernel_info);
4509 break;
4510 }
4511 if (LocaleCompare("copy",option+1) == 0)
4512 {
4513 if (*option == '+')
4514 break;
4515 i++;
4516 if (i == (ssize_t) argc)
4517 ThrowMogrifyException(OptionError,"MissingArgument",option);
4518 if (IsGeometry(argv[i]) == MagickFalse)
4519 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4520 i++;
4521 if (i == (ssize_t) argc)
4522 ThrowMogrifyException(OptionError,"MissingArgument",option);
4523 if (IsGeometry(argv[i]) == MagickFalse)
4524 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4525 break;
4526 }
4527 if (LocaleCompare("crop",option+1) == 0)
4528 {
4529 if (*option == '+')
4530 break;
4531 i++;
4532 if (i == (ssize_t) argc)
4533 ThrowMogrifyException(OptionError,"MissingArgument",option);
4534 if (IsGeometry(argv[i]) == MagickFalse)
4535 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4536 break;
4537 }
4538 if (LocaleCompare("cycle",option+1) == 0)
4539 {
4540 if (*option == '+')
4541 break;
4542 i++;
4543 if (i == (ssize_t) argc)
4544 ThrowMogrifyException(OptionError,"MissingArgument",option);
4545 if (IsGeometry(argv[i]) == MagickFalse)
4546 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4547 break;
4548 }
4549 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4550 }
4551 case 'd':
4552 {
4553 if (LocaleCompare("decipher",option+1) == 0)
4554 {
4555 if (*option == '+')
4556 break;
4557 i++;
4558 if (i == (ssize_t) argc)
4559 ThrowMogrifyException(OptionError,"MissingArgument",option);
4560 break;
4561 }
4562 if (LocaleCompare("deconstruct",option+1) == 0)
4563 break;
4564 if (LocaleCompare("debug",option+1) == 0)
4565 {
4566 ssize_t
4567 event;
4568
4569 if (*option == '+')
4570 break;
4571 i++;
4572 if (i == (ssize_t) argc)
4573 ThrowMogrifyException(OptionError,"MissingArgument",option);
4574 event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
4575 if (event < 0)
4576 ThrowMogrifyException(OptionError,"UnrecognizedEventType",
4577 argv[i]);
4578 (void) SetLogEventMask(argv[i]);
4579 break;
4580 }
4581 if (LocaleCompare("define",option+1) == 0)
4582 {
4583 i++;
4584 if (i == (ssize_t) argc)
4585 ThrowMogrifyException(OptionError,"MissingArgument",option);
4586 if (*option == '+')
4587 {
4588 const char
4589 *define;
4590
4591 define=GetImageOption(image_info,argv[i]);
4592 if (define == (const char *) NULL)
4593 ThrowMogrifyException(OptionError,"NoSuchOption",argv[i]);
4594 break;
4595 }
4596 break;
4597 }
4598 if (LocaleCompare("delay",option+1) == 0)
4599 {
4600 if (*option == '+')
4601 break;
4602 i++;
4603 if (i == (ssize_t) argc)
4604 ThrowMogrifyException(OptionError,"MissingArgument",option);
4605 if (IsGeometry(argv[i]) == MagickFalse)
4606 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4607 break;
4608 }
4609 if (LocaleCompare("delete",option+1) == 0)
4610 {
4611 if (*option == '+')
4612 break;
4613 i++;
4614 if (i == (ssize_t) argc)
4615 ThrowMogrifyException(OptionError,"MissingArgument",option);
4616 if (LocaleNCompare(argv[i],"registry:",9) == 0)
4617 {
4618 (void) DeleteImageRegistry(argv[i]+9);
4619 break;
4620 }
4621 if (IsGeometry(argv[i]) == MagickFalse)
4622 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4623 break;
4624 }
4625 if (LocaleCompare("density",option+1) == 0)
4626 {
4627 if (*option == '+')
4628 break;
4629 i++;
4630 if (i == (ssize_t) argc)
4631 ThrowMogrifyException(OptionError,"MissingArgument",option);
4632 if (IsGeometry(argv[i]) == MagickFalse)
4633 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4634 break;
4635 }
4636 if (LocaleCompare("depth",option+1) == 0)
4637 {
4638 if (*option == '+')
4639 break;
4640 i++;
4641 if (i == (ssize_t) argc)
4642 ThrowMogrifyException(OptionError,"MissingArgument",option);
4643 if (IsGeometry(argv[i]) == MagickFalse)
4644 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4645 break;
4646 }
4647 if (LocaleCompare("deskew",option+1) == 0)
4648 {
4649 if (*option == '+')
4650 break;
4651 i++;
4652 if (i == (ssize_t) argc)
4653 ThrowMogrifyException(OptionError,"MissingArgument",option);
4654 if (IsGeometry(argv[i]) == MagickFalse)
4655 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4656 break;
4657 }
4658 if (LocaleCompare("despeckle",option+1) == 0)
4659 break;
4660 if (LocaleCompare("dft",option+1) == 0)
4661 break;
4662 if (LocaleCompare("direction",option+1) == 0)
4663 {
4664 ssize_t
4665 direction;
4666
4667 if (*option == '+')
4668 break;
4669 i++;
4670 if (i == (ssize_t) argc)
4671 ThrowMogrifyException(OptionError,"MissingArgument",option);
4672 direction=ParseCommandOption(MagickDirectionOptions,MagickFalse,
4673 argv[i]);
4674 if (direction < 0)
4675 ThrowMogrifyException(OptionError,"UnrecognizedDirectionType",
4676 argv[i]);
4677 break;
4678 }
4679 if (LocaleCompare("display",option+1) == 0)
4680 {
4681 if (*option == '+')
4682 break;
4683 i++;
4684 if (i == (ssize_t) argc)
4685 ThrowMogrifyException(OptionError,"MissingArgument",option);
4686 break;
4687 }
4688 if (LocaleCompare("dispose",option+1) == 0)
4689 {
4690 ssize_t
4691 dispose;
4692
4693 if (*option == '+')
4694 break;
4695 i++;
4696 if (i == (ssize_t) argc)
4697 ThrowMogrifyException(OptionError,"MissingArgument",option);
4698 dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,
4699 argv[i]);
4700 if (dispose < 0)
4701 ThrowMogrifyException(OptionError,"UnrecognizedDisposeMethod",
4702 argv[i]);
4703 break;
4704 }
4705 if (LocaleCompare("distort",option+1) == 0)
4706 {
4707 ssize_t
4708 op;
4709
4710 i++;
4711 if (i == (ssize_t) argc)
4712 ThrowMogrifyException(OptionError,"MissingArgument",option);
4713 op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
4714 if (op < 0)
4715 ThrowMogrifyException(OptionError,"UnrecognizedDistortMethod",
4716 argv[i]);
4717 i++;
4718 if (i == (ssize_t) argc)
4719 ThrowMogrifyException(OptionError,"MissingArgument",option);
4720 break;
4721 }
4722 if (LocaleCompare("dither",option+1) == 0)
4723 {
4724 ssize_t
4725 method;
4726
4727 if (*option == '+')
4728 break;
4729 i++;
4730 if (i == (ssize_t) argc)
4731 ThrowMogrifyException(OptionError,"MissingArgument",option);
4732 method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]);
4733 if (method < 0)
4734 ThrowMogrifyException(OptionError,"UnrecognizedDitherMethod",
4735 argv[i]);
4736 break;
4737 }
4738 if (LocaleCompare("draw",option+1) == 0)
4739 {
4740 if (*option == '+')
4741 break;
4742 i++;
4743 if (i == (ssize_t) argc)
4744 ThrowMogrifyException(OptionError,"MissingArgument",option);
4745 break;
4746 }
4747 if (LocaleCompare("duplicate",option+1) == 0)
4748 {
4749 if (*option == '+')
4750 break;
4751 i++;
4752 if (i == (ssize_t) argc)
4753 ThrowMogrifyException(OptionError,"MissingArgument",option);
4754 if (IsGeometry(argv[i]) == MagickFalse)
4755 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4756 break;
4757 }
4758 if (LocaleCompare("duration",option+1) == 0)
4759 {
4760 if (*option == '+')
4761 break;
4762 i++;
4763 if (i == (ssize_t) argc)
4764 ThrowMogrifyException(OptionError,"MissingArgument",option);
4765 if (IsGeometry(argv[i]) == MagickFalse)
4766 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4767 break;
4768 }
4769 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4770 }
4771 case 'e':
4772 {
4773 if (LocaleCompare("edge",option+1) == 0)
4774 {
4775 if (*option == '+')
4776 break;
4777 i++;
4778 if (i == (ssize_t) argc)
4779 ThrowMogrifyException(OptionError,"MissingArgument",option);
4780 if (IsGeometry(argv[i]) == MagickFalse)
4781 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4782 break;
4783 }
4784 if (LocaleCompare("emboss",option+1) == 0)
4785 {
4786 if (*option == '+')
4787 break;
4788 i++;
4789 if (i == (ssize_t) argc)
4790 ThrowMogrifyException(OptionError,"MissingArgument",option);
4791 if (IsGeometry(argv[i]) == MagickFalse)
4792 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4793 break;
4794 }
4795 if (LocaleCompare("encipher",option+1) == 0)
4796 {
4797 if (*option == '+')
4798 break;
4799 i++;
4800 if (i == (ssize_t) argc)
4801 ThrowMogrifyException(OptionError,"MissingArgument",option);
4802 break;
4803 }
4804 if (LocaleCompare("encoding",option+1) == 0)
4805 {
4806 if (*option == '+')
4807 break;
4808 i++;
4809 if (i == (ssize_t) argc)
4810 ThrowMogrifyException(OptionError,"MissingArgument",option);
4811 break;
4812 }
4813 if (LocaleCompare("endian",option+1) == 0)
4814 {
4815 ssize_t
4816 endian;
4817
4818 if (*option == '+')
4819 break;
4820 i++;
4821 if (i == (ssize_t) argc)
4822 ThrowMogrifyException(OptionError,"MissingArgument",option);
4823 endian=ParseCommandOption(MagickEndianOptions,MagickFalse,argv[i]);
4824 if (endian < 0)
4825 ThrowMogrifyException(OptionError,"UnrecognizedEndianType",
4826 argv[i]);
4827 break;
4828 }
4829 if (LocaleCompare("enhance",option+1) == 0)
4830 break;
4831 if (LocaleCompare("equalize",option+1) == 0)
4832 break;
4833 if (LocaleCompare("evaluate",option+1) == 0)
4834 {
4835 ssize_t
4836 op;
4837
4838 if (*option == '+')
4839 break;
4840 i++;
4841 if (i == (ssize_t) argc)
4842 ThrowMogrifyException(OptionError,"MissingArgument",option);
4843 op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
4844 if (op < 0)
4845 ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator",
4846 argv[i]);
4847 i++;
4848 if (i == (ssize_t) argc)
4849 ThrowMogrifyException(OptionError,"MissingArgument",option);
4850 if (IsGeometry(argv[i]) == MagickFalse)
4851 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4852 break;
4853 }
4854 if (LocaleCompare("evaluate-sequence",option+1) == 0)
4855 {
4856 ssize_t
4857 op;
4858
4859 if (*option == '+')
4860 break;
4861 i++;
4862 if (i == (ssize_t) argc)
4863 ThrowMogrifyException(OptionError,"MissingArgument",option);
4864 op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
4865 if (op < 0)
4866 ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator",
4867 argv[i]);
4868 break;
4869 }
4870 if (LocaleCompare("extent",option+1) == 0)
4871 {
4872 if (*option == '+')
4873 break;
4874 i++;
4875 if (i == (ssize_t) argc)
4876 ThrowMogrifyException(OptionError,"MissingArgument",option);
4877 if (IsGeometry(argv[i]) == MagickFalse)
4878 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4879 break;
4880 }
4881 if (LocaleCompare("extract",option+1) == 0)
4882 {
4883 if (*option == '+')
4884 break;
4885 i++;
4886 if (i == (ssize_t) argc)
4887 ThrowMogrifyException(OptionError,"MissingArgument",option);
4888 if (IsGeometry(argv[i]) == MagickFalse)
4889 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4890 break;
4891 }
4892 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4893 }
4894 case 'f':
4895 {
4896 if (LocaleCompare("family",option+1) == 0)
4897 {
4898 if (*option == '+')
4899 break;
4900 i++;
4901 if (i == (ssize_t) argc)
4902 ThrowMogrifyException(OptionError,"MissingArgument",option);
4903 break;
4904 }
4905 if (LocaleCompare("features",option+1) == 0)
4906 {
4907 if (*option == '+')
4908 break;
4909 i++;
4910 if (i == (ssize_t) argc)
4911 ThrowMogrifyException(OptionError,"MissingArgument",option);
4912 if (IsGeometry(argv[i]) == MagickFalse)
4913 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4914 break;
4915 }
4916 if (LocaleCompare("fill",option+1) == 0)
4917 {
4918 if (*option == '+')
4919 break;
4920 i++;
4921 if (i == (ssize_t) argc)
4922 ThrowMogrifyException(OptionError,"MissingArgument",option);
4923 break;
4924 }
4925 if (LocaleCompare("filter",option+1) == 0)
4926 {
4927 ssize_t
4928 filter;
4929
4930 if (*option == '+')
4931 break;
4932 i++;
4933 if (i == (ssize_t) argc)
4934 ThrowMogrifyException(OptionError,"MissingArgument",option);
4935 filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]);
4936 if (filter < 0)
4937 ThrowMogrifyException(OptionError,"UnrecognizedImageFilter",
4938 argv[i]);
4939 break;
4940 }
4941 if (LocaleCompare("flatten",option+1) == 0)
4942 break;
4943 if (LocaleCompare("flip",option+1) == 0)
4944 break;
4945 if (LocaleCompare("flop",option+1) == 0)
4946 break;
4947 if (LocaleCompare("floodfill",option+1) == 0)
4948 {
4949 if (*option == '+')
4950 break;
4951 i++;
4952 if (i == (ssize_t) argc)
4953 ThrowMogrifyException(OptionError,"MissingArgument",option);
4954 if (IsGeometry(argv[i]) == MagickFalse)
4955 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4956 i++;
4957 if (i == (ssize_t) argc)
4958 ThrowMogrifyException(OptionError,"MissingArgument",option);
4959 break;
4960 }
4961 if (LocaleCompare("font",option+1) == 0)
4962 {
4963 if (*option == '+')
4964 break;
4965 i++;
4966 if (i == (ssize_t) argc)
4967 ThrowMogrifyException(OptionError,"MissingArgument",option);
4968 break;
4969 }
4970 if (LocaleCompare("format",option+1) == 0)
4971 {
4972 (void) CopyMagickString(argv[i]+1,"sans",MagickPathExtent);
4973 (void) CloneString(&format,(char *) NULL);
4974 if (*option == '+')
4975 break;
4976 i++;
4977 if (i == (ssize_t) argc)
4978 ThrowMogrifyException(OptionError,"MissingArgument",option);
4979 (void) CloneString(&format,argv[i]);
4980 (void) CopyMagickString(image_info->filename,format,
4981 MagickPathExtent);
4982 (void) ConcatenateMagickString(image_info->filename,":",
4983 MagickPathExtent);
4984 (void) SetImageInfo(image_info,0,exception);
4985 if (*image_info->magick == '\0')
4986 ThrowMogrifyException(OptionError,"UnrecognizedImageFormat",
4987 format);
4988 break;
4989 }
4990 if (LocaleCompare("frame",option+1) == 0)
4991 {
4992 if (*option == '+')
4993 break;
4994 i++;
4995 if (i == (ssize_t) argc)
4996 ThrowMogrifyException(OptionError,"MissingArgument",option);
4997 if (IsGeometry(argv[i]) == MagickFalse)
4998 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4999 break;
5000 }
5001 if (LocaleCompare("function",option+1) == 0)
5002 {
5003 ssize_t
5004 op;
5005
5006 if (*option == '+')
5007 break;
5008 i++;
5009 if (i == (ssize_t) argc)
5010 ThrowMogrifyException(OptionError,"MissingArgument",option);
5011 op=ParseCommandOption(MagickFunctionOptions,MagickFalse,argv[i]);
5012 if (op < 0)
5013 ThrowMogrifyException(OptionError,"UnrecognizedFunction",argv[i]);
5014 i++;
5015 if (i == (ssize_t) argc)
5016 ThrowMogrifyException(OptionError,"MissingArgument",option);
5017 break;
5018 }
5019 if (LocaleCompare("fuzz",option+1) == 0)
5020 {
5021 if (*option == '+')
5022 break;
5023 i++;
5024 if (i == (ssize_t) argc)
5025 ThrowMogrifyException(OptionError,"MissingArgument",option);
5026 if (IsGeometry(argv[i]) == MagickFalse)
5027 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5028 break;
5029 }
5030 if (LocaleCompare("fx",option+1) == 0)
5031 {
5032 i++;
5033 if (i == (ssize_t) argc)
5034 ThrowMogrifyException(OptionError,"MissingArgument",option);
5035 break;
5036 }
5037 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5038 }
5039 case 'g':
5040 {
5041 if (LocaleCompare("gamma",option+1) == 0)
5042 {
5043 i++;
5044 if (i == (ssize_t) argc)
5045 ThrowMogrifyException(OptionError,"MissingArgument",option);
5046 if (IsGeometry(argv[i]) == MagickFalse)
5047 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5048 break;
5049 }
5050 if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
5051 (LocaleCompare("gaussian",option+1) == 0))
5052 {
5053 i++;
5054 if (i == (ssize_t) argc)
5055 ThrowMogrifyException(OptionError,"MissingArgument",option);
5056 if (IsGeometry(argv[i]) == MagickFalse)
5057 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5058 break;
5059 }
5060 if (LocaleCompare("geometry",option+1) == 0)
5061 {
5062 if (*option == '+')
5063 break;
5064 i++;
5065 if (i == (ssize_t) argc)
5066 ThrowMogrifyException(OptionError,"MissingArgument",option);
5067 if (IsGeometry(argv[i]) == MagickFalse)
5068 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5069 break;
5070 }
5071 if (LocaleCompare("gravity",option+1) == 0)
5072 {
5073 ssize_t
5074 gravity;
5075
5076 if (*option == '+')
5077 break;
5078 i++;
5079 if (i == (ssize_t) argc)
5080 ThrowMogrifyException(OptionError,"MissingArgument",option);
5081 gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
5082 argv[i]);
5083 if (gravity < 0)
5084 ThrowMogrifyException(OptionError,"UnrecognizedGravityType",
5085 argv[i]);
5086 break;
5087 }
5088 if (LocaleCompare("grayscale",option+1) == 0)
5089 {
5090 ssize_t
5091 method;
5092
5093 if (*option == '+')
5094 break;
5095 i++;
5096 if (i == (ssize_t) argc)
5097 ThrowMogrifyException(OptionError,"MissingArgument",option);
5098 method=ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,
5099 argv[i]);
5100 if (method < 0)
5101 ThrowMogrifyException(OptionError,"UnrecognizedIntensityMethod",
5102 argv[i]);
5103 break;
5104 }
5105 if (LocaleCompare("green-primary",option+1) == 0)
5106 {
5107 if (*option == '+')
5108 break;
5109 i++;
5110 if (i == (ssize_t) argc)
5111 ThrowMogrifyException(OptionError,"MissingArgument",option);
5112 if (IsGeometry(argv[i]) == MagickFalse)
5113 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5114 break;
5115 }
5116 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5117 }
5118 case 'h':
5119 {
5120 if (LocaleCompare("hald-clut",option+1) == 0)
5121 break;
5122 if ((LocaleCompare("help",option+1) == 0) ||
5123 (LocaleCompare("-help",option+1) == 0))
5124 {
5125 DestroyMogrify();
5126 return(MogrifyUsage());
5127 }
5128 if (LocaleCompare("hough-lines",option+1) == 0)
5129 {
5130 if (*option == '+')
5131 break;
5132 i++;
5133 if (i == (ssize_t) argc)
5134 ThrowMogrifyException(OptionError,"MissingArgument",option);
5135 if (IsGeometry(argv[i]) == MagickFalse)
5136 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5137 break;
5138 }
5139 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5140 }
5141 case 'i':
5142 {
5143 if (LocaleCompare("identify",option+1) == 0)
5144 break;
5145 if (LocaleCompare("idft",option+1) == 0)
5146 break;
5147 if (LocaleCompare("illuminant",option+1) == 0)
5148 {
5149 ssize_t
5150 type;
5151
5152 if (*option == '+')
5153 break;
5154 i++;
5155 if (i == (ssize_t) argc)
5156 ThrowMogrifyException(OptionError,"MissingArgument",option);
5157 type=ParseCommandOption(MagickIlluminantOptions,MagickFalse,
5158 argv[i]);
5159 if (type < 0)
5160 ThrowMogrifyException(OptionError,"UnrecognizedIlluminantMethod",
5161 argv[i]);
5162 break;
5163 }
5164 if (LocaleCompare("implode",option+1) == 0)
5165 {
5166 if (*option == '+')
5167 break;
5168 i++;
5169 if (i == (ssize_t) argc)
5170 ThrowMogrifyException(OptionError,"MissingArgument",option);
5171 if (IsGeometry(argv[i]) == MagickFalse)
5172 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5173 break;
5174 }
5175 if (LocaleCompare("intensity",option+1) == 0)
5176 {
5177 ssize_t
5178 intensity;
5179
5180 if (*option == '+')
5181 break;
5182 i++;
5183 if (i == (ssize_t) argc)
5184 ThrowMogrifyException(OptionError,"MissingArgument",option);
5185 intensity=ParseCommandOption(MagickPixelIntensityOptions,
5186 MagickFalse,argv[i]);
5187 if (intensity < 0)
5188 ThrowMogrifyException(OptionError,
5189 "UnrecognizedPixelIntensityMethod",argv[i]);
5190 break;
5191 }
5192 if (LocaleCompare("integral",option+1) == 0)
5193 break;
5194 if (LocaleCompare("intent",option+1) == 0)
5195 {
5196 ssize_t
5197 intent;
5198
5199 if (*option == '+')
5200 break;
5201 i++;
5202 if (i == (ssize_t) argc)
5203 ThrowMogrifyException(OptionError,"MissingArgument",option);
5204 intent=ParseCommandOption(MagickIntentOptions,MagickFalse,argv[i]);
5205 if (intent < 0)
5206 ThrowMogrifyException(OptionError,"UnrecognizedIntentType",
5207 argv[i]);
5208 break;
5209 }
5210 if (LocaleCompare("interlace",option+1) == 0)
5211 {
5212 ssize_t
5213 interlace;
5214
5215 if (*option == '+')
5216 break;
5217 i++;
5218 if (i == (ssize_t) argc)
5219 ThrowMogrifyException(OptionError,"MissingArgument",option);
5220 interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
5221 argv[i]);
5222 if (interlace < 0)
5223 ThrowMogrifyException(OptionError,"UnrecognizedInterlaceType",
5224 argv[i]);
5225 break;
5226 }
5227 if (LocaleCompare("interline-spacing",option+1) == 0)
5228 {
5229 if (*option == '+')
5230 break;
5231 i++;
5232 if (i == (ssize_t) argc)
5233 ThrowMogrifyException(OptionError,"MissingArgument",option);
5234 if (IsGeometry(argv[i]) == MagickFalse)
5235 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5236 break;
5237 }
5238 if (LocaleCompare("interpolate",option+1) == 0)
5239 {
5240 ssize_t
5241 interpolate;
5242
5243 if (*option == '+')
5244 break;
5245 i++;
5246 if (i == (ssize_t) argc)
5247 ThrowMogrifyException(OptionError,"MissingArgument",option);
5248 interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
5249 argv[i]);
5250 if (interpolate < 0)
5251 ThrowMogrifyException(OptionError,"UnrecognizedInterpolateMethod",
5252 argv[i]);
5253 break;
5254 }
5255 if (LocaleCompare("interword-spacing",option+1) == 0)
5256 {
5257 if (*option == '+')
5258 break;
5259 i++;
5260 if (i == (ssize_t) argc)
5261 ThrowMogrifyException(OptionError,"MissingArgument",option);
5262 if (IsGeometry(argv[i]) == MagickFalse)
5263 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5264 break;
5265 }
5266 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5267 }
5268 case 'k':
5269 {
5270 if (LocaleCompare("kerning",option+1) == 0)
5271 {
5272 if (*option == '+')
5273 break;
5274 i++;
5275 if (i == (ssize_t) argc)
5276 ThrowMogrifyException(OptionError,"MissingArgument",option);
5277 if (IsGeometry(argv[i]) == MagickFalse)
5278 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5279 break;
5280 }
5281 if (LocaleCompare("kmeans",option+1) == 0)
5282 {
5283 i++;
5284 if (i == (ssize_t) argc)
5285 ThrowMogrifyException(OptionError,"MissingArgument",option);
5286 if (IsGeometry(argv[i]) == MagickFalse)
5287 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5288 break;
5289 }
5290 if (LocaleCompare("kuwahara",option+1) == 0)
5291 {
5292 i++;
5293 if (i == (ssize_t) argc)
5294 ThrowMogrifyException(OptionError,"MissingArgument",option);
5295 if (IsGeometry(argv[i]) == MagickFalse)
5296 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5297 break;
5298 }
5299 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5300 }
5301 case 'l':
5302 {
5303 if (LocaleCompare("label",option+1) == 0)
5304 {
5305 if (*option == '+')
5306 break;
5307 i++;
5308 if (i == (ssize_t) argc)
5309 ThrowMogrifyException(OptionError,"MissingArgument",option);
5310 break;
5311 }
5312 if (LocaleCompare("lat",option+1) == 0)
5313 {
5314 if (*option == '+')
5315 break;
5316 i++;
5317 if (i == (ssize_t) argc)
5318 ThrowMogrifyException(OptionError,"MissingArgument",option);
5319 if (IsGeometry(argv[i]) == MagickFalse)
5320 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5321 break;
5322 }
5323 if (LocaleCompare("layers",option+1) == 0)
5324 {
5325 ssize_t
5326 type;
5327
5328 if (*option == '+')
5329 break;
5330 i++;
5331 if (i == (ssize_t) argc)
5332 ThrowMogrifyException(OptionError,"MissingArgument",option);
5333 type=ParseCommandOption(MagickLayerOptions,MagickFalse,argv[i]);
5334 if (type < 0)
5335 ThrowMogrifyException(OptionError,"UnrecognizedLayerMethod",
5336 argv[i]);
5337 break;
5338 }
5339 if (LocaleCompare("level",option+1) == 0)
5340 {
5341 i++;
5342 if (i == (ssize_t) argc)
5343 ThrowMogrifyException(OptionError,"MissingArgument",option);
5344 if (IsGeometry(argv[i]) == MagickFalse)
5345 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5346 break;
5347 }
5348 if (LocaleCompare("level-colors",option+1) == 0)
5349 {
5350 i++;
5351 if (i == (ssize_t) argc)
5352 ThrowMogrifyException(OptionError,"MissingArgument",option);
5353 break;
5354 }
5355 if (LocaleCompare("limit",option+1) == 0)
5356 {
5357 char
5358 *p;
5359
5360 double
5361 value;
5362
5363 ssize_t
5364 resource;
5365
5366 if (*option == '+')
5367 break;
5368 i++;
5369 if (i == (ssize_t) argc)
5370 ThrowMogrifyException(OptionError,"MissingArgument",option);
5371 resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
5372 argv[i]);
5373 if (resource < 0)
5374 ThrowMogrifyException(OptionError,"UnrecognizedResourceType",
5375 argv[i]);
5376 i++;
5377 if (i == (ssize_t) argc)
5378 ThrowMogrifyException(OptionError,"MissingArgument",option);
5379 value=StringToDouble(argv[i],&p);
5380 (void) value;
5381 if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
5382 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5383 break;
5384 }
5385 if (LocaleCompare("liquid-rescale",option+1) == 0)
5386 {
5387 i++;
5388 if (i == (ssize_t) argc)
5389 ThrowMogrifyException(OptionError,"MissingArgument",option);
5390 if (IsGeometry(argv[i]) == MagickFalse)
5391 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5392 break;
5393 }
5394 if (LocaleCompare("list",option+1) == 0)
5395 {
5396 ssize_t
5397 list;
5398
5399 if (*option == '+')
5400 break;
5401 i++;
5402 if (i == (ssize_t) argc)
5403 ThrowMogrifyException(OptionError,"MissingArgument",option);
5404 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
5405 if (list < 0)
5406 ThrowMogrifyException(OptionError,"UnrecognizedListType",argv[i]);
5407 status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
5408 argv+j,exception);
5409 return(status == 0 ? MagickFalse : MagickTrue);
5410 }
5411 if (LocaleCompare("log",option+1) == 0)
5412 {
5413 if (*option == '+')
5414 break;
5415 i++;
5416 if ((i == (ssize_t) argc) ||
5417 (strchr(argv[i],'%') == (char *) NULL))
5418 ThrowMogrifyException(OptionError,"MissingArgument",option);
5419 break;
5420 }
5421 if (LocaleCompare("loop",option+1) == 0)
5422 {
5423 if (*option == '+')
5424 break;
5425 i++;
5426 if (i == (ssize_t) argc)
5427 ThrowMogrifyException(OptionError,"MissingArgument",option);
5428 if (IsGeometry(argv[i]) == MagickFalse)
5429 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5430 break;
5431 }
5432 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5433 }
5434 case 'm':
5435 {
5436 if (LocaleCompare("magnify",option+1) == 0)
5437 break;
5438 if (LocaleCompare("map",option+1) == 0)
5439 {
5440 global_colormap=(*option == '+') ? MagickTrue : MagickFalse;
5441 if (*option == '+')
5442 break;
5443 i++;
5444 if (i == (ssize_t) argc)
5445 ThrowMogrifyException(OptionError,"MissingArgument",option);
5446 break;
5447 }
5448 if (LocaleCompare("mask",option+1) == 0)
5449 {
5450 if (*option == '+')
5451 break;
5452 i++;
5453 if (i == (ssize_t) argc)
5454 ThrowMogrifyException(OptionError,"MissingArgument",option);
5455 break;
5456 }
5457 if (LocaleCompare("matte",option+1) == 0)
5458 break;
5459 if (LocaleCompare("mattecolor",option+1) == 0)
5460 {
5461 if (*option == '+')
5462 break;
5463 i++;
5464 if (i == (ssize_t) argc)
5465 ThrowMogrifyException(OptionError,"MissingArgument",option);
5466 break;
5467 }
5468 if (LocaleCompare("maximum",option+1) == 0)
5469 break;
5470 if (LocaleCompare("mean-shift",option+1) == 0)
5471 {
5472 if (*option == '+')
5473 break;
5474 i++;
5475 if (i == (ssize_t) argc)
5476 ThrowMogrifyException(OptionError,"MissingArgument",option);
5477 if (IsGeometry(argv[i]) == MagickFalse)
5478 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5479 break;
5480 }
5481 if (LocaleCompare("median",option+1) == 0)
5482 {
5483 if (*option == '+')
5484 break;
5485 i++;
5486 if (i == (ssize_t) argc)
5487 ThrowMogrifyException(OptionError,"MissingArgument",option);
5488 if (IsGeometry(argv[i]) == MagickFalse)
5489 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5490 break;
5491 }
5492 if (LocaleCompare("metric",option+1) == 0)
5493 {
5494 ssize_t
5495 type;
5496
5497 if (*option == '+')
5498 break;
5499 i++;
5500 if (i == (ssize_t) argc)
5501 ThrowMogrifyException(OptionError,"MissingArgument",option);
5502 type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
5503 if (type < 0)
5504 ThrowMogrifyException(OptionError,"UnrecognizedMetricType",
5505 argv[i]);
5506 break;
5507 }
5508 if (LocaleCompare("minimum",option+1) == 0)
5509 break;
5510 if (LocaleCompare("modulate",option+1) == 0)
5511 {
5512 if (*option == '+')
5513 break;
5514 i++;
5515 if (i == (ssize_t) argc)
5516 ThrowMogrifyException(OptionError,"MissingArgument",option);
5517 if (IsGeometry(argv[i]) == MagickFalse)
5518 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5519 break;
5520 }
5521 if (LocaleCompare("mode",option+1) == 0)
5522 {
5523 if (*option == '+')
5524 break;
5525 i++;
5526 if (i == (ssize_t) argc)
5527 ThrowMogrifyException(OptionError,"MissingArgument",option);
5528 if (IsGeometry(argv[i]) == MagickFalse)
5529 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5530 break;
5531 }
5532 if (LocaleCompare("monitor",option+1) == 0)
5533 break;
5534 if (LocaleCompare("monochrome",option+1) == 0)
5535 break;
5536 if (LocaleCompare("morph",option+1) == 0)
5537 {
5538 if (*option == '+')
5539 break;
5540 i++;
5541 if (i == (ssize_t) argc)
5542 ThrowMogrifyException(OptionError,"MissingArgument",option);
5543 if (IsGeometry(argv[i]) == MagickFalse)
5544 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5545 break;
5546 }
5547 if (LocaleCompare("morphology",option+1) == 0)
5548 {
5549 char
5550 token[MagickPathExtent];
5551
5552 KernelInfo
5553 *kernel_info;
5554
5555 ssize_t
5556 op;
5557
5558 i++;
5559 if (i == (ssize_t) argc)
5560 ThrowMogrifyException(OptionError,"MissingArgument",option);
5561 (void) GetNextToken(argv[i],(const char **) NULL,MagickPathExtent,
5562 token);
5563 op=ParseCommandOption(MagickMorphologyOptions,MagickFalse,token);
5564 if (op < 0)
5565 ThrowMogrifyException(OptionError,"UnrecognizedMorphologyMethod",
5566 token);
5567 i++;
5568 if (i == (ssize_t) argc)
5569 ThrowMogrifyException(OptionError,"MissingArgument",option);
5570 kernel_info=AcquireKernelInfo(argv[i],exception);
5571 if (kernel_info == (KernelInfo *) NULL)
5572 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5573 kernel_info=DestroyKernelInfo(kernel_info);
5574 break;
5575 }
5576 if (LocaleCompare("mosaic",option+1) == 0)
5577 break;
5578 if (LocaleCompare("motion-blur",option+1) == 0)
5579 {
5580 if (*option == '+')
5581 break;
5582 i++;
5583 if (i == (ssize_t) argc)
5584 ThrowMogrifyException(OptionError,"MissingArgument",option);
5585 if (IsGeometry(argv[i]) == MagickFalse)
5586 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5587 break;
5588 }
5589 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5590 }
5591 case 'n':
5592 {
5593 if (LocaleCompare("negate",option+1) == 0)
5594 break;
5595 if (LocaleCompare("noise",option+1) == 0)
5596 {
5597 i++;
5598 if (i == (ssize_t) argc)
5599 ThrowMogrifyException(OptionError,"MissingArgument",option);
5600 if (*option == '+')
5601 {
5602 ssize_t
5603 noise;
5604
5605 noise=ParseCommandOption(MagickNoiseOptions,MagickFalse,
5606 argv[i]);
5607 if (noise < 0)
5608 ThrowMogrifyException(OptionError,"UnrecognizedNoiseType",
5609 argv[i]);
5610 break;
5611 }
5612 if (IsGeometry(argv[i]) == MagickFalse)
5613 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5614 break;
5615 }
5616 if (LocaleCompare("noop",option+1) == 0)
5617 break;
5618 if (LocaleCompare("normalize",option+1) == 0)
5619 break;
5620 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5621 }
5622 case 'o':
5623 {
5624 if (LocaleCompare("opaque",option+1) == 0)
5625 {
5626 i++;
5627 if (i == (ssize_t) argc)
5628 ThrowMogrifyException(OptionError,"MissingArgument",option);
5629 break;
5630 }
5631 if (LocaleCompare("ordered-dither",option+1) == 0)
5632 {
5633 if (*option == '+')
5634 break;
5635 i++;
5636 if (i == (ssize_t) argc)
5637 ThrowMogrifyException(OptionError,"MissingArgument",option);
5638 break;
5639 }
5640 if (LocaleCompare("orient",option+1) == 0)
5641 {
5642 ssize_t
5643 orientation;
5644
5645 orientation=UndefinedOrientation;
5646 if (*option == '+')
5647 break;
5648 i++;
5649 if (i == (ssize_t) argc)
5650 ThrowMogrifyException(OptionError,"MissingArgument",option);
5651 orientation=ParseCommandOption(MagickOrientationOptions,MagickFalse,
5652 argv[i]);
5653 if (orientation < 0)
5654 ThrowMogrifyException(OptionError,"UnrecognizedImageOrientation",
5655 argv[i]);
5656 break;
5657 }
5658 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5659 }
5660 case 'p':
5661 {
5662 if (LocaleCompare("page",option+1) == 0)
5663 {
5664 if (*option == '+')
5665 break;
5666 i++;
5667 if (i == (ssize_t) argc)
5668 ThrowMogrifyException(OptionError,"MissingArgument",option);
5669 break;
5670 }
5671 if (LocaleCompare("paint",option+1) == 0)
5672 {
5673 if (*option == '+')
5674 break;
5675 i++;
5676 if (i == (ssize_t) argc)
5677 ThrowMogrifyException(OptionError,"MissingArgument",option);
5678 if (IsGeometry(argv[i]) == MagickFalse)
5679 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5680 break;
5681 }
5682 if (LocaleCompare("path",option+1) == 0)
5683 {
5684 (void) CloneString(&path,(char *) NULL);
5685 if (*option == '+')
5686 break;
5687 i++;
5688 if (i == (ssize_t) argc)
5689 ThrowMogrifyException(OptionError,"MissingArgument",option);
5690 (void) CloneString(&path,argv[i]);
5691 break;
5692 }
5693 if (LocaleCompare("perceptible",option+1) == 0)
5694 {
5695 if (*option == '+')
5696 break;
5697 i++;
5698 if (i == (ssize_t) argc)
5699 ThrowMogrifyException(OptionError,"MissingArgument",option);
5700 if (IsGeometry(argv[i]) == MagickFalse)
5701 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5702 break;
5703 }
5704 if (LocaleCompare("pointsize",option+1) == 0)
5705 {
5706 if (*option == '+')
5707 break;
5708 i++;
5709 if (i == (ssize_t) argc)
5710 ThrowMogrifyException(OptionError,"MissingArgument",option);
5711 if (IsGeometry(argv[i]) == MagickFalse)
5712 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5713 break;
5714 }
5715 if (LocaleCompare("polaroid",option+1) == 0)
5716 {
5717 if (*option == '+')
5718 break;
5719 i++;
5720 if (i == (ssize_t) argc)
5721 ThrowMogrifyException(OptionError,"MissingArgument",option);
5722 if (IsGeometry(argv[i]) == MagickFalse)
5723 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5724 break;
5725 }
5726 if (LocaleCompare("poly",option+1) == 0)
5727 {
5728 if (*option == '+')
5729 break;
5730 i++;
5731 if (i == (ssize_t) argc)
5732 ThrowMogrifyException(OptionError,"MissingArgument",option);
5733 if (IsGeometry(argv[i]) == MagickFalse)
5734 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5735 break;
5736 }
5737 if (LocaleCompare("posterize",option+1) == 0)
5738 {
5739 if (*option == '+')
5740 break;
5741 i++;
5742 if (i == (ssize_t) argc)
5743 ThrowMogrifyException(OptionError,"MissingArgument",option);
5744 if (IsGeometry(argv[i]) == MagickFalse)
5745 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5746 break;
5747 }
5748 if (LocaleCompare("precision",option+1) == 0)
5749 {
5750 if (*option == '+')
5751 break;
5752 i++;
5753 if (i == (ssize_t) argc)
5754 ThrowMogrifyException(OptionError,"MissingArgument",option);
5755 if (IsGeometry(argv[i]) == MagickFalse)
5756 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5757 break;
5758 }
5759 if (LocaleCompare("print",option+1) == 0)
5760 {
5761 if (*option == '+')
5762 break;
5763 i++;
5764 if (i == (ssize_t) argc)
5765 ThrowMogrifyException(OptionError,"MissingArgument",option);
5766 break;
5767 }
5768 if (LocaleCompare("process",option+1) == 0)
5769 {
5770 if (*option == '+')
5771 break;
5772 i++;
5773 if (i == (ssize_t) argc)
5774 ThrowMogrifyException(OptionError,"MissingArgument",option);
5775 break;
5776 }
5777 if (LocaleCompare("profile",option+1) == 0)
5778 {
5779 i++;
5780 if (i == (ssize_t) argc)
5781 ThrowMogrifyException(OptionError,"MissingArgument",option);
5782 break;
5783 }
5784 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5785 }
5786 case 'q':
5787 {
5788 if (LocaleCompare("quality",option+1) == 0)
5789 {
5790 if (*option == '+')
5791 break;
5792 i++;
5793 if (i == (ssize_t) argc)
5794 ThrowMogrifyException(OptionError,"MissingArgument",option);
5795 if (IsGeometry(argv[i]) == MagickFalse)
5796 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5797 break;
5798 }
5799 if (LocaleCompare("quantize",option+1) == 0)
5800 {
5801 ssize_t
5802 colorspace;
5803
5804 if (*option == '+')
5805 break;
5806 i++;
5807 if (i == (ssize_t) argc)
5808 ThrowMogrifyException(OptionError,"MissingArgument",option);
5809 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
5810 argv[i]);
5811 if (colorspace < 0)
5812 ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
5813 argv[i]);
5814 break;
5815 }
5816 if (LocaleCompare("quiet",option+1) == 0)
5817 break;
5818 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5819 }
5820 case 'r':
5821 {
5822 if (LocaleCompare("rotational-blur",option+1) == 0)
5823 {
5824 i++;
5825 if (i == (ssize_t) argc)
5826 ThrowMogrifyException(OptionError,"MissingArgument",option);
5827 if (IsGeometry(argv[i]) == MagickFalse)
5828 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5829 break;
5830 }
5831 if (LocaleCompare("raise",option+1) == 0)
5832 {
5833 i++;
5834 if (i == (ssize_t) argc)
5835 ThrowMogrifyException(OptionError,"MissingArgument",option);
5836 if (IsGeometry(argv[i]) == MagickFalse)
5837 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5838 break;
5839 }
5840 if (LocaleCompare("random-threshold",option+1) == 0)
5841 {
5842 if (*option == '+')
5843 break;
5844 i++;
5845 if (i == (ssize_t) argc)
5846 ThrowMogrifyException(OptionError,"MissingArgument",option);
5847 if (IsGeometry(argv[i]) == MagickFalse)
5848 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5849 break;
5850 }
5851 if (LocaleCompare("range-threshold",option+1) == 0)
5852 {
5853 if (*option == '+')
5854 break;
5855 i++;
5856 if (i == (ssize_t) argc)
5857 ThrowMogrifyException(OptionError,"MissingArgument",option);
5858 if (IsGeometry(argv[i]) == MagickFalse)
5859 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5860 break;
5861 }
5862 if (LocaleCompare("read-mask",option+1) == 0)
5863 {
5864 if (*option == '+')
5865 break;
5866 i++;
5867 if (i == (ssize_t) argc)
5868 ThrowMogrifyException(OptionError,"MissingArgument",option);
5869 break;
5870 }
5871 if (LocaleCompare("red-primary",option+1) == 0)
5872 {
5873 if (*option == '+')
5874 break;
5875 i++;
5876 if (i == (ssize_t) argc)
5877 ThrowMogrifyException(OptionError,"MissingArgument",option);
5878 if (IsGeometry(argv[i]) == MagickFalse)
5879 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5880 }
5881 if (LocaleCompare("regard-warnings",option+1) == 0)
5882 break;
5883 if (LocaleCompare("region",option+1) == 0)
5884 {
5885 if (*option == '+')
5886 break;
5887 i++;
5888 if (i == (ssize_t) argc)
5889 ThrowMogrifyException(OptionError,"MissingArgument",option);
5890 if (IsGeometry(argv[i]) == MagickFalse)
5891 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5892 break;
5893 }
5894 if (LocaleCompare("remap",option+1) == 0)
5895 {
5896 if (*option == '+')
5897 break;
5898 i++;
5899 if (i == (ssize_t) argc)
5900 ThrowMogrifyException(OptionError,"MissingArgument",option);
5901 break;
5902 }
5903 if (LocaleCompare("render",option+1) == 0)
5904 break;
5905 if (LocaleCompare("repage",option+1) == 0)
5906 {
5907 if (*option == '+')
5908 break;
5909 i++;
5910 if (i == (ssize_t) argc)
5911 ThrowMogrifyException(OptionError,"MissingArgument",option);
5912 if (IsGeometry(argv[i]) == MagickFalse)
5913 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5914 break;
5915 }
5916 if (LocaleCompare("resample",option+1) == 0)
5917 {
5918 if (*option == '+')
5919 break;
5920 i++;
5921 if (i == (ssize_t) argc)
5922 ThrowMogrifyException(OptionError,"MissingArgument",option);
5923 if (IsGeometry(argv[i]) == MagickFalse)
5924 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5925 break;
5926 }
5927 if (LocaleCompare("reshape",option+1) == 0)
5928 {
5929 if (*option == '+')
5930 break;
5931 i++;
5932 if (i == (ssize_t) argc)
5933 ThrowMogrifyException(OptionError,"MissingArgument",option);
5934 if (IsGeometry(argv[i]) == MagickFalse)
5935 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5936 break;
5937 }
5938 if (LocaleCompare("resize",option+1) == 0)
5939 {
5940 if (*option == '+')
5941 break;
5942 i++;
5943 if (i == (ssize_t) argc)
5944 ThrowMogrifyException(OptionError,"MissingArgument",option);
5945 if (IsGeometry(argv[i]) == MagickFalse)
5946 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5947 break;
5948 }
5949 if ((LocaleNCompare("respect-parentheses",option+1,17) == 0) ||
5950 (LocaleNCompare("respect-parenthesis",option+1,17) == 0))
5951 {
5952 respect_parentheses=(*option == '-') ? MagickTrue : MagickFalse;
5953 break;
5954 }
5955 if (LocaleCompare("reverse",option+1) == 0)
5956 break;
5957 if (LocaleCompare("roll",option+1) == 0)
5958 {
5959 if (*option == '+')
5960 break;
5961 i++;
5962 if (i == (ssize_t) argc)
5963 ThrowMogrifyException(OptionError,"MissingArgument",option);
5964 if (IsGeometry(argv[i]) == MagickFalse)
5965 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5966 break;
5967 }
5968 if (LocaleCompare("rotate",option+1) == 0)
5969 {
5970 i++;
5971 if (i == (ssize_t) argc)
5972 ThrowMogrifyException(OptionError,"MissingArgument",option);
5973 if (IsGeometry(argv[i]) == MagickFalse)
5974 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5975 break;
5976 }
5977 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5978 }
5979 case 's':
5980 {
5981 if (LocaleCompare("sample",option+1) == 0)
5982 {
5983 if (*option == '+')
5984 break;
5985 i++;
5986 if (i == (ssize_t) argc)
5987 ThrowMogrifyException(OptionError,"MissingArgument",option);
5988 if (IsGeometry(argv[i]) == MagickFalse)
5989 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5990 break;
5991 }
5992 if (LocaleCompare("sampling-factor",option+1) == 0)
5993 {
5994 if (*option == '+')
5995 break;
5996 i++;
5997 if (i == (ssize_t) argc)
5998 ThrowMogrifyException(OptionError,"MissingArgument",option);
5999 if (IsGeometry(argv[i]) == MagickFalse)
6000 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6001 break;
6002 }
6003 if (LocaleCompare("scale",option+1) == 0)
6004 {
6005 if (*option == '+')
6006 break;
6007 i++;
6008 if (i == (ssize_t) argc)
6009 ThrowMogrifyException(OptionError,"MissingArgument",option);
6010 if (IsGeometry(argv[i]) == MagickFalse)
6011 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6012 break;
6013 }
6014 if (LocaleCompare("scene",option+1) == 0)
6015 {
6016 if (*option == '+')
6017 break;
6018 i++;
6019 if (i == (ssize_t) argc)
6020 ThrowMogrifyException(OptionError,"MissingArgument",option);
6021 if (IsGeometry(argv[i]) == MagickFalse)
6022 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6023 break;
6024 }
6025 if (LocaleCompare("seed",option+1) == 0)
6026 {
6027 if (*option == '+')
6028 break;
6029 i++;
6030 if (i == (ssize_t) argc)
6031 ThrowMogrifyException(OptionError,"MissingArgument",option);
6032 if (IsGeometry(argv[i]) == MagickFalse)
6033 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6034 break;
6035 }
6036 if (LocaleCompare("segment",option+1) == 0)
6037 {
6038 if (*option == '+')
6039 break;
6040 i++;
6041 if (i == (ssize_t) argc)
6042 ThrowMogrifyException(OptionError,"MissingArgument",option);
6043 if (IsGeometry(argv[i]) == MagickFalse)
6044 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6045 break;
6046 }
6047 if (LocaleCompare("selective-blur",option+1) == 0)
6048 {
6049 i++;
6050 if (i == (ssize_t) argc)
6051 ThrowMogrifyException(OptionError,"MissingArgument",option);
6052 if (IsGeometry(argv[i]) == MagickFalse)
6053 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6054 break;
6055 }
6056 if (LocaleCompare("separate",option+1) == 0)
6057 break;
6058 if (LocaleCompare("sepia-tone",option+1) == 0)
6059 {
6060 if (*option == '+')
6061 break;
6062 i++;
6063 if (i == (ssize_t) argc)
6064 ThrowMogrifyException(OptionError,"MissingArgument",option);
6065 if (IsGeometry(argv[i]) == MagickFalse)
6066 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6067 break;
6068 }
6069 if (LocaleCompare("set",option+1) == 0)
6070 {
6071 i++;
6072 if (i == (ssize_t) argc)
6073 ThrowMogrifyException(OptionError,"MissingArgument",option);
6074 if (*option == '+')
6075 break;
6076 i++;
6077 if (i == (ssize_t) argc)
6078 ThrowMogrifyException(OptionError,"MissingArgument",option);
6079 break;
6080 }
6081 if (LocaleCompare("shade",option+1) == 0)
6082 {
6083 i++;
6084 if (i == (ssize_t) argc)
6085 ThrowMogrifyException(OptionError,"MissingArgument",option);
6086 if (IsGeometry(argv[i]) == MagickFalse)
6087 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6088 break;
6089 }
6090 if (LocaleCompare("shadow",option+1) == 0)
6091 {
6092 if (*option == '+')
6093 break;
6094 i++;
6095 if (i == (ssize_t) argc)
6096 ThrowMogrifyException(OptionError,"MissingArgument",option);
6097 if (IsGeometry(argv[i]) == MagickFalse)
6098 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6099 break;
6100 }
6101 if (LocaleCompare("sharpen",option+1) == 0)
6102 {
6103 i++;
6104 if (i == (ssize_t) argc)
6105 ThrowMogrifyException(OptionError,"MissingArgument",option);
6106 if (IsGeometry(argv[i]) == MagickFalse)
6107 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6108 break;
6109 }
6110 if (LocaleCompare("shave",option+1) == 0)
6111 {
6112 if (*option == '+')
6113 break;
6114 i++;
6115 if (i == (ssize_t) argc)
6116 ThrowMogrifyException(OptionError,"MissingArgument",option);
6117 if (IsGeometry(argv[i]) == MagickFalse)
6118 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6119 break;
6120 }
6121 if (LocaleCompare("shear",option+1) == 0)
6122 {
6123 i++;
6124 if (i == (ssize_t) argc)
6125 ThrowMogrifyException(OptionError,"MissingArgument",option);
6126 if (IsGeometry(argv[i]) == MagickFalse)
6127 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6128 break;
6129 }
6130 if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
6131 {
6132 i++;
6133 if (i == (ssize_t) argc)
6134 ThrowMogrifyException(OptionError,"MissingArgument",option);
6135 if (IsGeometry(argv[i]) == MagickFalse)
6136 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6137 break;
6138 }
6139 if (LocaleCompare("size",option+1) == 0)
6140 {
6141 if (*option == '+')
6142 break;
6143 i++;
6144 if (i == (ssize_t) argc)
6145 ThrowMogrifyException(OptionError,"MissingArgument",option);
6146 if (IsGeometry(argv[i]) == MagickFalse)
6147 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6148 break;
6149 }
6150 if (LocaleCompare("sketch",option+1) == 0)
6151 {
6152 if (*option == '+')
6153 break;
6154 i++;
6155 if (i == (ssize_t) argc)
6156 ThrowMogrifyException(OptionError,"MissingArgument",option);
6157 if (IsGeometry(argv[i]) == MagickFalse)
6158 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6159 break;
6160 }
6161 if (LocaleCompare("smush",option+1) == 0)
6162 {
6163 i++;
6164 if (i == (ssize_t) argc)
6165 ThrowMogrifyException(OptionError,"MissingArgument",option);
6166 if (IsGeometry(argv[i]) == MagickFalse)
6167 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6168 i++;
6169 break;
6170 }
6171 if (LocaleCompare("solarize",option+1) == 0)
6172 {
6173 if (*option == '+')
6174 break;
6175 i++;
6176 if (i == (ssize_t) argc)
6177 ThrowMogrifyException(OptionError,"MissingArgument",option);
6178 if (IsGeometry(argv[i]) == MagickFalse)
6179 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6180 break;
6181 }
6182 if (LocaleCompare("sort",option+1) == 0)
6183 break;
6184 if (LocaleCompare("sparse-color",option+1) == 0)
6185 {
6186 ssize_t
6187 op;
6188
6189 i++;
6190 if (i == (ssize_t) argc)
6191 ThrowMogrifyException(OptionError,"MissingArgument",option);
6192 op=ParseCommandOption(MagickSparseColorOptions,MagickFalse,argv[i]);
6193 if (op < 0)
6194 ThrowMogrifyException(OptionError,"UnrecognizedSparseColorMethod",
6195 argv[i]);
6196 i++;
6197 if (i == (ssize_t) argc)
6198 ThrowMogrifyException(OptionError,"MissingArgument",option);
6199 break;
6200 }
6201 if (LocaleCompare("splice",option+1) == 0)
6202 {
6203 if (*option == '+')
6204 break;
6205 i++;
6206 if (i == (ssize_t) argc)
6207 ThrowMogrifyException(OptionError,"MissingArgument",option);
6208 if (IsGeometry(argv[i]) == MagickFalse)
6209 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6210 break;
6211 }
6212 if (LocaleCompare("spread",option+1) == 0)
6213 {
6214 if (*option == '+')
6215 break;
6216 i++;
6217 if (i == (ssize_t) argc)
6218 ThrowMogrifyException(OptionError,"MissingArgument",option);
6219 if (IsGeometry(argv[i]) == MagickFalse)
6220 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6221 break;
6222 }
6223 if (LocaleCompare("statistic",option+1) == 0)
6224 {
6225 ssize_t
6226 op;
6227
6228 if (*option == '+')
6229 break;
6230 i++;
6231 if (i == (ssize_t) argc)
6232 ThrowMogrifyException(OptionError,"MissingArgument",option);
6233 op=ParseCommandOption(MagickStatisticOptions,MagickFalse,argv[i]);
6234 if (op < 0)
6235 ThrowMogrifyException(OptionError,"UnrecognizedStatisticType",
6236 argv[i]);
6237 i++;
6238 if (i == (ssize_t) argc)
6239 ThrowMogrifyException(OptionError,"MissingArgument",option);
6240 if (IsGeometry(argv[i]) == MagickFalse)
6241 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6242 break;
6243 }
6244 if (LocaleCompare("stretch",option+1) == 0)
6245 {
6246 ssize_t
6247 stretch;
6248
6249 if (*option == '+')
6250 break;
6251 i++;
6252 if (i == (ssize_t) argc)
6253 ThrowMogrifyException(OptionError,"MissingArgument",option);
6254 stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,
6255 argv[i]);
6256 if (stretch < 0)
6257 ThrowMogrifyException(OptionError,"UnrecognizedStyleType",
6258 argv[i]);
6259 break;
6260 }
6261 if (LocaleCompare("strip",option+1) == 0)
6262 break;
6263 if (LocaleCompare("stroke",option+1) == 0)
6264 {
6265 if (*option == '+')
6266 break;
6267 i++;
6268 if (i == (ssize_t) argc)
6269 ThrowMogrifyException(OptionError,"MissingArgument",option);
6270 break;
6271 }
6272 if (LocaleCompare("strokewidth",option+1) == 0)
6273 {
6274 if (*option == '+')
6275 break;
6276 i++;
6277 if (i == (ssize_t) argc)
6278 ThrowMogrifyException(OptionError,"MissingArgument",option);
6279 if (IsGeometry(argv[i]) == MagickFalse)
6280 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6281 break;
6282 }
6283 if (LocaleCompare("style",option+1) == 0)
6284 {
6285 ssize_t
6286 style;
6287
6288 if (*option == '+')
6289 break;
6290 i++;
6291 if (i == (ssize_t) argc)
6292 ThrowMogrifyException(OptionError,"MissingArgument",option);
6293 style=ParseCommandOption(MagickStyleOptions,MagickFalse,argv[i]);
6294 if (style < 0)
6295 ThrowMogrifyException(OptionError,"UnrecognizedStyleType",
6296 argv[i]);
6297 break;
6298 }
6299 if (LocaleCompare("swap",option+1) == 0)
6300 {
6301 if (*option == '+')
6302 break;
6303 i++;
6304 if (i == (ssize_t) argc)
6305 ThrowMogrifyException(OptionError,"MissingArgument",option);
6306 if (IsGeometry(argv[i]) == MagickFalse)
6307 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6308 break;
6309 }
6310 if (LocaleCompare("swirl",option+1) == 0)
6311 {
6312 if (*option == '+')
6313 break;
6314 i++;
6315 if (i == (ssize_t) argc)
6316 ThrowMogrifyException(OptionError,"MissingArgument",option);
6317 if (IsGeometry(argv[i]) == MagickFalse)
6318 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6319 break;
6320 }
6321 if (LocaleCompare("synchronize",option+1) == 0)
6322 break;
6323 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6324 }
6325 case 't':
6326 {
6327 if (LocaleCompare("taint",option+1) == 0)
6328 break;
6329 if (LocaleCompare("texture",option+1) == 0)
6330 {
6331 if (*option == '+')
6332 break;
6333 i++;
6334 if (i == (ssize_t) argc)
6335 ThrowMogrifyException(OptionError,"MissingArgument",option);
6336 break;
6337 }
6338 if (LocaleCompare("tile",option+1) == 0)
6339 {
6340 if (*option == '+')
6341 break;
6342 i++;
6343 if (i == (ssize_t) argc)
6344 ThrowMogrifyException(OptionError,"MissingArgument",option);
6345 break;
6346 }
6347 if (LocaleCompare("tile-offset",option+1) == 0)
6348 {
6349 if (*option == '+')
6350 break;
6351 i++;
6352 if (i == (ssize_t) argc)
6353 ThrowMogrifyException(OptionError,"MissingArgument",option);
6354 if (IsGeometry(argv[i]) == MagickFalse)
6355 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6356 break;
6357 }
6358 if (LocaleCompare("tint",option+1) == 0)
6359 {
6360 if (*option == '+')
6361 break;
6362 i++;
6363 if (i == (ssize_t) argc)
6364 ThrowMogrifyException(OptionError,"MissingArgument",option);
6365 if (IsGeometry(argv[i]) == MagickFalse)
6366 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6367 break;
6368 }
6369 if (LocaleCompare("transform",option+1) == 0)
6370 break;
6371 if (LocaleCompare("transpose",option+1) == 0)
6372 break;
6373 if (LocaleCompare("transverse",option+1) == 0)
6374 break;
6375 if (LocaleCompare("threshold",option+1) == 0)
6376 {
6377 if (*option == '+')
6378 break;
6379 i++;
6380 if (i == (ssize_t) argc)
6381 ThrowMogrifyException(OptionError,"MissingArgument",option);
6382 if (IsGeometry(argv[i]) == MagickFalse)
6383 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6384 break;
6385 }
6386 if (LocaleCompare("thumbnail",option+1) == 0)
6387 {
6388 if (*option == '+')
6389 break;
6390 i++;
6391 if (i == (ssize_t) argc)
6392 ThrowMogrifyException(OptionError,"MissingArgument",option);
6393 if (IsGeometry(argv[i]) == MagickFalse)
6394 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6395 break;
6396 }
6397 if (LocaleCompare("transparent",option+1) == 0)
6398 {
6399 i++;
6400 if (i == (ssize_t) argc)
6401 ThrowMogrifyException(OptionError,"MissingArgument",option);
6402 break;
6403 }
6404 if (LocaleCompare("transparent-color",option+1) == 0)
6405 {
6406 if (*option == '+')
6407 break;
6408 i++;
6409 if (i == (ssize_t) argc)
6410 ThrowMogrifyException(OptionError,"MissingArgument",option);
6411 break;
6412 }
6413 if (LocaleCompare("treedepth",option+1) == 0)
6414 {
6415 if (*option == '+')
6416 break;
6417 i++;
6418 if (i == (ssize_t) argc)
6419 ThrowMogrifyException(OptionError,"MissingArgument",option);
6420 if (IsGeometry(argv[i]) == MagickFalse)
6421 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6422 break;
6423 }
6424 if (LocaleCompare("trim",option+1) == 0)
6425 break;
6426 if (LocaleCompare("type",option+1) == 0)
6427 {
6428 ssize_t
6429 type;
6430
6431 if (*option == '+')
6432 break;
6433 i++;
6434 if (i == (ssize_t) argc)
6435 ThrowMogrifyException(OptionError,"MissingArgument",option);
6436 type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
6437 if (type < 0)
6438 ThrowMogrifyException(OptionError,"UnrecognizedImageType",
6439 argv[i]);
6440 break;
6441 }
6442 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6443 }
6444 case 'u':
6445 {
6446 if (LocaleCompare("undercolor",option+1) == 0)
6447 {
6448 if (*option == '+')
6449 break;
6450 i++;
6451 if (i == (ssize_t) argc)
6452 ThrowMogrifyException(OptionError,"MissingArgument",option);
6453 break;
6454 }
6455 if (LocaleCompare("unique-colors",option+1) == 0)
6456 break;
6457 if (LocaleCompare("units",option+1) == 0)
6458 {
6459 ssize_t
6460 units;
6461
6462 if (*option == '+')
6463 break;
6464 i++;
6465 if (i == (ssize_t) argc)
6466 ThrowMogrifyException(OptionError,"MissingArgument",option);
6467 units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
6468 argv[i]);
6469 if (units < 0)
6470 ThrowMogrifyException(OptionError,"UnrecognizedUnitsType",
6471 argv[i]);
6472 break;
6473 }
6474 if (LocaleCompare("unsharp",option+1) == 0)
6475 {
6476 i++;
6477 if (i == (ssize_t) argc)
6478 ThrowMogrifyException(OptionError,"MissingArgument",option);
6479 if (IsGeometry(argv[i]) == MagickFalse)
6480 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6481 break;
6482 }
6483 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6484 }
6485 case 'v':
6486 {
6487 if (LocaleCompare("verbose",option+1) == 0)
6488 {
6489 image_info->verbose=(*option == '-') ? MagickTrue : MagickFalse;
6490 break;
6491 }
6492 if ((LocaleCompare("version",option+1) == 0) ||
6493 (LocaleCompare("-version",option+1) == 0))
6494 {
6495 ListMagickVersion(stdout);
6496 break;
6497 }
6498 if (LocaleCompare("vignette",option+1) == 0)
6499 {
6500 if (*option == '+')
6501 break;
6502 i++;
6503 if (i == (ssize_t) argc)
6504 ThrowMogrifyException(OptionError,"MissingArgument",option);
6505 if (IsGeometry(argv[i]) == MagickFalse)
6506 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6507 break;
6508 }
6509 if (LocaleCompare("virtual-pixel",option+1) == 0)
6510 {
6511 ssize_t
6512 method;
6513
6514 if (*option == '+')
6515 break;
6516 i++;
6517 if (i == (ssize_t) argc)
6518 ThrowMogrifyException(OptionError,"MissingArgument",option);
6519 method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
6520 argv[i]);
6521 if (method < 0)
6522 ThrowMogrifyException(OptionError,
6523 "UnrecognizedVirtualPixelMethod",argv[i]);
6524 break;
6525 }
6526 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6527 }
6528 case 'w':
6529 {
6530 if (LocaleCompare("wave",option+1) == 0)
6531 {
6532 i++;
6533 if (i == (ssize_t) argc)
6534 ThrowMogrifyException(OptionError,"MissingArgument",option);
6535 if (IsGeometry(argv[i]) == MagickFalse)
6536 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6537 break;
6538 }
6539 if (LocaleCompare("wavelet-denoise",option+1) == 0)
6540 {
6541 i++;
6542 if (i == (ssize_t) argc)
6543 ThrowMogrifyException(OptionError,"MissingArgument",option);
6544 if (IsGeometry(argv[i]) == MagickFalse)
6545 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6546 break;
6547 }
6548 if (LocaleCompare("weight",option+1) == 0)
6549 {
6550 if (*option == '+')
6551 break;
6552 i++;
6553 if (i == (ssize_t) argc)
6554 ThrowMogrifyException(OptionError,"MissingArgument",option);
6555 break;
6556 }
6557 if (LocaleCompare("word-break",option+1) == 0)
6558 {
6559 ssize_t
6560 word_break;
6561
6562 if (*option == '+')
6563 break;
6564 i++;
6565 if (i == (ssize_t) argc)
6566 ThrowMogrifyException(OptionError,"MissingArgument",option);
6567 word_break=ParseCommandOption(MagickWordBreakOptions,MagickFalse,
6568 argv[i]);
6569 if (word_break < 0)
6570 ThrowMogrifyException(OptionError,"UnrecognizedArgument",argv[i]);
6571 break;
6572 }
6573 if (LocaleCompare("white-balance",option+1) == 0)
6574 break;
6575 if (LocaleCompare("white-point",option+1) == 0)
6576 {
6577 if (*option == '+')
6578 break;
6579 i++;
6580 if (i == (ssize_t) argc)
6581 ThrowMogrifyException(OptionError,"MissingArgument",option);
6582 if (IsGeometry(argv[i]) == MagickFalse)
6583 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6584 break;
6585 }
6586 if (LocaleCompare("white-threshold",option+1) == 0)
6587 {
6588 if (*option == '+')
6589 break;
6590 i++;
6591 if (i == (ssize_t) argc)
6592 ThrowMogrifyException(OptionError,"MissingArgument",option);
6593 if (IsGeometry(argv[i]) == MagickFalse)
6594 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6595 break;
6596 }
6597 if (LocaleCompare("write",option+1) == 0)
6598 {
6599 i++;
6600 if (i == (ssize_t) argc)
6601 ThrowMogrifyException(OptionError,"MissingArgument",option);
6602 break;
6603 }
6604 if (LocaleCompare("write-mask",option+1) == 0)
6605 {
6606 if (*option == '+')
6607 break;
6608 i++;
6609 if (i == (ssize_t) argc)
6610 ThrowMogrifyException(OptionError,"MissingArgument",option);
6611 break;
6612 }
6613 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6614 }
6615 case '?':
6616 break;
6617 default:
6618 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6619 }
6620 fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
6621 FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
6622 if (fire != MagickFalse)
6623 FireImageStack(MagickFalse,MagickTrue,MagickTrue);
6624 }
6625 if (k != 0)
6626 ThrowMogrifyException(OptionError,"UnbalancedParenthesis",argv[i]);
6627 if (i != (ssize_t) argc)
6628 ThrowMogrifyException(OptionError,"MissingAnImageFilename",argv[i]);
6629 DestroyMogrify();
6630 return(status != 0 ? MagickTrue : MagickFalse);
6631}
6632␌
6633/*
6634%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6635% %
6636% %
6637% %
6638+ M o g r i f y I m a g e I n f o %
6639% %
6640% %
6641% %
6642%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6643%
6644% MogrifyImageInfo() applies image processing settings to the image as
6645% prescribed by command line options.
6646%
6647% The format of the MogrifyImageInfo method is:
6648%
6649% MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,const int argc,
6650% const char **argv,ExceptionInfo *exception)
6651%
6652% A description of each parameter follows:
6653%
6654% o image_info: the image info..
6655%
6656% o argc: Specifies a pointer to an integer describing the number of
6657% elements in the argument vector.
6658%
6659% o argv: Specifies a pointer to a text array containing the command line
6660% arguments.
6661%
6662% o exception: return any errors or warnings in this structure.
6663%
6664*/
6665WandExport MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,
6666 const int argc,const char **argv,ExceptionInfo *exception)
6667{
6668 const char
6669 *option;
6670
6671 GeometryInfo
6672 geometry_info;
6673
6674 ssize_t
6675 count;
6676
6677 ssize_t
6678 i;
6679
6680 /*
6681 Initialize method variables.
6682 */
6683 assert(image_info != (ImageInfo *) NULL);
6684 assert(image_info->signature == MagickCoreSignature);
6685 if (IsEventLogging() != MagickFalse)
6686 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
6687 image_info->filename);
6688 if (argc < 0)
6689 return(MagickTrue);
6690 /*
6691 Set the image settings.
6692 */
6693 for (i=0; i < (ssize_t) argc; i++)
6694 {
6695 option=argv[i];
6696 if (IsCommandOption(option) == MagickFalse)
6697 continue;
6698 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
6699 count=MagickMax(count,0L);
6700 if ((i+count) >= (ssize_t) argc)
6701 break;
6702 switch (*(option+1))
6703 {
6704 case 'a':
6705 {
6706 if (LocaleCompare("adjoin",option+1) == 0)
6707 {
6708 image_info->adjoin=(*option == '-') ? MagickTrue : MagickFalse;
6709 break;
6710 }
6711 if (LocaleCompare("antialias",option+1) == 0)
6712 {
6713 image_info->antialias=(*option == '-') ? MagickTrue : MagickFalse;
6714 break;
6715 }
6716 if (LocaleCompare("authenticate",option+1) == 0)
6717 {
6718 if (*option == '+')
6719 (void) DeleteImageOption(image_info,option+1);
6720 else
6721 (void) SetImageOption(image_info,option+1,argv[i+1]);
6722 break;
6723 }
6724 break;
6725 }
6726 case 'b':
6727 {
6728 if (LocaleCompare("background",option+1) == 0)
6729 {
6730 if (*option == '+')
6731 {
6732 (void) DeleteImageOption(image_info,option+1);
6733 (void) QueryColorCompliance(MogrifyBackgroundColor,
6734 AllCompliance,&image_info->background_color,exception);
6735 break;
6736 }
6737 (void) SetImageOption(image_info,option+1,argv[i+1]);
6738 (void) QueryColorCompliance(argv[i+1],AllCompliance,
6739 &image_info->background_color,exception);
6740 break;
6741 }
6742 if (LocaleCompare("bias",option+1) == 0)
6743 {
6744 if (*option == '+')
6745 {
6746 (void) SetImageOption(image_info,"convolve:bias","0.0");
6747 break;
6748 }
6749 (void) SetImageOption(image_info,"convolve:bias",argv[i+1]);
6750 break;
6751 }
6752 if (LocaleCompare("black-point-compensation",option+1) == 0)
6753 {
6754 if (*option == '+')
6755 {
6756 (void) SetImageOption(image_info,option+1,"false");
6757 break;
6758 }
6759 (void) SetImageOption(image_info,option+1,"true");
6760 break;
6761 }
6762 if (LocaleCompare("blue-primary",option+1) == 0)
6763 {
6764 if (*option == '+')
6765 {
6766 (void) SetImageOption(image_info,option+1,"0.0");
6767 break;
6768 }
6769 (void) SetImageOption(image_info,option+1,argv[i+1]);
6770 break;
6771 }
6772 if (LocaleCompare("bordercolor",option+1) == 0)
6773 {
6774 if (*option == '+')
6775 {
6776 (void) DeleteImageOption(image_info,option+1);
6777 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance,
6778 &image_info->border_color,exception);
6779 break;
6780 }
6781 (void) QueryColorCompliance(argv[i+1],AllCompliance,
6782 &image_info->border_color,exception);
6783 (void) SetImageOption(image_info,option+1,argv[i+1]);
6784 break;
6785 }
6786 if (LocaleCompare("box",option+1) == 0)
6787 {
6788 if (*option == '+')
6789 {
6790 (void) SetImageOption(image_info,"undercolor","none");
6791 break;
6792 }
6793 (void) SetImageOption(image_info,"undercolor",argv[i+1]);
6794 break;
6795 }
6796 break;
6797 }
6798 case 'c':
6799 {
6800 if (LocaleCompare("cache",option+1) == 0)
6801 {
6802 MagickSizeType
6803 limit;
6804
6805 limit=MagickResourceInfinity;
6806 if (LocaleCompare("unlimited",argv[i+1]) != 0)
6807 limit=(MagickSizeType) SiPrefixToDoubleInterval(argv[i+1],
6808 100.0);
6809 (void) SetMagickResourceLimit(MemoryResource,limit);
6810 (void) SetMagickResourceLimit(MapResource,2*limit);
6811 break;
6812 }
6813 if (LocaleCompare("caption",option+1) == 0)
6814 {
6815 if (*option == '+')
6816 {
6817 (void) DeleteImageOption(image_info,option+1);
6818 break;
6819 }
6820 (void) SetImageOption(image_info,option+1,argv[i+1]);
6821 break;
6822 }
6823 if (LocaleCompare("colorspace",option+1) == 0)
6824 {
6825 if (*option == '+')
6826 {
6827 image_info->colorspace=UndefinedColorspace;
6828 (void) SetImageOption(image_info,option+1,"undefined");
6829 break;
6830 }
6831 image_info->colorspace=(ColorspaceType) ParseCommandOption(
6832 MagickColorspaceOptions,MagickFalse,argv[i+1]);
6833 (void) SetImageOption(image_info,option+1,argv[i+1]);
6834 break;
6835 }
6836 if (LocaleCompare("comment",option+1) == 0)
6837 {
6838 if (*option == '+')
6839 {
6840 (void) DeleteImageOption(image_info,option+1);
6841 break;
6842 }
6843 (void) SetImageOption(image_info,option+1,argv[i+1]);
6844 break;
6845 }
6846 if (LocaleCompare("compose",option+1) == 0)
6847 {
6848 if (*option == '+')
6849 {
6850 (void) SetImageOption(image_info,option+1,"undefined");
6851 break;
6852 }
6853 (void) SetImageOption(image_info,option+1,argv[i+1]);
6854 break;
6855 }
6856 if (LocaleCompare("compress",option+1) == 0)
6857 {
6858 if (*option == '+')
6859 {
6860 image_info->compression=UndefinedCompression;
6861 (void) SetImageOption(image_info,option+1,"undefined");
6862 break;
6863 }
6864 image_info->compression=(CompressionType) ParseCommandOption(
6865 MagickCompressOptions,MagickFalse,argv[i+1]);
6866 (void) SetImageOption(image_info,option+1,argv[i+1]);
6867 break;
6868 }
6869 break;
6870 }
6871 case 'd':
6872 {
6873 if (LocaleCompare("debug",option+1) == 0)
6874 {
6875 if (*option == '+')
6876 (void) SetLogEventMask("none");
6877 else
6878 (void) SetLogEventMask(argv[i+1]);
6879 image_info->debug=IsEventLogging();
6880 break;
6881 }
6882 if (LocaleCompare("define",option+1) == 0)
6883 {
6884 if (*option == '+')
6885 {
6886 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6887 (void) DeleteImageRegistry(argv[i+1]+9);
6888 else
6889 (void) DeleteImageOption(image_info,argv[i+1]);
6890 break;
6891 }
6892 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6893 {
6894 (void) DefineImageRegistry(StringRegistryType,argv[i+1]+9,
6895 exception);
6896 break;
6897 }
6898 (void) DefineImageOption(image_info,argv[i+1]);
6899 break;
6900 }
6901 if (LocaleCompare("delay",option+1) == 0)
6902 {
6903 if (*option == '+')
6904 {
6905 (void) SetImageOption(image_info,option+1,"0");
6906 break;
6907 }
6908 (void) SetImageOption(image_info,option+1,argv[i+1]);
6909 break;
6910 }
6911 if (LocaleCompare("density",option+1) == 0)
6912 {
6913 /*
6914 Set image density.
6915 */
6916 if (*option == '+')
6917 {
6918 if (image_info->density != (char *) NULL)
6919 image_info->density=DestroyString(image_info->density);
6920 (void) SetImageOption(image_info,option+1,"72");
6921 break;
6922 }
6923 (void) CloneString(&image_info->density,argv[i+1]);
6924 (void) SetImageOption(image_info,option+1,argv[i+1]);
6925 break;
6926 }
6927 if (LocaleCompare("depth",option+1) == 0)
6928 {
6929 if (*option == '+')
6930 {
6931 image_info->depth=MAGICKCORE_QUANTUM_DEPTH;
6932 break;
6933 }
6934 image_info->depth=StringToUnsignedLong(argv[i+1]);
6935 break;
6936 }
6937 if (LocaleCompare("direction",option+1) == 0)
6938 {
6939 if (*option == '+')
6940 {
6941 (void) SetImageOption(image_info,option+1,"undefined");
6942 break;
6943 }
6944 (void) SetImageOption(image_info,option+1,argv[i+1]);
6945 break;
6946 }
6947 if (LocaleCompare("display",option+1) == 0)
6948 {
6949 if (*option == '+')
6950 {
6951 if (image_info->server_name != (char *) NULL)
6952 image_info->server_name=DestroyString(
6953 image_info->server_name);
6954 break;
6955 }
6956 (void) CloneString(&image_info->server_name,argv[i+1]);
6957 break;
6958 }
6959 if (LocaleCompare("dispose",option+1) == 0)
6960 {
6961 if (*option == '+')
6962 {
6963 (void) SetImageOption(image_info,option+1,"undefined");
6964 break;
6965 }
6966 (void) SetImageOption(image_info,option+1,argv[i+1]);
6967 break;
6968 }
6969 if (LocaleCompare("dither",option+1) == 0)
6970 {
6971 if (*option == '+')
6972 {
6973 image_info->dither=MagickFalse;
6974 (void) SetImageOption(image_info,option+1,"none");
6975 break;
6976 }
6977 (void) SetImageOption(image_info,option+1,argv[i+1]);
6978 image_info->dither=MagickTrue;
6979 break;
6980 }
6981 break;
6982 }
6983 case 'e':
6984 {
6985 if (LocaleCompare("encoding",option+1) == 0)
6986 {
6987 if (*option == '+')
6988 {
6989 (void) SetImageOption(image_info,option+1,"undefined");
6990 break;
6991 }
6992 (void) SetImageOption(image_info,option+1,argv[i+1]);
6993 break;
6994 }
6995 if (LocaleCompare("endian",option+1) == 0)
6996 {
6997 if (*option == '+')
6998 {
6999 image_info->endian=UndefinedEndian;
7000 (void) SetImageOption(image_info,option+1,"undefined");
7001 break;
7002 }
7003 image_info->endian=(EndianType) ParseCommandOption(
7004 MagickEndianOptions,MagickFalse,argv[i+1]);
7005 (void) SetImageOption(image_info,option+1,argv[i+1]);
7006 break;
7007 }
7008 if (LocaleCompare("extract",option+1) == 0)
7009 {
7010 /*
7011 Set image extract geometry.
7012 */
7013 if (*option == '+')
7014 {
7015 if (image_info->extract != (char *) NULL)
7016 image_info->extract=DestroyString(image_info->extract);
7017 break;
7018 }
7019 (void) CloneString(&image_info->extract,argv[i+1]);
7020 break;
7021 }
7022 break;
7023 }
7024 case 'f':
7025 {
7026 if (LocaleCompare("family",option+1) == 0)
7027 {
7028 if (*option != '+')
7029 (void) SetImageOption(image_info,option+1,argv[i+1]);
7030 break;
7031 }
7032 if (LocaleCompare("fill",option+1) == 0)
7033 {
7034 if (*option == '+')
7035 {
7036 (void) SetImageOption(image_info,option+1,"none");
7037 break;
7038 }
7039 (void) SetImageOption(image_info,option+1,argv[i+1]);
7040 break;
7041 }
7042 if (LocaleCompare("filter",option+1) == 0)
7043 {
7044 if (*option == '+')
7045 {
7046 (void) SetImageOption(image_info,option+1,"undefined");
7047 break;
7048 }
7049 (void) SetImageOption(image_info,option+1,argv[i+1]);
7050 break;
7051 }
7052 if (LocaleCompare("font",option+1) == 0)
7053 {
7054 if (*option == '+')
7055 {
7056 if (image_info->font != (char *) NULL)
7057 image_info->font=DestroyString(image_info->font);
7058 break;
7059 }
7060 (void) CloneString(&image_info->font,argv[i+1]);
7061 break;
7062 }
7063 if (LocaleCompare("format",option+1) == 0)
7064 {
7065 (void) SetImageOption(image_info,option+1,argv[i+1]);
7066 break;
7067 }
7068 if (LocaleCompare("fuzz",option+1) == 0)
7069 {
7070 if (*option == '+')
7071 {
7072 image_info->fuzz=0.0;
7073 (void) SetImageOption(image_info,option+1,"0");
7074 break;
7075 }
7076 image_info->fuzz=StringToDoubleInterval(argv[i+1],(double)
7077 QuantumRange+1.0);
7078 (void) SetImageOption(image_info,option+1,argv[i+1]);
7079 break;
7080 }
7081 break;
7082 }
7083 case 'g':
7084 {
7085 if (LocaleCompare("gravity",option+1) == 0)
7086 {
7087 if (*option == '+')
7088 {
7089 (void) SetImageOption(image_info,option+1,"undefined");
7090 break;
7091 }
7092 (void) SetImageOption(image_info,option+1,argv[i+1]);
7093 break;
7094 }
7095 if (LocaleCompare("green-primary",option+1) == 0)
7096 {
7097 if (*option == '+')
7098 {
7099 (void) SetImageOption(image_info,option+1,"0.0");
7100 break;
7101 }
7102 (void) SetImageOption(image_info,option+1,argv[i+1]);
7103 break;
7104 }
7105 break;
7106 }
7107 case 'i':
7108 {
7109 if (LocaleCompare("intensity",option+1) == 0)
7110 {
7111 if (*option == '+')
7112 {
7113 (void) SetImageOption(image_info,option+1,"undefined");
7114 break;
7115 }
7116 (void) SetImageOption(image_info,option+1,argv[i+1]);
7117 break;
7118 }
7119 if (LocaleCompare("intent",option+1) == 0)
7120 {
7121 if (*option == '+')
7122 {
7123 (void) SetImageOption(image_info,option+1,"undefined");
7124 break;
7125 }
7126 (void) SetImageOption(image_info,option+1,argv[i+1]);
7127 break;
7128 }
7129 if (LocaleCompare("interlace",option+1) == 0)
7130 {
7131 if (*option == '+')
7132 {
7133 image_info->interlace=UndefinedInterlace;
7134 (void) SetImageOption(image_info,option+1,"undefined");
7135 break;
7136 }
7137 image_info->interlace=(InterlaceType) ParseCommandOption(
7138 MagickInterlaceOptions,MagickFalse,argv[i+1]);
7139 (void) SetImageOption(image_info,option+1,argv[i+1]);
7140 break;
7141 }
7142 if (LocaleCompare("interline-spacing",option+1) == 0)
7143 {
7144 if (*option == '+')
7145 {
7146 (void) SetImageOption(image_info,option+1,"undefined");
7147 break;
7148 }
7149 (void) SetImageOption(image_info,option+1,argv[i+1]);
7150 break;
7151 }
7152 if (LocaleCompare("interpolate",option+1) == 0)
7153 {
7154 if (*option == '+')
7155 {
7156 (void) SetImageOption(image_info,option+1,"undefined");
7157 break;
7158 }
7159 (void) SetImageOption(image_info,option+1,argv[i+1]);
7160 break;
7161 }
7162 if (LocaleCompare("interword-spacing",option+1) == 0)
7163 {
7164 if (*option == '+')
7165 {
7166 (void) SetImageOption(image_info,option+1,"undefined");
7167 break;
7168 }
7169 (void) SetImageOption(image_info,option+1,argv[i+1]);
7170 break;
7171 }
7172 break;
7173 }
7174 case 'k':
7175 {
7176 if (LocaleCompare("kerning",option+1) == 0)
7177 {
7178 if (*option == '+')
7179 {
7180 (void) SetImageOption(image_info,option+1,"undefined");
7181 break;
7182 }
7183 (void) SetImageOption(image_info,option+1,argv[i+1]);
7184 break;
7185 }
7186 break;
7187 }
7188 case 'l':
7189 {
7190 if (LocaleCompare("label",option+1) == 0)
7191 {
7192 if (*option == '+')
7193 {
7194 (void) DeleteImageOption(image_info,option+1);
7195 break;
7196 }
7197 (void) SetImageOption(image_info,option+1,argv[i+1]);
7198 break;
7199 }
7200 if (LocaleCompare("limit",option+1) == 0)
7201 {
7202 MagickSizeType
7203 limit;
7204
7205 ResourceType
7206 type;
7207
7208 if (*option == '+')
7209 break;
7210 type=(ResourceType) ParseCommandOption(MagickResourceOptions,
7211 MagickFalse,argv[i+1]);
7212 limit=MagickResourceInfinity;
7213 if (LocaleCompare("unlimited",argv[i+2]) != 0)
7214 limit=(MagickSizeType) SiPrefixToDoubleInterval(argv[i+2],100.0);
7215 if (type == TimeResource)
7216 limit=(MagickSizeType) ParseMagickTimeToLive(argv[i+2]);
7217 (void) SetMagickResourceLimit(type,limit);
7218 break;
7219 }
7220 if (LocaleCompare("list",option+1) == 0)
7221 {
7222 ssize_t
7223 list;
7224
7225 /*
7226 Display configuration list.
7227 */
7228 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i+1]);
7229 switch (list)
7230 {
7231 case MagickCoderOptions:
7232 {
7233 (void) ListCoderInfo((FILE *) NULL,exception);
7234 break;
7235 }
7236 case MagickColorOptions:
7237 {
7238 (void) ListColorInfo((FILE *) NULL,exception);
7239 break;
7240 }
7241 case MagickConfigureOptions:
7242 {
7243 (void) ListConfigureInfo((FILE *) NULL,exception);
7244 break;
7245 }
7246 case MagickDelegateOptions:
7247 {
7248 (void) ListDelegateInfo((FILE *) NULL,exception);
7249 break;
7250 }
7251 case MagickFontOptions:
7252 {
7253 (void) ListTypeInfo((FILE *) NULL,exception);
7254 break;
7255 }
7256 case MagickFormatOptions:
7257 {
7258 (void) ListMagickInfo((FILE *) NULL,exception);
7259 break;
7260 }
7261 case MagickLocaleOptions:
7262 {
7263 (void) ListLocaleInfo((FILE *) NULL,exception);
7264 break;
7265 }
7266 case MagickLogOptions:
7267 {
7268 (void) ListLogInfo((FILE *) NULL,exception);
7269 break;
7270 }
7271 case MagickMagicOptions:
7272 {
7273 (void) ListMagicInfo((FILE *) NULL,exception);
7274 break;
7275 }
7276 case MagickMimeOptions:
7277 {
7278 (void) ListMimeInfo((FILE *) NULL,exception);
7279 break;
7280 }
7281 case MagickModuleOptions:
7282 {
7283 (void) ListModuleInfo((FILE *) NULL,exception);
7284 break;
7285 }
7286 case MagickPagesizeOptions:
7287 {
7288 (void) ListPagesizes((FILE *) NULL,exception);
7289 break;
7290 }
7291 case MagickPolicyOptions:
7292 {
7293 (void) ListPolicyInfo((FILE *) NULL,exception);
7294 break;
7295 }
7296 case MagickResourceOptions:
7297 {
7298 (void) ListMagickResourceInfo((FILE *) NULL,exception);
7299 break;
7300 }
7301 case MagickThresholdOptions:
7302 {
7303 (void) ListThresholdMaps((FILE *) NULL,exception);
7304 break;
7305 }
7306 default:
7307 {
7308 (void) ListCommandOptions((FILE *) NULL,(CommandOption) list,
7309 exception);
7310 break;
7311 }
7312 }
7313 break;
7314 }
7315 if (LocaleCompare("log",option+1) == 0)
7316 {
7317 if (*option == '+')
7318 break;
7319 (void) SetLogFormat(argv[i+1]);
7320 break;
7321 }
7322 if (LocaleCompare("loop",option+1) == 0)
7323 {
7324 if (*option == '+')
7325 {
7326 (void) SetImageOption(image_info,option+1,"0");
7327 break;
7328 }
7329 (void) SetImageOption(image_info,option+1,argv[i+1]);
7330 break;
7331 }
7332 break;
7333 }
7334 case 'm':
7335 {
7336 if (LocaleCompare("matte",option+1) == 0)
7337 {
7338 if (*option == '+')
7339 {
7340 (void) SetImageOption(image_info,option+1,"false");
7341 break;
7342 }
7343 (void) SetImageOption(image_info,option+1,"true");
7344 break;
7345 }
7346 if (LocaleCompare("mattecolor",option+1) == 0)
7347 {
7348 if (*option == '+')
7349 {
7350 (void) SetImageOption(image_info,option+1,argv[i+1]);
7351 (void) QueryColorCompliance(MogrifyAlphaColor,AllCompliance,
7352 &image_info->matte_color,exception);
7353 break;
7354 }
7355 (void) SetImageOption(image_info,option+1,argv[i+1]);
7356 (void) QueryColorCompliance(argv[i+1],AllCompliance,
7357 &image_info->matte_color,exception);
7358 break;
7359 }
7360 if (LocaleCompare("metric",option+1) == 0)
7361 {
7362 if (*option == '+')
7363 (void) DeleteImageOption(image_info,option+1);
7364 else
7365 (void) SetImageOption(image_info,option+1,argv[i+1]);
7366 break;
7367 }
7368 if (LocaleCompare("monitor",option+1) == 0)
7369 {
7370 (void) SetImageInfoProgressMonitor(image_info,MonitorProgress,
7371 (void *) NULL);
7372 break;
7373 }
7374 if (LocaleCompare("monochrome",option+1) == 0)
7375 {
7376 image_info->monochrome=(*option == '-') ? MagickTrue : MagickFalse;
7377 break;
7378 }
7379 break;
7380 }
7381 case 'o':
7382 {
7383 if (LocaleCompare("orient",option+1) == 0)
7384 {
7385 if (*option == '+')
7386 {
7387 image_info->orientation=UndefinedOrientation;
7388 (void) SetImageOption(image_info,option+1,"undefined");
7389 break;
7390 }
7391 image_info->orientation=(OrientationType) ParseCommandOption(
7392 MagickOrientationOptions,MagickFalse,argv[i+1]);
7393 (void) SetImageOption(image_info,option+1,argv[i+1]);
7394 break;
7395 }
7396 break;
7397 }
7398 case 'p':
7399 {
7400 if (LocaleCompare("page",option+1) == 0)
7401 {
7402 char
7403 *canonical_page,
7404 page[MagickPathExtent];
7405
7406 const char
7407 *image_option;
7408
7409 MagickStatusType
7410 flags;
7411
7412 RectangleInfo
7413 geometry;
7414
7415 if (*option == '+')
7416 {
7417 (void) DeleteImageOption(image_info,option+1);
7418 (void) CloneString(&image_info->page,(char *) NULL);
7419 break;
7420 }
7421 (void) memset(&geometry,0,sizeof(geometry));
7422 image_option=GetImageOption(image_info,"page");
7423 if (image_option != (const char *) NULL)
7424 flags=ParseAbsoluteGeometry(image_option,&geometry);
7425 canonical_page=GetPageGeometry(argv[i+1]);
7426 flags=ParseAbsoluteGeometry(canonical_page,&geometry);
7427 canonical_page=DestroyString(canonical_page);
7428 (void) FormatLocaleString(page,MagickPathExtent,"%lux%lu",
7429 (unsigned long) geometry.width,(unsigned long) geometry.height);
7430 if (((flags & XValue) != 0) || ((flags & YValue) != 0))
7431 (void) FormatLocaleString(page,MagickPathExtent,"%lux%lu%+ld%+ld",
7432 (unsigned long) geometry.width,(unsigned long) geometry.height,
7433 (long) geometry.x,(long) geometry.y);
7434 (void) SetImageOption(image_info,option+1,page);
7435 (void) CloneString(&image_info->page,page);
7436 break;
7437 }
7438 if (LocaleCompare("ping",option+1) == 0)
7439 {
7440 image_info->ping=(*option == '-') ? MagickTrue : MagickFalse;
7441 break;
7442 }
7443 if (LocaleCompare("pointsize",option+1) == 0)
7444 {
7445 if (*option == '+')
7446 geometry_info.rho=0.0;
7447 else
7448 (void) ParseGeometry(argv[i+1],&geometry_info);
7449 image_info->pointsize=geometry_info.rho;
7450 break;
7451 }
7452 if (LocaleCompare("precision",option+1) == 0)
7453 {
7454 (void) SetMagickPrecision(StringToInteger(argv[i+1]));
7455 break;
7456 }
7457 break;
7458 }
7459 case 'q':
7460 {
7461 if (LocaleCompare("quality",option+1) == 0)
7462 {
7463 /*
7464 Set image compression quality.
7465 */
7466 if (*option == '+')
7467 {
7468 image_info->quality=UndefinedCompressionQuality;
7469 (void) SetImageOption(image_info,option+1,"0");
7470 break;
7471 }
7472 image_info->quality=StringToUnsignedLong(argv[i+1]);
7473 (void) SetImageOption(image_info,option+1,argv[i+1]);
7474 break;
7475 }
7476 if (LocaleCompare("quiet",option+1) == 0)
7477 {
7478 static WarningHandler
7479 warning_handler = (WarningHandler) NULL;
7480
7481 if (*option == '+')
7482 {
7483 /*
7484 Restore error or warning messages.
7485 */
7486 warning_handler=SetWarningHandler(warning_handler);
7487 break;
7488 }
7489 /*
7490 Suppress error or warning messages.
7491 */
7492 warning_handler=SetWarningHandler((WarningHandler) NULL);
7493 break;
7494 }
7495 break;
7496 }
7497 case 'r':
7498 {
7499 if (LocaleCompare("red-primary",option+1) == 0)
7500 {
7501 if (*option == '+')
7502 {
7503 (void) SetImageOption(image_info,option+1,"0.0");
7504 break;
7505 }
7506 (void) SetImageOption(image_info,option+1,argv[i+1]);
7507 break;
7508 }
7509 break;
7510 }
7511 case 's':
7512 {
7513 if (LocaleCompare("sampling-factor",option+1) == 0)
7514 {
7515 /*
7516 Set image sampling factor.
7517 */
7518 if (*option == '+')
7519 {
7520 if (image_info->sampling_factor != (char *) NULL)
7521 image_info->sampling_factor=DestroyString(
7522 image_info->sampling_factor);
7523 break;
7524 }
7525 (void) CloneString(&image_info->sampling_factor,argv[i+1]);
7526 break;
7527 }
7528 if (LocaleCompare("scene",option+1) == 0)
7529 {
7530 /*
7531 Set image scene.
7532 */
7533 if (*option == '+')
7534 {
7535 image_info->scene=0;
7536 (void) SetImageOption(image_info,option+1,"0");
7537 break;
7538 }
7539 image_info->scene=StringToUnsignedLong(argv[i+1]);
7540 (void) SetImageOption(image_info,option+1,argv[i+1]);
7541 break;
7542 }
7543 if (LocaleCompare("seed",option+1) == 0)
7544 {
7545 unsigned long
7546 seed;
7547
7548 if (*option == '+')
7549 {
7550 seed=(unsigned long) time((time_t *) NULL);
7551 SetRandomSecretKey(seed);
7552 break;
7553 }
7554 seed=StringToUnsignedLong(argv[i+1]);
7555 SetRandomSecretKey(seed);
7556 break;
7557 }
7558 if (LocaleCompare("size",option+1) == 0)
7559 {
7560 if (*option == '+')
7561 {
7562 if (image_info->size != (char *) NULL)
7563 image_info->size=DestroyString(image_info->size);
7564 break;
7565 }
7566 (void) CloneString(&image_info->size,argv[i+1]);
7567 break;
7568 }
7569 if (LocaleCompare("stroke",option+1) == 0)
7570 {
7571 if (*option == '+')
7572 {
7573 (void) SetImageOption(image_info,option+1,"none");
7574 break;
7575 }
7576 (void) SetImageOption(image_info,option+1,argv[i+1]);
7577 break;
7578 }
7579 if (LocaleCompare("strokewidth",option+1) == 0)
7580 {
7581 if (*option == '+')
7582 (void) SetImageOption(image_info,option+1,"0");
7583 else
7584 (void) SetImageOption(image_info,option+1,argv[i+1]);
7585 break;
7586 }
7587 if (LocaleCompare("style",option+1) == 0)
7588 {
7589 if (*option == '+')
7590 {
7591 (void) SetImageOption(image_info,option+1,"none");
7592 break;
7593 }
7594 (void) SetImageOption(image_info,option+1,argv[i+1]);
7595 break;
7596 }
7597 if (LocaleCompare("synchronize",option+1) == 0)
7598 {
7599 if (*option == '+')
7600 {
7601 image_info->synchronize=MagickFalse;
7602 break;
7603 }
7604 image_info->synchronize=MagickTrue;
7605 break;
7606 }
7607 break;
7608 }
7609 case 't':
7610 {
7611 if (LocaleCompare("taint",option+1) == 0)
7612 {
7613 if (*option == '+')
7614 {
7615 (void) SetImageOption(image_info,option+1,"false");
7616 break;
7617 }
7618 (void) SetImageOption(image_info,option+1,"true");
7619 break;
7620 }
7621 if (LocaleCompare("texture",option+1) == 0)
7622 {
7623 if (*option == '+')
7624 {
7625 if (image_info->texture != (char *) NULL)
7626 image_info->texture=DestroyString(image_info->texture);
7627 break;
7628 }
7629 (void) CloneString(&image_info->texture,argv[i+1]);
7630 break;
7631 }
7632 if (LocaleCompare("tile-offset",option+1) == 0)
7633 {
7634 if (*option == '+')
7635 (void) SetImageOption(image_info,option+1,"0");
7636 else
7637 (void) SetImageOption(image_info,option+1,argv[i+1]);
7638 break;
7639 }
7640 if (LocaleCompare("transparent-color",option+1) == 0)
7641 {
7642 if (*option == '+')
7643 {
7644 (void) QueryColorCompliance("none",AllCompliance,
7645 &image_info->transparent_color,exception);
7646 (void) SetImageOption(image_info,option+1,"none");
7647 break;
7648 }
7649 (void) QueryColorCompliance(argv[i+1],AllCompliance,
7650 &image_info->transparent_color,exception);
7651 (void) SetImageOption(image_info,option+1,argv[i+1]);
7652 break;
7653 }
7654 if (LocaleCompare("type",option+1) == 0)
7655 {
7656 if (*option == '+')
7657 {
7658 image_info->type=UndefinedType;
7659 (void) SetImageOption(image_info,option+1,"undefined");
7660 break;
7661 }
7662 image_info->type=(ImageType) ParseCommandOption(MagickTypeOptions,
7663 MagickFalse,argv[i+1]);
7664 (void) SetImageOption(image_info,option+1,argv[i+1]);
7665 break;
7666 }
7667 break;
7668 }
7669 case 'u':
7670 {
7671 if (LocaleCompare("undercolor",option+1) == 0)
7672 {
7673 if (*option == '+')
7674 (void) DeleteImageOption(image_info,option+1);
7675 else
7676 (void) SetImageOption(image_info,option+1,argv[i+1]);
7677 break;
7678 }
7679 if (LocaleCompare("units",option+1) == 0)
7680 {
7681 if (*option == '+')
7682 {
7683 image_info->units=UndefinedResolution;
7684 (void) SetImageOption(image_info,option+1,"undefined");
7685 break;
7686 }
7687 image_info->units=(ResolutionType) ParseCommandOption(
7688 MagickResolutionOptions,MagickFalse,argv[i+1]);
7689 (void) SetImageOption(image_info,option+1,argv[i+1]);
7690 break;
7691 }
7692 break;
7693 }
7694 case 'v':
7695 {
7696 if (LocaleCompare("verbose",option+1) == 0)
7697 {
7698 if (*option == '+')
7699 {
7700 image_info->verbose=MagickFalse;
7701 break;
7702 }
7703 image_info->verbose=MagickTrue;
7704 image_info->ping=MagickFalse;
7705 break;
7706 }
7707 if (LocaleCompare("virtual-pixel",option+1) == 0)
7708 {
7709 if (*option == '+')
7710 (void) SetImageOption(image_info,option+1,"undefined");
7711 else
7712 (void) SetImageOption(image_info,option+1,argv[i+1]);
7713 break;
7714 }
7715 break;
7716 }
7717 case 'w':
7718 {
7719 if (LocaleCompare("weight",option+1) == 0)
7720 {
7721 if (*option == '+')
7722 (void) SetImageOption(image_info,option+1,"0");
7723 else
7724 (void) SetImageOption(image_info,option+1,argv[i+1]);
7725 break;
7726 }
7727 if (LocaleCompare("white-point",option+1) == 0)
7728 {
7729 if (*option == '+')
7730 (void) SetImageOption(image_info,option+1,"0.0");
7731 else
7732 (void) SetImageOption(image_info,option+1,argv[i+1]);
7733 break;
7734 }
7735 if (LocaleCompare("word-break",option+1) == 0)
7736 {
7737 if (*option == '+')
7738 {
7739 (void) SetImageOption(image_info,option+1,"undefined");
7740 break;
7741 }
7742 (void) SetImageOption(image_info,option+1,argv[i+1]);
7743 break;
7744 }
7745 break;
7746 }
7747 default:
7748 break;
7749 }
7750 i+=count;
7751 }
7752 return(MagickTrue);
7753}
7754␌
7755/*
7756%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7757% %
7758% %
7759% %
7760+ M o g r i f y I m a g e L i s t %
7761% %
7762% %
7763% %
7764%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7765%
7766% MogrifyImageList() applies any command line options that might affect the
7767% entire image list (e.g. -append, -coalesce, etc.).
7768%
7769% The format of the MogrifyImage method is:
7770%
7771% MagickBooleanType MogrifyImageList(ImageInfo *image_info,const int argc,
7772% const char **argv,Image **images,ExceptionInfo *exception)
7773%
7774% A description of each parameter follows:
7775%
7776% o image_info: the image info..
7777%
7778% o argc: Specifies a pointer to an integer describing the number of
7779% elements in the argument vector.
7780%
7781% o argv: Specifies a pointer to a text array containing the command line
7782% arguments.
7783%
7784% o images: pointer to pointer of the first image in image list.
7785%
7786% o exception: return any errors or warnings in this structure.
7787%
7788*/
7789WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
7790 const int argc,const char **argv,Image **images,ExceptionInfo *exception)
7791{
7792 const char
7793 *option;
7794
7795 ImageInfo
7796 *mogrify_info;
7797
7798 MagickStatusType
7799 status;
7800
7801 PixelInterpolateMethod
7802 interpolate_method;
7803
7804 QuantizeInfo
7805 *quantize_info;
7806
7807 ssize_t
7808 i;
7809
7810 ssize_t
7811 count,
7812 index;
7813
7814 /*
7815 Apply options to the image list.
7816 */
7817 assert(image_info != (ImageInfo *) NULL);
7818 assert(image_info->signature == MagickCoreSignature);
7819 assert(images != (Image **) NULL);
7820 assert((*images)->previous == (Image *) NULL);
7821 assert((*images)->signature == MagickCoreSignature);
7822 if (IsEventLogging() != MagickFalse)
7823 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
7824 (*images)->filename);
7825 if ((argc <= 0) || (*argv == (char *) NULL))
7826 return(MagickTrue);
7827 interpolate_method=UndefinedInterpolatePixel;
7828 mogrify_info=CloneImageInfo(image_info);
7829 quantize_info=AcquireQuantizeInfo(mogrify_info);
7830 status=MagickTrue;
7831 for (i=0; i < (ssize_t) argc; i++)
7832 {
7833 if (*images == (Image *) NULL)
7834 break;
7835 option=argv[i];
7836 if (IsCommandOption(option) == MagickFalse)
7837 continue;
7838 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
7839 count=MagickMax(count,0L);
7840 if ((i+count) >= (ssize_t) argc)
7841 break;
7842 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception);
7843 switch (*(option+1))
7844 {
7845 case 'a':
7846 {
7847 if (LocaleCompare("affinity",option+1) == 0)
7848 {
7849 (void) SyncImagesSettings(mogrify_info,*images,exception);
7850 if (*option == '+')
7851 {
7852 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7853 exception);
7854 break;
7855 }
7856 i++;
7857 break;
7858 }
7859 if (LocaleCompare("append",option+1) == 0)
7860 {
7861 Image
7862 *append_image;
7863
7864 (void) SyncImagesSettings(mogrify_info,*images,exception);
7865 append_image=AppendImages(*images,*option == '-' ? MagickTrue :
7866 MagickFalse,exception);
7867 if (append_image == (Image *) NULL)
7868 {
7869 status=MagickFalse;
7870 break;
7871 }
7872 *images=DestroyImageList(*images);
7873 *images=append_image;
7874 break;
7875 }
7876 if (LocaleCompare("average",option+1) == 0)
7877 {
7878 Image
7879 *average_image;
7880
7881 /*
7882 Average an image sequence (deprecated).
7883 */
7884 (void) SyncImagesSettings(mogrify_info,*images,exception);
7885 average_image=EvaluateImages(*images,MeanEvaluateOperator,
7886 exception);
7887 if (average_image == (Image *) NULL)
7888 {
7889 status=MagickFalse;
7890 break;
7891 }
7892 *images=DestroyImageList(*images);
7893 *images=average_image;
7894 break;
7895 }
7896 break;
7897 }
7898 case 'c':
7899 {
7900 if (LocaleCompare("channel-fx",option+1) == 0)
7901 {
7902 Image
7903 *channel_image;
7904
7905 (void) SyncImagesSettings(mogrify_info,*images,exception);
7906 channel_image=ChannelFxImage(*images,argv[i+1],exception);
7907 if (channel_image == (Image *) NULL)
7908 {
7909 status=MagickFalse;
7910 break;
7911 }
7912 *images=DestroyImageList(*images);
7913 *images=channel_image;
7914 break;
7915 }
7916 if (LocaleCompare("clut",option+1) == 0)
7917 {
7918 Image
7919 *clut_image,
7920 *image;
7921
7922 (void) SyncImagesSettings(mogrify_info,*images,exception);
7923 image=RemoveFirstImageFromList(images);
7924 clut_image=RemoveFirstImageFromList(images);
7925 if (clut_image == (Image *) NULL)
7926 {
7927 (void) ThrowMagickException(exception,GetMagickModule(),
7928 OptionError,"ImageSequenceRequired","`%s'",option);
7929 image=DestroyImage(image);
7930 status=MagickFalse;
7931 break;
7932 }
7933 (void) ClutImage(image,clut_image,interpolate_method,exception);
7934 clut_image=DestroyImage(clut_image);
7935 *images=DestroyImageList(*images);
7936 *images=image;
7937 break;
7938 }
7939 if (LocaleCompare("coalesce",option+1) == 0)
7940 {
7941 Image
7942 *coalesce_image;
7943
7944 (void) SyncImagesSettings(mogrify_info,*images,exception);
7945 coalesce_image=CoalesceImages(*images,exception);
7946 if (coalesce_image == (Image *) NULL)
7947 {
7948 status=MagickFalse;
7949 break;
7950 }
7951 *images=DestroyImageList(*images);
7952 *images=coalesce_image;
7953 break;
7954 }
7955 if (LocaleCompare("combine",option+1) == 0)
7956 {
7957 ColorspaceType
7958 colorspace;
7959
7960 Image
7961 *combine_image;
7962
7963 (void) SyncImagesSettings(mogrify_info,*images,exception);
7964 colorspace=(*images)->colorspace;
7965 if ((*images)->number_channels < GetImageListLength(*images))
7966 colorspace=sRGBColorspace;
7967 if (*option == '+')
7968 colorspace=(ColorspaceType) ParseCommandOption(
7969 MagickColorspaceOptions,MagickFalse,argv[i+1]);
7970 combine_image=CombineImages(*images,colorspace,exception);
7971 if (combine_image == (Image *) NULL)
7972 {
7973 status=MagickFalse;
7974 break;
7975 }
7976 *images=DestroyImageList(*images);
7977 *images=combine_image;
7978 break;
7979 }
7980 if (LocaleCompare("compare",option+1) == 0)
7981 {
7982 double
7983 distortion;
7984
7985 Image
7986 *difference_image,
7987 *image,
7988 *reconstruct_image;
7989
7990 MetricType
7991 metric;
7992
7993 /*
7994 Mathematically and visually annotate the difference between an
7995 image and its reconstruction.
7996 */
7997 (void) SyncImagesSettings(mogrify_info,*images,exception);
7998 image=RemoveFirstImageFromList(images);
7999 reconstruct_image=RemoveFirstImageFromList(images);
8000 if (reconstruct_image == (Image *) NULL)
8001 {
8002 (void) ThrowMagickException(exception,GetMagickModule(),
8003 OptionError,"ImageSequenceRequired","`%s'",option);
8004 image=DestroyImage(image);
8005 status=MagickFalse;
8006 break;
8007 }
8008 metric=UndefinedErrorMetric;
8009 option=GetImageOption(mogrify_info,"metric");
8010 if (option != (const char *) NULL)
8011 metric=(MetricType) ParseCommandOption(MagickMetricOptions,
8012 MagickFalse,option);
8013 difference_image=CompareImages(image,reconstruct_image,metric,
8014 &distortion,exception);
8015 if (difference_image == (Image *) NULL)
8016 break;
8017 reconstruct_image=DestroyImage(reconstruct_image);
8018 image=DestroyImage(image);
8019 if (*images != (Image *) NULL)
8020 *images=DestroyImageList(*images);
8021 *images=difference_image;
8022 break;
8023 }
8024 if (LocaleCompare("complex",option+1) == 0)
8025 {
8026 ComplexOperator
8027 op;
8028
8029 Image
8030 *complex_images;
8031
8032 (void) SyncImageSettings(mogrify_info,*images,exception);
8033 op=(ComplexOperator) ParseCommandOption(MagickComplexOptions,
8034 MagickFalse,argv[i+1]);
8035 complex_images=ComplexImages(*images,op,exception);
8036 if (complex_images == (Image *) NULL)
8037 {
8038 status=MagickFalse;
8039 break;
8040 }
8041 *images=DestroyImageList(*images);
8042 *images=complex_images;
8043 break;
8044 }
8045 if (LocaleCompare("composite",option+1) == 0)
8046 {
8047 CompositeOperator
8048 compose;
8049
8050 const char*
8051 value;
8052
8053 MagickBooleanType
8054 clip_to_self;
8055
8056 Image
8057 *mask_image,
8058 *new_images,
8059 *source_image;
8060
8061 RectangleInfo
8062 geometry;
8063
8064 /* Compose value from "-compose" option only */
8065 (void) SyncImageSettings(mogrify_info,*images,exception);
8066 value=GetImageOption(mogrify_info,"compose");
8067 if (value == (const char *) NULL)
8068 compose=OverCompositeOp; /* use Over not source_image->compose */
8069 else
8070 compose=(CompositeOperator) ParseCommandOption(
8071 MagickComposeOptions,MagickFalse,value);
8072
8073 /* Get "clip-to-self" expert setting (false is normal) */
8074 clip_to_self=GetCompositeClipToSelf(compose);
8075 value=GetImageOption(mogrify_info,"compose:clip-to-self");
8076 if (value != (const char *) NULL)
8077 clip_to_self=IsStringTrue(value);
8078 value=GetImageOption(mogrify_info,"compose:outside-overlay");
8079 if (value != (const char *) NULL)
8080 clip_to_self=IsStringFalse(value); /* deprecated */
8081
8082 new_images=RemoveFirstImageFromList(images);
8083 source_image=RemoveFirstImageFromList(images);
8084 if (source_image == (Image *) NULL)
8085 {
8086 (void) ThrowMagickException(exception,GetMagickModule(),
8087 OptionError,"ImageSequenceRequired","`%s'",option);
8088 new_images=DestroyImage(new_images);
8089 status=MagickFalse;
8090 break;
8091 }
8092
8093 /* FUTURE: this should not be here! - should be part of -geometry */
8094 if (source_image->geometry != (char *) NULL)
8095 {
8096 RectangleInfo
8097 resize_geometry;
8098
8099 (void) ParseRegionGeometry(source_image,source_image->geometry,
8100 &resize_geometry,exception);
8101 if ((source_image->columns != resize_geometry.width) ||
8102 (source_image->rows != resize_geometry.height))
8103 {
8104 Image
8105 *resize_image;
8106
8107 resize_image=ResizeImage(source_image,resize_geometry.width,
8108 resize_geometry.height,source_image->filter,exception);
8109 if (resize_image != (Image *) NULL)
8110 {
8111 source_image=DestroyImage(source_image);
8112 source_image=resize_image;
8113 }
8114 }
8115 }
8116 SetGeometry(source_image,&geometry);
8117 (void) ParseAbsoluteGeometry(source_image->geometry,&geometry);
8118 GravityAdjustGeometry(new_images->columns,new_images->rows,
8119 new_images->gravity,&geometry);
8120 mask_image=RemoveFirstImageFromList(images);
8121 if (mask_image == (Image *) NULL)
8122 status&=(MagickStatusType) CompositeImage(new_images,source_image,
8123 compose,clip_to_self,geometry.x,geometry.y,exception);
8124 else
8125 {
8126 Image
8127 *canvas_image;
8128
8129 canvas_image=CloneImage(new_images,0,0,MagickTrue,exception);
8130 if (canvas_image == (Image *) NULL)
8131 break;
8132 switch (compose)
8133 {
8134 case BlendCompositeOp:
8135 {
8136 status&=(MagickStatusType) CompositeImage(new_images,
8137 source_image,compose,clip_to_self,geometry.x,geometry.y,
8138 exception);
8139 status&=(MagickStatusType) CompositeImage(new_images,
8140 mask_image,CopyAlphaCompositeOp,MagickTrue,0,0,exception);
8141 break;
8142 }
8143 case DisplaceCompositeOp:
8144 case DistortCompositeOp:
8145 {
8146 status&=(MagickStatusType) CompositeImage(source_image,
8147 mask_image,CopyGreenCompositeOp,MagickTrue,0,0,exception);
8148 (void) SetImageColorspace(source_image,sRGBColorspace,
8149 exception);
8150 status&=(MagickStatusType) CompositeImage(new_images,
8151 source_image,compose,clip_to_self,geometry.x,geometry.y,
8152 exception);
8153 break;
8154 }
8155 case SaliencyBlendCompositeOp:
8156 case SeamlessBlendCompositeOp:
8157 {
8158 status&=(MagickStatusType) CompositeImage(source_image,
8159 mask_image,CopyAlphaCompositeOp,MagickTrue,0,0,exception);
8160 status&=(MagickStatusType) CompositeImage(new_images,
8161 source_image,compose,clip_to_self,geometry.x,geometry.y,
8162 exception);
8163 break;
8164 }
8165 default:
8166 {
8167 Image
8168 *clone_image;
8169
8170 clone_image=CloneImage(new_images,0,0,MagickTrue,exception);
8171 if (clone_image == (Image *) NULL)
8172 break;
8173 status&=(MagickStatusType) CompositeImage(new_images,
8174 source_image,compose,clip_to_self,geometry.x,geometry.y,
8175 exception);
8176 status&=(MagickStatusType) CompositeImage(new_images,
8177 mask_image,CopyAlphaCompositeOp,MagickTrue,0,0,exception);
8178 status&=(MagickStatusType) CompositeImage(clone_image,
8179 new_images,OverCompositeOp,clip_to_self,0,0,exception);
8180 new_images=DestroyImageList(new_images);
8181 new_images=clone_image;
8182 break;
8183 }
8184 }
8185 switch (compose)
8186 {
8187 case DisplaceCompositeOp:
8188 case DistortCompositeOp:
8189 {
8190 status&=(MagickStatusType) CompositeImage(canvas_image,
8191 new_images,CopyCompositeOp,clip_to_self,0,0,exception);
8192 break;
8193 }
8194 default:
8195 {
8196 status&=(MagickStatusType) CompositeImage(canvas_image,
8197 new_images,OverCompositeOp,clip_to_self,0,0,exception);
8198 break;
8199 }
8200 }
8201 new_images=DestroyImageList(new_images);
8202 new_images=canvas_image;
8203 mask_image=DestroyImage(mask_image);
8204 }
8205 source_image=DestroyImage(source_image);
8206 *images=DestroyImageList(*images);
8207 *images=new_images;
8208 break;
8209 }
8210 if (LocaleCompare("copy",option+1) == 0)
8211 {
8212 Image
8213 *source_image;
8214
8215 OffsetInfo
8216 offset;
8217
8218 RectangleInfo
8219 geometry;
8220
8221 /*
8222 Copy image pixels.
8223 */
8224 (void) SyncImageSettings(mogrify_info,*images,exception);
8225 (void) ParsePageGeometry(*images,argv[i+2],&geometry,exception);
8226 offset.x=geometry.x;
8227 offset.y=geometry.y;
8228 source_image=(*images);
8229 if (source_image->next != (Image *) NULL)
8230 source_image=source_image->next;
8231 (void) ParsePageGeometry(source_image,argv[i+1],&geometry,
8232 exception);
8233 status=CopyImagePixels(*images,source_image,&geometry,&offset,
8234 exception);
8235 break;
8236 }
8237 break;
8238 }
8239 case 'd':
8240 {
8241 if (LocaleCompare("deconstruct",option+1) == 0)
8242 {
8243 Image
8244 *deconstruct_image;
8245
8246 (void) SyncImagesSettings(mogrify_info,*images,exception);
8247 deconstruct_image=CompareImagesLayers(*images,CompareAnyLayer,
8248 exception);
8249 if (deconstruct_image == (Image *) NULL)
8250 {
8251 status=MagickFalse;
8252 break;
8253 }
8254 *images=DestroyImageList(*images);
8255 *images=deconstruct_image;
8256 break;
8257 }
8258 if (LocaleCompare("delete",option+1) == 0)
8259 {
8260 if (*option == '+')
8261 DeleteImages(images,"-1",exception);
8262 else
8263 DeleteImages(images,argv[i+1],exception);
8264 break;
8265 }
8266 if (LocaleCompare("dither",option+1) == 0)
8267 {
8268 if (*option == '+')
8269 {
8270 quantize_info->dither_method=NoDitherMethod;
8271 break;
8272 }
8273 quantize_info->dither_method=(DitherMethod) ParseCommandOption(
8274 MagickDitherOptions,MagickFalse,argv[i+1]);
8275 break;
8276 }
8277 if (LocaleCompare("duplicate",option+1) == 0)
8278 {
8279 Image
8280 *duplicate_images;
8281
8282 if (*option == '+')
8283 duplicate_images=DuplicateImages(*images,1,"-1",exception);
8284 else
8285 {
8286 const char
8287 *p;
8288
8289 size_t
8290 number_duplicates;
8291
8292 number_duplicates=(size_t) StringToLong(argv[i+1]);
8293 p=strchr(argv[i+1],',');
8294 if (p == (const char *) NULL)
8295 duplicate_images=DuplicateImages(*images,number_duplicates,
8296 "-1",exception);
8297 else
8298 duplicate_images=DuplicateImages(*images,number_duplicates,
8299 p+1,exception);
8300 }
8301 AppendImageToList(images, duplicate_images);
8302 (void) SyncImagesSettings(mogrify_info,*images,exception);
8303 break;
8304 }
8305 break;
8306 }
8307 case 'e':
8308 {
8309 if (LocaleCompare("evaluate-sequence",option+1) == 0)
8310 {
8311 Image
8312 *evaluate_image;
8313
8314 MagickEvaluateOperator
8315 op;
8316
8317 (void) SyncImageSettings(mogrify_info,*images,exception);
8318 op=(MagickEvaluateOperator) ParseCommandOption(
8319 MagickEvaluateOptions,MagickFalse,argv[i+1]);
8320 evaluate_image=EvaluateImages(*images,op,exception);
8321 if (evaluate_image == (Image *) NULL)
8322 {
8323 status=MagickFalse;
8324 break;
8325 }
8326 *images=DestroyImageList(*images);
8327 *images=evaluate_image;
8328 break;
8329 }
8330 break;
8331 }
8332 case 'f':
8333 {
8334 if (LocaleCompare("fft",option+1) == 0)
8335 {
8336 Image
8337 *fourier_image;
8338
8339 /*
8340 Implements the discrete Fourier transform (DFT).
8341 */
8342 (void) SyncImageSettings(mogrify_info,*images,exception);
8343 fourier_image=ForwardFourierTransformImage(*images,*option == '-' ?
8344 MagickTrue : MagickFalse,exception);
8345 if (fourier_image == (Image *) NULL)
8346 break;
8347 *images=DestroyImageList(*images);
8348 *images=fourier_image;
8349 break;
8350 }
8351 if (LocaleCompare("flatten",option+1) == 0)
8352 {
8353 Image
8354 *flatten_image;
8355
8356 (void) SyncImagesSettings(mogrify_info,*images,exception);
8357 flatten_image=MergeImageLayers(*images,FlattenLayer,exception);
8358 if (flatten_image == (Image *) NULL)
8359 break;
8360 *images=DestroyImageList(*images);
8361 *images=flatten_image;
8362 break;
8363 }
8364 if (LocaleCompare("fx",option+1) == 0)
8365 {
8366 Image
8367 *fx_image;
8368
8369 (void) SyncImagesSettings(mogrify_info,*images,exception);
8370 fx_image=FxImage(*images,argv[i+1],exception);
8371 if (fx_image == (Image *) NULL)
8372 {
8373 status=MagickFalse;
8374 break;
8375 }
8376 *images=DestroyImageList(*images);
8377 *images=fx_image;
8378 break;
8379 }
8380 break;
8381 }
8382 case 'h':
8383 {
8384 if (LocaleCompare("hald-clut",option+1) == 0)
8385 {
8386 Image
8387 *hald_image,
8388 *image;
8389
8390 (void) SyncImagesSettings(mogrify_info,*images,exception);
8391 image=RemoveFirstImageFromList(images);
8392 hald_image=RemoveFirstImageFromList(images);
8393 if (hald_image == (Image *) NULL)
8394 {
8395 (void) ThrowMagickException(exception,GetMagickModule(),
8396 OptionError,"ImageSequenceRequired","`%s'",option);
8397 image=DestroyImage(image);
8398 status=MagickFalse;
8399 break;
8400 }
8401 (void) HaldClutImage(image,hald_image,exception);
8402 hald_image=DestroyImage(hald_image);
8403 if (*images != (Image *) NULL)
8404 *images=DestroyImageList(*images);
8405 *images=image;
8406 break;
8407 }
8408 break;
8409 }
8410 case 'i':
8411 {
8412 if (LocaleCompare("ift",option+1) == 0)
8413 {
8414 Image
8415 *fourier_image,
8416 *magnitude_image,
8417 *phase_image;
8418
8419 /*
8420 Implements the inverse fourier discrete Fourier transform (DFT).
8421 */
8422 (void) SyncImagesSettings(mogrify_info,*images,exception);
8423 magnitude_image=RemoveFirstImageFromList(images);
8424 phase_image=RemoveFirstImageFromList(images);
8425 if (phase_image == (Image *) NULL)
8426 {
8427 (void) ThrowMagickException(exception,GetMagickModule(),
8428 OptionError,"ImageSequenceRequired","`%s'",option);
8429 magnitude_image=DestroyImage(magnitude_image);
8430 status=MagickFalse;
8431 break;
8432 }
8433 fourier_image=InverseFourierTransformImage(magnitude_image,
8434 phase_image,*option == '-' ? MagickTrue : MagickFalse,exception);
8435 magnitude_image=DestroyImage(magnitude_image);
8436 phase_image=DestroyImage(phase_image);
8437 if (fourier_image == (Image *) NULL)
8438 break;
8439 if (*images != (Image *) NULL)
8440 *images=DestroyImageList(*images);
8441 *images=fourier_image;
8442 break;
8443 }
8444 if (LocaleCompare("insert",option+1) == 0)
8445 {
8446 Image
8447 *p,
8448 *q;
8449
8450 index=0;
8451 if (*option != '+')
8452 index=(ssize_t) StringToLong(argv[i+1]);
8453 p=RemoveLastImageFromList(images);
8454 if (p == (Image *) NULL)
8455 {
8456 (void) ThrowMagickException(exception,GetMagickModule(),
8457 OptionError,"NoSuchImage","`%s'",argv[i+1]);
8458 status=MagickFalse;
8459 break;
8460 }
8461 q=p;
8462 if (index == 0)
8463 PrependImageToList(images,q);
8464 else
8465 if (index == (ssize_t) GetImageListLength(*images))
8466 AppendImageToList(images,q);
8467 else
8468 {
8469 q=GetImageFromList(*images,index-1);
8470 if (q == (Image *) NULL)
8471 {
8472 p=DestroyImage(p);
8473 (void) ThrowMagickException(exception,GetMagickModule(),
8474 OptionError,"NoSuchImage","`%s'",argv[i+1]);
8475 status=MagickFalse;
8476 break;
8477 }
8478 InsertImageInList(&q,p);
8479 }
8480 *images=GetFirstImageInList(q);
8481 break;
8482 }
8483 if (LocaleCompare("interpolate",option+1) == 0)
8484 {
8485 interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
8486 MagickInterpolateOptions,MagickFalse,argv[i+1]);
8487 break;
8488 }
8489 break;
8490 }
8491 case 'l':
8492 {
8493 if (LocaleCompare("layers",option+1) == 0)
8494 {
8495 Image
8496 *layers;
8497
8498 LayerMethod
8499 method;
8500
8501 (void) SyncImagesSettings(mogrify_info,*images,exception);
8502 layers=(Image *) NULL;
8503 method=(LayerMethod) ParseCommandOption(MagickLayerOptions,
8504 MagickFalse,argv[i+1]);
8505 switch (method)
8506 {
8507 case CoalesceLayer:
8508 {
8509 layers=CoalesceImages(*images,exception);
8510 break;
8511 }
8512 case CompareAnyLayer:
8513 case CompareClearLayer:
8514 case CompareOverlayLayer:
8515 default:
8516 {
8517 layers=CompareImagesLayers(*images,method,exception);
8518 break;
8519 }
8520 case MergeLayer:
8521 case FlattenLayer:
8522 case MosaicLayer:
8523 case TrimBoundsLayer:
8524 {
8525 layers=MergeImageLayers(*images,method,exception);
8526 break;
8527 }
8528 case DisposeLayer:
8529 {
8530 layers=DisposeImages(*images,exception);
8531 break;
8532 }
8533 case OptimizeImageLayer:
8534 {
8535 layers=OptimizeImageLayers(*images,exception);
8536 break;
8537 }
8538 case OptimizePlusLayer:
8539 {
8540 layers=OptimizePlusImageLayers(*images,exception);
8541 break;
8542 }
8543 case OptimizeTransLayer:
8544 {
8545 OptimizeImageTransparency(*images,exception);
8546 break;
8547 }
8548 case RemoveDupsLayer:
8549 {
8550 RemoveDuplicateLayers(images,exception);
8551 break;
8552 }
8553 case RemoveZeroLayer:
8554 {
8555 RemoveZeroDelayLayers(images,exception);
8556 break;
8557 }
8558 case OptimizeLayer:
8559 {
8560 /*
8561 General Purpose, GIF Animation Optimizer.
8562 */
8563 layers=CoalesceImages(*images,exception);
8564 if (layers == (Image *) NULL)
8565 {
8566 status=MagickFalse;
8567 break;
8568 }
8569 *images=DestroyImageList(*images);
8570 *images=layers;
8571 layers=OptimizeImageLayers(*images,exception);
8572 if (layers == (Image *) NULL)
8573 {
8574 status=MagickFalse;
8575 break;
8576 }
8577 *images=DestroyImageList(*images);
8578 *images=layers;
8579 layers=(Image *) NULL;
8580 OptimizeImageTransparency(*images,exception);
8581 (void) RemapImages(quantize_info,*images,(Image *) NULL,
8582 exception);
8583 break;
8584 }
8585 case CompositeLayer:
8586 {
8587 CompositeOperator
8588 compose;
8589
8590 Image
8591 *source;
8592
8593 RectangleInfo
8594 geometry;
8595
8596 /*
8597 Split image sequence at the first 'NULL:' image.
8598 */
8599 source=(*images);
8600 while (source != (Image *) NULL)
8601 {
8602 source=GetNextImageInList(source);
8603 if ((source != (Image *) NULL) &&
8604 (LocaleCompare(source->magick,"NULL") == 0))
8605 break;
8606 }
8607 if (source != (Image *) NULL)
8608 {
8609 if ((GetPreviousImageInList(source) == (Image *) NULL) ||
8610 (GetNextImageInList(source) == (Image *) NULL))
8611 source=(Image *) NULL;
8612 else
8613 {
8614 /*
8615 Separate the two lists, junk the null: image.
8616 */
8617 source=SplitImageList(source->previous);
8618 DeleteImageFromList(&source);
8619 }
8620 }
8621 if (source == (Image *) NULL)
8622 {
8623 (void) ThrowMagickException(exception,GetMagickModule(),
8624 OptionError,"MissingNullSeparator","layers Composite");
8625 status=MagickFalse;
8626 break;
8627 }
8628 /*
8629 Adjust offset with gravity and virtual canvas.
8630 */
8631 SetGeometry(*images,&geometry);
8632 (void) ParseAbsoluteGeometry((*images)->geometry,&geometry);
8633 geometry.width=source->page.width != 0 ?
8634 source->page.width : source->columns;
8635 geometry.height=source->page.height != 0 ?
8636 source->page.height : source->rows;
8637 GravityAdjustGeometry((*images)->page.width != 0 ?
8638 (*images)->page.width : (*images)->columns,
8639 (*images)->page.height != 0 ? (*images)->page.height :
8640 (*images)->rows,(*images)->gravity,&geometry);
8641 compose=OverCompositeOp;
8642 option=GetImageOption(mogrify_info,"compose");
8643 if (option != (const char *) NULL)
8644 compose=(CompositeOperator) ParseCommandOption(
8645 MagickComposeOptions,MagickFalse,option);
8646 CompositeLayers(*images,compose,source,geometry.x,geometry.y,
8647 exception);
8648 source=DestroyImageList(source);
8649 break;
8650 }
8651 }
8652 if (layers == (Image *) NULL)
8653 break;
8654 *images=DestroyImageList(*images);
8655 *images=layers;
8656 break;
8657 }
8658 break;
8659 }
8660 case 'm':
8661 {
8662 if (LocaleCompare("map",option+1) == 0)
8663 {
8664 (void) SyncImagesSettings(mogrify_info,*images,exception);
8665 if (*option == '+')
8666 {
8667 (void) RemapImages(quantize_info,*images,(Image *) NULL,
8668 exception);
8669 break;
8670 }
8671 i++;
8672 break;
8673 }
8674 if (LocaleCompare("maximum",option+1) == 0)
8675 {
8676 Image
8677 *maximum_image;
8678
8679 /*
8680 Maximum image sequence (deprecated).
8681 */
8682 (void) SyncImagesSettings(mogrify_info,*images,exception);
8683 maximum_image=EvaluateImages(*images,MaxEvaluateOperator,exception);
8684 if (maximum_image == (Image *) NULL)
8685 {
8686 status=MagickFalse;
8687 break;
8688 }
8689 *images=DestroyImageList(*images);
8690 *images=maximum_image;
8691 break;
8692 }
8693 if (LocaleCompare("minimum",option+1) == 0)
8694 {
8695 Image
8696 *minimum_image;
8697
8698 /*
8699 Minimum image sequence (deprecated).
8700 */
8701 (void) SyncImagesSettings(mogrify_info,*images,exception);
8702 minimum_image=EvaluateImages(*images,MinEvaluateOperator,exception);
8703 if (minimum_image == (Image *) NULL)
8704 {
8705 status=MagickFalse;
8706 break;
8707 }
8708 *images=DestroyImageList(*images);
8709 *images=minimum_image;
8710 break;
8711 }
8712 if (LocaleCompare("morph",option+1) == 0)
8713 {
8714 Image
8715 *morph_image;
8716
8717 (void) SyncImagesSettings(mogrify_info,*images,exception);
8718 morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]),
8719 exception);
8720 if (morph_image == (Image *) NULL)
8721 {
8722 status=MagickFalse;
8723 break;
8724 }
8725 *images=DestroyImageList(*images);
8726 *images=morph_image;
8727 break;
8728 }
8729 if (LocaleCompare("mosaic",option+1) == 0)
8730 {
8731 Image
8732 *mosaic_image;
8733
8734 (void) SyncImagesSettings(mogrify_info,*images,exception);
8735 mosaic_image=MergeImageLayers(*images,MosaicLayer,exception);
8736 if (mosaic_image == (Image *) NULL)
8737 {
8738 status=MagickFalse;
8739 break;
8740 }
8741 *images=DestroyImageList(*images);
8742 *images=mosaic_image;
8743 break;
8744 }
8745 break;
8746 }
8747 case 'p':
8748 {
8749 if (LocaleCompare("poly",option+1) == 0)
8750 {
8751 char
8752 *args,
8753 token[MagickPathExtent];
8754
8755 const char
8756 *p;
8757
8758 double
8759 *arguments;
8760
8761 Image
8762 *polynomial_image;
8763
8764 ssize_t
8765 x;
8766
8767 size_t
8768 number_arguments;
8769
8770 /*
8771 Polynomial image.
8772 */
8773 (void) SyncImageSettings(mogrify_info,*images,exception);
8774 args=InterpretImageProperties(mogrify_info,*images,argv[i+1],
8775 exception);
8776 if (args == (char *) NULL)
8777 break;
8778 p=(char *) args;
8779 for (x=0; *p != '\0'; x++)
8780 {
8781 (void) GetNextToken(p,&p,MagickPathExtent,token);
8782 if (*token == ',')
8783 (void) GetNextToken(p,&p,MagickPathExtent,token);
8784 }
8785 number_arguments=(size_t) x;
8786 arguments=(double *) AcquireQuantumMemory(number_arguments,
8787 sizeof(*arguments));
8788 if (arguments == (double *) NULL)
8789 ThrowWandFatalException(ResourceLimitFatalError,
8790 "MemoryAllocationFailed",(*images)->filename);
8791 (void) memset(arguments,0,number_arguments*
8792 sizeof(*arguments));
8793 p=(char *) args;
8794 for (x=0; (x < (ssize_t) number_arguments) && (*p != '\0'); x++)
8795 {
8796 (void) GetNextToken(p,&p,MagickPathExtent,token);
8797 if (*token == ',')
8798 (void) GetNextToken(p,&p,MagickPathExtent,token);
8799 arguments[x]=StringToDouble(token,(char **) NULL);
8800 }
8801 args=DestroyString(args);
8802 polynomial_image=PolynomialImage(*images,number_arguments >> 1,
8803 arguments,exception);
8804 arguments=(double *) RelinquishMagickMemory(arguments);
8805 if (polynomial_image == (Image *) NULL)
8806 {
8807 status=MagickFalse;
8808 break;
8809 }
8810 *images=DestroyImageList(*images);
8811 *images=polynomial_image;
8812 }
8813 if (LocaleCompare("print",option+1) == 0)
8814 {
8815 char
8816 *string;
8817
8818 (void) SyncImagesSettings(mogrify_info,*images,exception);
8819 string=InterpretImageProperties(mogrify_info,*images,argv[i+1],
8820 exception);
8821 if (string == (char *) NULL)
8822 break;
8823 (void) FormatLocaleFile(stdout,"%s",string);
8824 string=DestroyString(string);
8825 }
8826 if (LocaleCompare("process",option+1) == 0)
8827 {
8828 char
8829 **arguments;
8830
8831 int
8832 j,
8833 number_arguments;
8834
8835 (void) SyncImagesSettings(mogrify_info,*images,exception);
8836 arguments=StringToArgv(argv[i+1],&number_arguments);
8837 if ((arguments == (char **) NULL) || (number_arguments == 1))
8838 break;
8839 if ((argc > 1) && (strchr(arguments[1],'=') != (char *) NULL))
8840 {
8841 char
8842 breaker,
8843 quote,
8844 *token;
8845
8846 const char
8847 *argument;
8848
8849 int
8850 next,
8851 token_status;
8852
8853 size_t
8854 length;
8855
8856 TokenInfo
8857 *token_info;
8858
8859 /*
8860 Support old style syntax, filter="-option arg".
8861 */
8862 length=strlen(argv[i+1]);
8863 token=(char *) NULL;
8864 if (~length >= (MagickPathExtent-1))
8865 token=(char *) AcquireQuantumMemory(length+MagickPathExtent,
8866 sizeof(*token));
8867 if (token == (char *) NULL)
8868 break;
8869 next=0;
8870 argument=argv[i+1];
8871 token_info=AcquireTokenInfo();
8872 token_status=Tokenizer(token_info,0,token,length,argument,"",
8873 "=","\"",'\0',&breaker,&next,&quote);
8874 token_info=DestroyTokenInfo(token_info);
8875 if (token_status == 0)
8876 {
8877 const char
8878 *arg;
8879
8880 arg=(&(argument[next]));
8881 (void) InvokeDynamicImageFilter(token,&(*images),1,&arg,
8882 exception);
8883 }
8884 token=DestroyString(token);
8885 break;
8886 }
8887 (void) SubstituteString(&arguments[1],"-","");
8888 (void) InvokeDynamicImageFilter(arguments[1],&(*images),
8889 number_arguments-2,(const char **) arguments+2,exception);
8890 for (j=0; j < number_arguments; j++)
8891 arguments[j]=DestroyString(arguments[j]);
8892 arguments=(char **) RelinquishMagickMemory(arguments);
8893 break;
8894 }
8895 break;
8896 }
8897 case 'r':
8898 {
8899 if (LocaleCompare("reverse",option+1) == 0)
8900 {
8901 ReverseImageList(images);
8902 break;
8903 }
8904 break;
8905 }
8906 case 's':
8907 {
8908 if (LocaleCompare("smush",option+1) == 0)
8909 {
8910 Image
8911 *smush_image;
8912
8913 ssize_t
8914 offset;
8915
8916 (void) SyncImagesSettings(mogrify_info,*images,exception);
8917 offset=(ssize_t) StringToLong(argv[i+1]);
8918 smush_image=SmushImages(*images,*option == '-' ? MagickTrue :
8919 MagickFalse,offset,exception);
8920 if (smush_image == (Image *) NULL)
8921 {
8922 status=MagickFalse;
8923 break;
8924 }
8925 *images=DestroyImageList(*images);
8926 *images=smush_image;
8927 break;
8928 }
8929 if (LocaleCompare("swap",option+1) == 0)
8930 {
8931 Image
8932 *p,
8933 *q,
8934 *u,
8935 *v;
8936
8937 ssize_t
8938 swap_index;
8939
8940 index=(-1);
8941 swap_index=(-2);
8942 if (*option != '+')
8943 {
8944 GeometryInfo
8945 geometry_info;
8946
8947 MagickStatusType
8948 flags;
8949
8950 swap_index=(-1);
8951 flags=ParseGeometry(argv[i+1],&geometry_info);
8952 index=(ssize_t) geometry_info.rho;
8953 if ((flags & SigmaValue) != 0)
8954 swap_index=(ssize_t) geometry_info.sigma;
8955 }
8956 p=GetImageFromList(*images,index);
8957 q=GetImageFromList(*images,swap_index);
8958 if ((p == (Image *) NULL) || (q == (Image *) NULL))
8959 {
8960 (void) ThrowMagickException(exception,GetMagickModule(),
8961 OptionError,"NoSuchImage","`%s'",(*images)->filename);
8962 status=MagickFalse;
8963 break;
8964 }
8965 if (p == q)
8966 break;
8967 u=CloneImage(p,0,0,MagickTrue,exception);
8968 if (u == (Image *) NULL)
8969 break;
8970 v=CloneImage(q,0,0,MagickTrue,exception);
8971 if (v == (Image *) NULL)
8972 {
8973 u=DestroyImage(u);
8974 break;
8975 }
8976 ReplaceImageInList(&p,v);
8977 ReplaceImageInList(&q,u);
8978 *images=GetFirstImageInList(q);
8979 break;
8980 }
8981 break;
8982 }
8983 case 'w':
8984 {
8985 if (LocaleCompare("write",option+1) == 0)
8986 {
8987 char
8988 key[MagickPathExtent];
8989
8990 Image
8991 *write_images;
8992
8993 ImageInfo
8994 *write_info;
8995
8996 (void) SyncImagesSettings(mogrify_info,*images,exception);
8997 (void) FormatLocaleString(key,MagickPathExtent,"cache:%s",
8998 argv[i+1]);
8999 (void) DeleteImageRegistry(key);
9000 write_images=CloneImageList(*images,exception);
9001 write_info=CloneImageInfo(mogrify_info);
9002 status&=(MagickStatusType) WriteImages(write_info,write_images,
9003 argv[i+1],exception);
9004 write_info=DestroyImageInfo(write_info);
9005 write_images=DestroyImageList(write_images);
9006 break;
9007 }
9008 break;
9009 }
9010 default:
9011 break;
9012 }
9013 i+=count;
9014 }
9015 quantize_info=DestroyQuantizeInfo(quantize_info);
9016 mogrify_info=DestroyImageInfo(mogrify_info);
9017 status&=(MagickStatusType) MogrifyImageInfo(image_info,argc,argv,exception);
9018 return(status != 0 ? MagickTrue : MagickFalse);
9019}
9020␌
9021/*
9022%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9023% %
9024% %
9025% %
9026+ M o g r i f y I m a g e s %
9027% %
9028% %
9029% %
9030%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9031%
9032% MogrifyImages() applies image processing options to a sequence of images as
9033% prescribed by command line options.
9034%
9035% The format of the MogrifyImage method is:
9036%
9037% MagickBooleanType MogrifyImages(ImageInfo *image_info,
9038% const MagickBooleanType post,const int argc,const char **argv,
9039% Image **images,Exceptioninfo *exception)
9040%
9041% A description of each parameter follows:
9042%
9043% o image_info: the image info..
9044%
9045% o post: If true, post process image list operators otherwise pre-process.
9046%
9047% o argc: Specifies a pointer to an integer describing the number of
9048% elements in the argument vector.
9049%
9050% o argv: Specifies a pointer to a text array containing the command line
9051% arguments.
9052%
9053% o images: pointer to a pointer of the first image in image list.
9054%
9055% o exception: return any errors or warnings in this structure.
9056%
9057*/
9058WandExport MagickBooleanType MogrifyImages(ImageInfo *image_info,
9059 const MagickBooleanType post,const int argc,const char **argv,
9060 Image **images,ExceptionInfo *exception)
9061{
9062#define MogrifyImageTag "Mogrify/Image"
9063
9064 MagickStatusType
9065 status;
9066
9067 MagickBooleanType
9068 proceed;
9069
9070 size_t
9071 n;
9072
9073 ssize_t
9074 i;
9075
9076 assert(image_info != (ImageInfo *) NULL);
9077 assert(image_info->signature == MagickCoreSignature);
9078 if (images == (Image **) NULL)
9079 return(MogrifyImage(image_info,argc,argv,images,exception));
9080 assert((*images)->previous == (Image *) NULL);
9081 assert((*images)->signature == MagickCoreSignature);
9082 if (IsEventLogging() != MagickFalse)
9083 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
9084 (*images)->filename);
9085 if ((argc <= 0) || (*argv == (char *) NULL))
9086 return(MagickTrue);
9087 (void) SetImageInfoProgressMonitor(image_info,(MagickProgressMonitor) NULL,
9088 (void *) NULL);
9089 status=MagickTrue;
9090#if 0
9091 (void) FormatLocaleFile(stderr, "mogrify start %s %d (%s)\n",argv[0],argc,
9092 post?"post":"pre");
9093#endif
9094 /*
9095 Pre-process multi-image sequence operators
9096 */
9097 if (post == MagickFalse)
9098 status&=(MagickStatusType) MogrifyImageList(image_info,argc,argv,images,
9099 exception);
9100 /*
9101 For each image, process simple single image operators
9102 */
9103 i=0;
9104 n=GetImageListLength(*images);
9105 for ( ; ; )
9106 {
9107#if 0
9108 (void) FormatLocaleFile(stderr,"mogrify %ld of %ld\n",(long)
9109 GetImageIndexInList(*images),(long)GetImageListLength(*images));
9110#endif
9111 status&=(MagickStatusType) MogrifyImage(image_info,argc,argv,images,
9112 exception);
9113 proceed=SetImageProgress(*images,MogrifyImageTag,(MagickOffsetType) i, n);
9114 if (proceed == MagickFalse)
9115 break;
9116 if ( (*images)->next == (Image *) NULL )
9117 break;
9118 *images=(*images)->next;
9119 i++;
9120 }
9121 assert( *images != (Image *) NULL );
9122#if 0
9123 (void) FormatLocaleFile(stderr,"mogrify end %ld of %ld\n",(long)
9124 GetImageIndexInList(*images),(long)GetImageListLength(*images));
9125#endif
9126 /*
9127 Post-process, multi-image sequence operators
9128 */
9129 *images=GetFirstImageInList(*images);
9130 if (post != MagickFalse)
9131 status&=(MagickStatusType) MogrifyImageList(image_info,argc,argv,images,
9132 exception);
9133 return(status != 0 ? MagickTrue : MagickFalse);
9134}