MagickWand 7.1.2-25
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 /*
3908 Rename image file as backup.
3909 */
3910 (void) CopyMagickString(backup_filename,image->filename,
3911 MagickPathExtent);
3912 for (j=0; j < 6; j++)
3913 {
3914 (void) ConcatenateMagickString(backup_filename,"~",
3915 MagickPathExtent);
3916 if (IsPathAccessible(backup_filename) == MagickFalse)
3917 break;
3918 }
3919 if ((IsPathAccessible(backup_filename) != MagickFalse) ||
3920 (rename_utf8(image->filename,backup_filename) != 0))
3921 *backup_filename='\0';
3922 }
3923 /*
3924 Write transmogrified image to disk.
3925 */
3926 image_info->synchronize=MagickTrue;
3927 status&=(MagickStatusType) WriteImages(image_info,image,image->filename,
3928 exception);
3929 if (status != MagickFalse)
3930 {
3931 {
3932 MagickBooleanType
3933 preserve_timestamp;
3934
3935 preserve_timestamp=IsStringTrue(GetImageOption(image_info,
3936 "preserve-timestamp"));
3937 if (preserve_timestamp != MagickFalse)
3938 (void) set_file_timestamp(image->filename,&properties);
3939 }
3940 if (*backup_filename != '\0')
3941 (void) remove_utf8(backup_filename);
3942 }
3943 else
3944 if (*backup_filename != '\0')
3945 (void) rename_utf8(backup_filename,image->filename);
3946 RemoveAllImageStack();
3947 continue;
3948 }
3949 pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
3950 switch (*(option+1))
3951 {
3952 case 'a':
3953 {
3954 if (LocaleCompare("adaptive-blur",option+1) == 0)
3955 {
3956 i++;
3957 if (i == (ssize_t) argc)
3958 ThrowMogrifyException(OptionError,"MissingArgument",option);
3959 if (IsGeometry(argv[i]) == MagickFalse)
3960 ThrowMogrifyInvalidArgumentException(option,argv[i]);
3961 break;
3962 }
3963 if (LocaleCompare("adaptive-resize",option+1) == 0)
3964 {
3965 i++;
3966 if (i == (ssize_t) argc)
3967 ThrowMogrifyException(OptionError,"MissingArgument",option);
3968 if (IsGeometry(argv[i]) == MagickFalse)
3969 ThrowMogrifyInvalidArgumentException(option,argv[i]);
3970 break;
3971 }
3972 if (LocaleCompare("adaptive-sharpen",option+1) == 0)
3973 {
3974 i++;
3975 if (i == (ssize_t) argc)
3976 ThrowMogrifyException(OptionError,"MissingArgument",option);
3977 if (IsGeometry(argv[i]) == MagickFalse)
3978 ThrowMogrifyInvalidArgumentException(option,argv[i]);
3979 break;
3980 }
3981 if (LocaleCompare("affine",option+1) == 0)
3982 {
3983 if (*option == '+')
3984 break;
3985 i++;
3986 if (i == (ssize_t) argc)
3987 ThrowMogrifyException(OptionError,"MissingArgument",option);
3988 break;
3989 }
3990 if (LocaleCompare("alpha",option+1) == 0)
3991 {
3992 ssize_t
3993 type;
3994
3995 if (*option == '+')
3996 break;
3997 i++;
3998 if (i == (ssize_t) argc)
3999 ThrowMogrifyException(OptionError,"MissingArgument",option);
4000 type=ParseCommandOption(MagickAlphaChannelOptions,MagickFalse,
4001 argv[i]);
4002 if (type < 0)
4003 ThrowMogrifyException(OptionError,
4004 "UnrecognizedAlphaChannelOption",argv[i]);
4005 break;
4006 }
4007 if (LocaleCompare("annotate",option+1) == 0)
4008 {
4009 if (*option == '+')
4010 break;
4011 i++;
4012 if (i == (ssize_t) argc)
4013 ThrowMogrifyException(OptionError,"MissingArgument",option);
4014 if (IsGeometry(argv[i]) == MagickFalse)
4015 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4016 if (i == (ssize_t) argc)
4017 ThrowMogrifyException(OptionError,"MissingArgument",option);
4018 i++;
4019 break;
4020 }
4021 if (LocaleCompare("antialias",option+1) == 0)
4022 break;
4023 if (LocaleCompare("append",option+1) == 0)
4024 break;
4025 if (LocaleCompare("attenuate",option+1) == 0)
4026 {
4027 if (*option == '+')
4028 break;
4029 i++;
4030 if (i == (ssize_t) argc)
4031 ThrowMogrifyException(OptionError,"MissingArgument",option);
4032 if (IsGeometry(argv[i]) == MagickFalse)
4033 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4034 break;
4035 }
4036 if (LocaleCompare("authenticate",option+1) == 0)
4037 {
4038 if (*option == '+')
4039 break;
4040 i++;
4041 if (i == (ssize_t) argc)
4042 ThrowMogrifyException(OptionError,"MissingArgument",option);
4043 break;
4044 }
4045 if (LocaleCompare("auto-gamma",option+1) == 0)
4046 break;
4047 if (LocaleCompare("auto-level",option+1) == 0)
4048 break;
4049 if (LocaleCompare("auto-orient",option+1) == 0)
4050 break;
4051 if (LocaleCompare("auto-threshold",option+1) == 0)
4052 {
4053 ssize_t
4054 method;
4055
4056 if (*option == '+')
4057 break;
4058 i++;
4059 if (i == (ssize_t) argc)
4060 ThrowMogrifyException(OptionError,"MissingArgument",option);
4061 method=ParseCommandOption(MagickAutoThresholdOptions,MagickFalse,
4062 argv[i]);
4063 if (method < 0)
4064 ThrowMogrifyException(OptionError,"UnrecognizedThresholdMethod",
4065 argv[i]);
4066 break;
4067 }
4068 if (LocaleCompare("average",option+1) == 0)
4069 break;
4070 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4071 }
4072 case 'b':
4073 {
4074 if (LocaleCompare("background",option+1) == 0)
4075 {
4076 if (*option == '+')
4077 break;
4078 i++;
4079 if (i == (ssize_t) argc)
4080 ThrowMogrifyException(OptionError,"MissingArgument",option);
4081 break;
4082 }
4083 if (LocaleCompare("bias",option+1) == 0)
4084 {
4085 if (*option == '+')
4086 break;
4087 i++;
4088 if (i == (ssize_t) argc)
4089 ThrowMogrifyException(OptionError,"MissingArgument",option);
4090 if (IsGeometry(argv[i]) == MagickFalse)
4091 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4092 break;
4093 }
4094 if (LocaleCompare("bilateral-blur",option+1) == 0)
4095 {
4096 if (*option == '+')
4097 break;
4098 i++;
4099 if (i == (ssize_t) argc)
4100 ThrowMogrifyException(OptionError,"MissingArgument",option);
4101 if (IsGeometry(argv[i]) == MagickFalse)
4102 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4103 break;
4104 }
4105 if (LocaleCompare("black-point-compensation",option+1) == 0)
4106 break;
4107 if (LocaleCompare("black-threshold",option+1) == 0)
4108 {
4109 if (*option == '+')
4110 break;
4111 i++;
4112 if (i == (ssize_t) argc)
4113 ThrowMogrifyException(OptionError,"MissingArgument",option);
4114 if (IsGeometry(argv[i]) == MagickFalse)
4115 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4116 break;
4117 }
4118 if (LocaleCompare("blue-primary",option+1) == 0)
4119 {
4120 if (*option == '+')
4121 break;
4122 i++;
4123 if (i == (ssize_t) argc)
4124 ThrowMogrifyException(OptionError,"MissingArgument",option);
4125 if (IsGeometry(argv[i]) == MagickFalse)
4126 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4127 break;
4128 }
4129 if (LocaleCompare("blue-shift",option+1) == 0)
4130 {
4131 i++;
4132 if (i == (ssize_t) argc)
4133 ThrowMogrifyException(OptionError,"MissingArgument",option);
4134 if (IsGeometry(argv[i]) == MagickFalse)
4135 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4136 break;
4137 }
4138 if (LocaleCompare("blur",option+1) == 0)
4139 {
4140 i++;
4141 if (i == (ssize_t) argc)
4142 ThrowMogrifyException(OptionError,"MissingArgument",option);
4143 if (IsGeometry(argv[i]) == MagickFalse)
4144 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4145 break;
4146 }
4147 if (LocaleCompare("border",option+1) == 0)
4148 {
4149 if (*option == '+')
4150 break;
4151 i++;
4152 if (i == (ssize_t) argc)
4153 ThrowMogrifyException(OptionError,"MissingArgument",option);
4154 if (IsGeometry(argv[i]) == MagickFalse)
4155 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4156 break;
4157 }
4158 if (LocaleCompare("bordercolor",option+1) == 0)
4159 {
4160 if (*option == '+')
4161 break;
4162 i++;
4163 if (i == (ssize_t) argc)
4164 ThrowMogrifyException(OptionError,"MissingArgument",option);
4165 break;
4166 }
4167 if (LocaleCompare("box",option+1) == 0)
4168 {
4169 if (*option == '+')
4170 break;
4171 i++;
4172 if (i == (ssize_t) argc)
4173 ThrowMogrifyException(OptionError,"MissingArgument",option);
4174 break;
4175 }
4176 if (LocaleCompare("brightness-contrast",option+1) == 0)
4177 {
4178 i++;
4179 if (i == (ssize_t) argc)
4180 ThrowMogrifyException(OptionError,"MissingArgument",option);
4181 if (IsGeometry(argv[i]) == MagickFalse)
4182 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4183 break;
4184 }
4185 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4186 }
4187 case 'c':
4188 {
4189 if (LocaleCompare("cache",option+1) == 0)
4190 {
4191 if (*option == '+')
4192 break;
4193 i++;
4194 if (i == (ssize_t) argc)
4195 ThrowMogrifyException(OptionError,"MissingArgument",option);
4196 if (IsGeometry(argv[i]) == MagickFalse)
4197 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4198 break;
4199 }
4200 if (LocaleCompare("canny",option+1) == 0)
4201 {
4202 if (*option == '+')
4203 break;
4204 i++;
4205 if (i == (ssize_t) argc)
4206 ThrowMogrifyException(OptionError,"MissingArgument",option);
4207 if (IsGeometry(argv[i]) == MagickFalse)
4208 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4209 break;
4210 }
4211 if (LocaleCompare("caption",option+1) == 0)
4212 {
4213 if (*option == '+')
4214 break;
4215 i++;
4216 if (i == (ssize_t) argc)
4217 ThrowMogrifyException(OptionError,"MissingArgument",option);
4218 break;
4219 }
4220 if (LocaleCompare("channel",option+1) == 0)
4221 {
4222 ssize_t
4223 channel;
4224
4225 if (*option == '+')
4226 break;
4227 i++;
4228 if (i == (ssize_t) argc)
4229 ThrowMogrifyException(OptionError,"MissingArgument",option);
4230 channel=ParseChannelOption(argv[i]);
4231 if (channel < 0)
4232 ThrowMogrifyException(OptionError,"UnrecognizedChannelType",
4233 argv[i]);
4234 break;
4235 }
4236 if (LocaleCompare("channel-fx",option+1) == 0)
4237 {
4238 ssize_t
4239 channel;
4240
4241 if (*option == '+')
4242 break;
4243 i++;
4244 if (i == (ssize_t) argc)
4245 ThrowMogrifyException(OptionError,"MissingArgument",option);
4246 channel=ParsePixelChannelOption(argv[i]);
4247 if (channel < 0)
4248 ThrowMogrifyException(OptionError,"UnrecognizedChannelType",
4249 argv[i]);
4250 break;
4251 }
4252 if (LocaleCompare("cdl",option+1) == 0)
4253 {
4254 if (*option == '+')
4255 break;
4256 i++;
4257 if (i == (ssize_t) argc)
4258 ThrowMogrifyException(OptionError,"MissingArgument",option);
4259 break;
4260 }
4261 if (LocaleCompare("charcoal",option+1) == 0)
4262 {
4263 if (*option == '+')
4264 break;
4265 i++;
4266 if (i == (ssize_t) argc)
4267 ThrowMogrifyException(OptionError,"MissingArgument",option);
4268 if (IsGeometry(argv[i]) == MagickFalse)
4269 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4270 break;
4271 }
4272 if (LocaleCompare("chop",option+1) == 0)
4273 {
4274 if (*option == '+')
4275 break;
4276 i++;
4277 if (i == (ssize_t) argc)
4278 ThrowMogrifyException(OptionError,"MissingArgument",option);
4279 if (IsGeometry(argv[i]) == MagickFalse)
4280 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4281 break;
4282 }
4283 if (LocaleCompare("clahe",option+1) == 0)
4284 {
4285 if (*option == '+')
4286 break;
4287 i++;
4288 if (i == (ssize_t) argc)
4289 ThrowMogrifyException(OptionError,"MissingArgument",option);
4290 if (IsGeometry(argv[i]) == MagickFalse)
4291 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4292 break;
4293 }
4294 if (LocaleCompare("clamp",option+1) == 0)
4295 break;
4296 if (LocaleCompare("clip",option+1) == 0)
4297 break;
4298 if (LocaleCompare("clip-mask",option+1) == 0)
4299 {
4300 if (*option == '+')
4301 break;
4302 i++;
4303 if (i == (ssize_t) argc)
4304 ThrowMogrifyException(OptionError,"MissingArgument",option);
4305 break;
4306 }
4307 if (LocaleCompare("clut",option+1) == 0)
4308 break;
4309 if (LocaleCompare("coalesce",option+1) == 0)
4310 break;
4311 if (LocaleCompare("colorize",option+1) == 0)
4312 {
4313 if (*option == '+')
4314 break;
4315 i++;
4316 if (i == (ssize_t) argc)
4317 ThrowMogrifyException(OptionError,"MissingArgument",option);
4318 if (IsGeometry(argv[i]) == MagickFalse)
4319 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4320 break;
4321 }
4322 if (LocaleCompare("color-matrix",option+1) == 0)
4323 {
4324 KernelInfo
4325 *kernel_info;
4326
4327 if (*option == '+')
4328 break;
4329 i++;
4330 if (i == (ssize_t) argc)
4331 ThrowMogrifyException(OptionError,"MissingArgument",option);
4332 kernel_info=AcquireKernelInfo(argv[i],exception);
4333 if (kernel_info == (KernelInfo *) NULL)
4334 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4335 kernel_info=DestroyKernelInfo(kernel_info);
4336 break;
4337 }
4338 if (LocaleCompare("colors",option+1) == 0)
4339 {
4340 if (*option == '+')
4341 break;
4342 i++;
4343 if (i == (ssize_t) argc)
4344 ThrowMogrifyException(OptionError,"MissingArgument",option);
4345 if (IsGeometry(argv[i]) == MagickFalse)
4346 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4347 break;
4348 }
4349 if (LocaleCompare("colorspace",option+1) == 0)
4350 {
4351 ssize_t
4352 colorspace;
4353
4354 if (*option == '+')
4355 break;
4356 i++;
4357 if (i == (ssize_t) argc)
4358 ThrowMogrifyException(OptionError,"MissingArgument",option);
4359 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
4360 argv[i]);
4361 if (colorspace < 0)
4362 ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
4363 argv[i]);
4364 break;
4365 }
4366 if (LocaleCompare("color-threshold",option+1) == 0)
4367 {
4368 if (*option == '+')
4369 break;
4370 i++;
4371 if (i == (ssize_t) argc)
4372 ThrowMogrifyException(OptionError,"MissingArgument",option);
4373 break;
4374 }
4375 if (LocaleCompare("combine",option+1) == 0)
4376 {
4377 ssize_t
4378 colorspace;
4379
4380 if (*option == '+')
4381 break;
4382 i++;
4383 if (i == (ssize_t) argc)
4384 ThrowMogrifyException(OptionError,"MissingArgument",option);
4385 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
4386 argv[i]);
4387 if (colorspace < 0)
4388 ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
4389 argv[i]);
4390 break;
4391 }
4392 if (LocaleCompare("comment",option+1) == 0)
4393 {
4394 if (*option == '+')
4395 break;
4396 i++;
4397 if (i == (ssize_t) argc)
4398 ThrowMogrifyException(OptionError,"MissingArgument",option);
4399 break;
4400 }
4401 if (LocaleCompare("compare",option+1) == 0)
4402 break;
4403 if (LocaleCompare("compose",option+1) == 0)
4404 {
4405 ssize_t
4406 compose;
4407
4408 if (*option == '+')
4409 break;
4410 i++;
4411 if (i == (ssize_t) argc)
4412 ThrowMogrifyException(OptionError,"MissingArgument",option);
4413 compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
4414 argv[i]);
4415 if (compose < 0)
4416 ThrowMogrifyException(OptionError,"UnrecognizedComposeOperator",
4417 argv[i]);
4418 break;
4419 }
4420 if (LocaleCompare("composite",option+1) == 0)
4421 break;
4422 if (LocaleCompare("compress",option+1) == 0)
4423 {
4424 ssize_t
4425 compress;
4426
4427 if (*option == '+')
4428 break;
4429 i++;
4430 if (i == (ssize_t) argc)
4431 ThrowMogrifyException(OptionError,"MissingArgument",option);
4432 compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
4433 argv[i]);
4434 if (compress < 0)
4435 ThrowMogrifyException(OptionError,"UnrecognizedImageCompression",
4436 argv[i]);
4437 break;
4438 }
4439 if (LocaleCompare("concurrent",option+1) == 0)
4440 break;
4441 if (LocaleCompare("connected-components",option+1) == 0)
4442 {
4443 i++;
4444 if (i == (ssize_t) argc)
4445 ThrowMogrifyException(OptionError,"MissingArgument",option);
4446 if (IsGeometry(argv[i]) == MagickFalse)
4447 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4448 break;
4449 }
4450 if (LocaleCompare("contrast",option+1) == 0)
4451 break;
4452 if (LocaleCompare("contrast-stretch",option+1) == 0)
4453 {
4454 i++;
4455 if (i == (ssize_t) argc)
4456 ThrowMogrifyException(OptionError,"MissingArgument",option);
4457 if (IsGeometry(argv[i]) == MagickFalse)
4458 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4459 break;
4460 }
4461 if (LocaleCompare("convolve",option+1) == 0)
4462 {
4463 KernelInfo
4464 *kernel_info;
4465
4466 if (*option == '+')
4467 break;
4468 i++;
4469 if (i == (ssize_t) argc)
4470 ThrowMogrifyException(OptionError,"MissingArgument",option);
4471 kernel_info=AcquireKernelInfo(argv[i],exception);
4472 if (kernel_info == (KernelInfo *) NULL)
4473 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4474 kernel_info=DestroyKernelInfo(kernel_info);
4475 break;
4476 }
4477 if (LocaleCompare("copy",option+1) == 0)
4478 {
4479 if (*option == '+')
4480 break;
4481 i++;
4482 if (i == (ssize_t) argc)
4483 ThrowMogrifyException(OptionError,"MissingArgument",option);
4484 if (IsGeometry(argv[i]) == MagickFalse)
4485 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4486 i++;
4487 if (i == (ssize_t) argc)
4488 ThrowMogrifyException(OptionError,"MissingArgument",option);
4489 if (IsGeometry(argv[i]) == MagickFalse)
4490 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4491 break;
4492 }
4493 if (LocaleCompare("crop",option+1) == 0)
4494 {
4495 if (*option == '+')
4496 break;
4497 i++;
4498 if (i == (ssize_t) argc)
4499 ThrowMogrifyException(OptionError,"MissingArgument",option);
4500 if (IsGeometry(argv[i]) == MagickFalse)
4501 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4502 break;
4503 }
4504 if (LocaleCompare("cycle",option+1) == 0)
4505 {
4506 if (*option == '+')
4507 break;
4508 i++;
4509 if (i == (ssize_t) argc)
4510 ThrowMogrifyException(OptionError,"MissingArgument",option);
4511 if (IsGeometry(argv[i]) == MagickFalse)
4512 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4513 break;
4514 }
4515 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4516 }
4517 case 'd':
4518 {
4519 if (LocaleCompare("decipher",option+1) == 0)
4520 {
4521 if (*option == '+')
4522 break;
4523 i++;
4524 if (i == (ssize_t) argc)
4525 ThrowMogrifyException(OptionError,"MissingArgument",option);
4526 break;
4527 }
4528 if (LocaleCompare("deconstruct",option+1) == 0)
4529 break;
4530 if (LocaleCompare("debug",option+1) == 0)
4531 {
4532 ssize_t
4533 event;
4534
4535 if (*option == '+')
4536 break;
4537 i++;
4538 if (i == (ssize_t) argc)
4539 ThrowMogrifyException(OptionError,"MissingArgument",option);
4540 event=ParseCommandOption(MagickLogEventOptions,MagickFalse,argv[i]);
4541 if (event < 0)
4542 ThrowMogrifyException(OptionError,"UnrecognizedEventType",
4543 argv[i]);
4544 (void) SetLogEventMask(argv[i]);
4545 break;
4546 }
4547 if (LocaleCompare("define",option+1) == 0)
4548 {
4549 i++;
4550 if (i == (ssize_t) argc)
4551 ThrowMogrifyException(OptionError,"MissingArgument",option);
4552 if (*option == '+')
4553 {
4554 const char
4555 *define;
4556
4557 define=GetImageOption(image_info,argv[i]);
4558 if (define == (const char *) NULL)
4559 ThrowMogrifyException(OptionError,"NoSuchOption",argv[i]);
4560 break;
4561 }
4562 break;
4563 }
4564 if (LocaleCompare("delay",option+1) == 0)
4565 {
4566 if (*option == '+')
4567 break;
4568 i++;
4569 if (i == (ssize_t) argc)
4570 ThrowMogrifyException(OptionError,"MissingArgument",option);
4571 if (IsGeometry(argv[i]) == MagickFalse)
4572 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4573 break;
4574 }
4575 if (LocaleCompare("delete",option+1) == 0)
4576 {
4577 if (*option == '+')
4578 break;
4579 i++;
4580 if (i == (ssize_t) argc)
4581 ThrowMogrifyException(OptionError,"MissingArgument",option);
4582 if (LocaleNCompare(argv[i],"registry:",9) == 0)
4583 {
4584 (void) DeleteImageRegistry(argv[i]+9);
4585 break;
4586 }
4587 if (IsGeometry(argv[i]) == MagickFalse)
4588 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4589 break;
4590 }
4591 if (LocaleCompare("density",option+1) == 0)
4592 {
4593 if (*option == '+')
4594 break;
4595 i++;
4596 if (i == (ssize_t) argc)
4597 ThrowMogrifyException(OptionError,"MissingArgument",option);
4598 if (IsGeometry(argv[i]) == MagickFalse)
4599 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4600 break;
4601 }
4602 if (LocaleCompare("depth",option+1) == 0)
4603 {
4604 if (*option == '+')
4605 break;
4606 i++;
4607 if (i == (ssize_t) argc)
4608 ThrowMogrifyException(OptionError,"MissingArgument",option);
4609 if (IsGeometry(argv[i]) == MagickFalse)
4610 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4611 break;
4612 }
4613 if (LocaleCompare("deskew",option+1) == 0)
4614 {
4615 if (*option == '+')
4616 break;
4617 i++;
4618 if (i == (ssize_t) argc)
4619 ThrowMogrifyException(OptionError,"MissingArgument",option);
4620 if (IsGeometry(argv[i]) == MagickFalse)
4621 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4622 break;
4623 }
4624 if (LocaleCompare("despeckle",option+1) == 0)
4625 break;
4626 if (LocaleCompare("dft",option+1) == 0)
4627 break;
4628 if (LocaleCompare("direction",option+1) == 0)
4629 {
4630 ssize_t
4631 direction;
4632
4633 if (*option == '+')
4634 break;
4635 i++;
4636 if (i == (ssize_t) argc)
4637 ThrowMogrifyException(OptionError,"MissingArgument",option);
4638 direction=ParseCommandOption(MagickDirectionOptions,MagickFalse,
4639 argv[i]);
4640 if (direction < 0)
4641 ThrowMogrifyException(OptionError,"UnrecognizedDirectionType",
4642 argv[i]);
4643 break;
4644 }
4645 if (LocaleCompare("display",option+1) == 0)
4646 {
4647 if (*option == '+')
4648 break;
4649 i++;
4650 if (i == (ssize_t) argc)
4651 ThrowMogrifyException(OptionError,"MissingArgument",option);
4652 break;
4653 }
4654 if (LocaleCompare("dispose",option+1) == 0)
4655 {
4656 ssize_t
4657 dispose;
4658
4659 if (*option == '+')
4660 break;
4661 i++;
4662 if (i == (ssize_t) argc)
4663 ThrowMogrifyException(OptionError,"MissingArgument",option);
4664 dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,
4665 argv[i]);
4666 if (dispose < 0)
4667 ThrowMogrifyException(OptionError,"UnrecognizedDisposeMethod",
4668 argv[i]);
4669 break;
4670 }
4671 if (LocaleCompare("distort",option+1) == 0)
4672 {
4673 ssize_t
4674 op;
4675
4676 i++;
4677 if (i == (ssize_t) argc)
4678 ThrowMogrifyException(OptionError,"MissingArgument",option);
4679 op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
4680 if (op < 0)
4681 ThrowMogrifyException(OptionError,"UnrecognizedDistortMethod",
4682 argv[i]);
4683 i++;
4684 if (i == (ssize_t) argc)
4685 ThrowMogrifyException(OptionError,"MissingArgument",option);
4686 break;
4687 }
4688 if (LocaleCompare("dither",option+1) == 0)
4689 {
4690 ssize_t
4691 method;
4692
4693 if (*option == '+')
4694 break;
4695 i++;
4696 if (i == (ssize_t) argc)
4697 ThrowMogrifyException(OptionError,"MissingArgument",option);
4698 method=ParseCommandOption(MagickDitherOptions,MagickFalse,argv[i]);
4699 if (method < 0)
4700 ThrowMogrifyException(OptionError,"UnrecognizedDitherMethod",
4701 argv[i]);
4702 break;
4703 }
4704 if (LocaleCompare("draw",option+1) == 0)
4705 {
4706 if (*option == '+')
4707 break;
4708 i++;
4709 if (i == (ssize_t) argc)
4710 ThrowMogrifyException(OptionError,"MissingArgument",option);
4711 break;
4712 }
4713 if (LocaleCompare("duplicate",option+1) == 0)
4714 {
4715 if (*option == '+')
4716 break;
4717 i++;
4718 if (i == (ssize_t) argc)
4719 ThrowMogrifyException(OptionError,"MissingArgument",option);
4720 if (IsGeometry(argv[i]) == MagickFalse)
4721 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4722 break;
4723 }
4724 if (LocaleCompare("duration",option+1) == 0)
4725 {
4726 if (*option == '+')
4727 break;
4728 i++;
4729 if (i == (ssize_t) argc)
4730 ThrowMogrifyException(OptionError,"MissingArgument",option);
4731 if (IsGeometry(argv[i]) == MagickFalse)
4732 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4733 break;
4734 }
4735 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4736 }
4737 case 'e':
4738 {
4739 if (LocaleCompare("edge",option+1) == 0)
4740 {
4741 if (*option == '+')
4742 break;
4743 i++;
4744 if (i == (ssize_t) argc)
4745 ThrowMogrifyException(OptionError,"MissingArgument",option);
4746 if (IsGeometry(argv[i]) == MagickFalse)
4747 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4748 break;
4749 }
4750 if (LocaleCompare("emboss",option+1) == 0)
4751 {
4752 if (*option == '+')
4753 break;
4754 i++;
4755 if (i == (ssize_t) argc)
4756 ThrowMogrifyException(OptionError,"MissingArgument",option);
4757 if (IsGeometry(argv[i]) == MagickFalse)
4758 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4759 break;
4760 }
4761 if (LocaleCompare("encipher",option+1) == 0)
4762 {
4763 if (*option == '+')
4764 break;
4765 i++;
4766 if (i == (ssize_t) argc)
4767 ThrowMogrifyException(OptionError,"MissingArgument",option);
4768 break;
4769 }
4770 if (LocaleCompare("encoding",option+1) == 0)
4771 {
4772 if (*option == '+')
4773 break;
4774 i++;
4775 if (i == (ssize_t) argc)
4776 ThrowMogrifyException(OptionError,"MissingArgument",option);
4777 break;
4778 }
4779 if (LocaleCompare("endian",option+1) == 0)
4780 {
4781 ssize_t
4782 endian;
4783
4784 if (*option == '+')
4785 break;
4786 i++;
4787 if (i == (ssize_t) argc)
4788 ThrowMogrifyException(OptionError,"MissingArgument",option);
4789 endian=ParseCommandOption(MagickEndianOptions,MagickFalse,argv[i]);
4790 if (endian < 0)
4791 ThrowMogrifyException(OptionError,"UnrecognizedEndianType",
4792 argv[i]);
4793 break;
4794 }
4795 if (LocaleCompare("enhance",option+1) == 0)
4796 break;
4797 if (LocaleCompare("equalize",option+1) == 0)
4798 break;
4799 if (LocaleCompare("evaluate",option+1) == 0)
4800 {
4801 ssize_t
4802 op;
4803
4804 if (*option == '+')
4805 break;
4806 i++;
4807 if (i == (ssize_t) argc)
4808 ThrowMogrifyException(OptionError,"MissingArgument",option);
4809 op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
4810 if (op < 0)
4811 ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator",
4812 argv[i]);
4813 i++;
4814 if (i == (ssize_t) argc)
4815 ThrowMogrifyException(OptionError,"MissingArgument",option);
4816 if (IsGeometry(argv[i]) == MagickFalse)
4817 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4818 break;
4819 }
4820 if (LocaleCompare("evaluate-sequence",option+1) == 0)
4821 {
4822 ssize_t
4823 op;
4824
4825 if (*option == '+')
4826 break;
4827 i++;
4828 if (i == (ssize_t) argc)
4829 ThrowMogrifyException(OptionError,"MissingArgument",option);
4830 op=ParseCommandOption(MagickEvaluateOptions,MagickFalse,argv[i]);
4831 if (op < 0)
4832 ThrowMogrifyException(OptionError,"UnrecognizedEvaluateOperator",
4833 argv[i]);
4834 break;
4835 }
4836 if (LocaleCompare("extent",option+1) == 0)
4837 {
4838 if (*option == '+')
4839 break;
4840 i++;
4841 if (i == (ssize_t) argc)
4842 ThrowMogrifyException(OptionError,"MissingArgument",option);
4843 if (IsGeometry(argv[i]) == MagickFalse)
4844 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4845 break;
4846 }
4847 if (LocaleCompare("extract",option+1) == 0)
4848 {
4849 if (*option == '+')
4850 break;
4851 i++;
4852 if (i == (ssize_t) argc)
4853 ThrowMogrifyException(OptionError,"MissingArgument",option);
4854 if (IsGeometry(argv[i]) == MagickFalse)
4855 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4856 break;
4857 }
4858 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
4859 }
4860 case 'f':
4861 {
4862 if (LocaleCompare("family",option+1) == 0)
4863 {
4864 if (*option == '+')
4865 break;
4866 i++;
4867 if (i == (ssize_t) argc)
4868 ThrowMogrifyException(OptionError,"MissingArgument",option);
4869 break;
4870 }
4871 if (LocaleCompare("features",option+1) == 0)
4872 {
4873 if (*option == '+')
4874 break;
4875 i++;
4876 if (i == (ssize_t) argc)
4877 ThrowMogrifyException(OptionError,"MissingArgument",option);
4878 if (IsGeometry(argv[i]) == MagickFalse)
4879 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4880 break;
4881 }
4882 if (LocaleCompare("fill",option+1) == 0)
4883 {
4884 if (*option == '+')
4885 break;
4886 i++;
4887 if (i == (ssize_t) argc)
4888 ThrowMogrifyException(OptionError,"MissingArgument",option);
4889 break;
4890 }
4891 if (LocaleCompare("filter",option+1) == 0)
4892 {
4893 ssize_t
4894 filter;
4895
4896 if (*option == '+')
4897 break;
4898 i++;
4899 if (i == (ssize_t) argc)
4900 ThrowMogrifyException(OptionError,"MissingArgument",option);
4901 filter=ParseCommandOption(MagickFilterOptions,MagickFalse,argv[i]);
4902 if (filter < 0)
4903 ThrowMogrifyException(OptionError,"UnrecognizedImageFilter",
4904 argv[i]);
4905 break;
4906 }
4907 if (LocaleCompare("flatten",option+1) == 0)
4908 break;
4909 if (LocaleCompare("flip",option+1) == 0)
4910 break;
4911 if (LocaleCompare("flop",option+1) == 0)
4912 break;
4913 if (LocaleCompare("floodfill",option+1) == 0)
4914 {
4915 if (*option == '+')
4916 break;
4917 i++;
4918 if (i == (ssize_t) argc)
4919 ThrowMogrifyException(OptionError,"MissingArgument",option);
4920 if (IsGeometry(argv[i]) == MagickFalse)
4921 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4922 i++;
4923 if (i == (ssize_t) argc)
4924 ThrowMogrifyException(OptionError,"MissingArgument",option);
4925 break;
4926 }
4927 if (LocaleCompare("font",option+1) == 0)
4928 {
4929 if (*option == '+')
4930 break;
4931 i++;
4932 if (i == (ssize_t) argc)
4933 ThrowMogrifyException(OptionError,"MissingArgument",option);
4934 break;
4935 }
4936 if (LocaleCompare("format",option+1) == 0)
4937 {
4938 (void) CopyMagickString(argv[i]+1,"sans",MagickPathExtent);
4939 (void) CloneString(&format,(char *) NULL);
4940 if (*option == '+')
4941 break;
4942 i++;
4943 if (i == (ssize_t) argc)
4944 ThrowMogrifyException(OptionError,"MissingArgument",option);
4945 (void) CloneString(&format,argv[i]);
4946 (void) CopyMagickString(image_info->filename,format,
4947 MagickPathExtent);
4948 (void) ConcatenateMagickString(image_info->filename,":",
4949 MagickPathExtent);
4950 (void) SetImageInfo(image_info,0,exception);
4951 if (*image_info->magick == '\0')
4952 ThrowMogrifyException(OptionError,"UnrecognizedImageFormat",
4953 format);
4954 break;
4955 }
4956 if (LocaleCompare("frame",option+1) == 0)
4957 {
4958 if (*option == '+')
4959 break;
4960 i++;
4961 if (i == (ssize_t) argc)
4962 ThrowMogrifyException(OptionError,"MissingArgument",option);
4963 if (IsGeometry(argv[i]) == MagickFalse)
4964 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4965 break;
4966 }
4967 if (LocaleCompare("function",option+1) == 0)
4968 {
4969 ssize_t
4970 op;
4971
4972 if (*option == '+')
4973 break;
4974 i++;
4975 if (i == (ssize_t) argc)
4976 ThrowMogrifyException(OptionError,"MissingArgument",option);
4977 op=ParseCommandOption(MagickFunctionOptions,MagickFalse,argv[i]);
4978 if (op < 0)
4979 ThrowMogrifyException(OptionError,"UnrecognizedFunction",argv[i]);
4980 i++;
4981 if (i == (ssize_t) argc)
4982 ThrowMogrifyException(OptionError,"MissingArgument",option);
4983 break;
4984 }
4985 if (LocaleCompare("fuzz",option+1) == 0)
4986 {
4987 if (*option == '+')
4988 break;
4989 i++;
4990 if (i == (ssize_t) argc)
4991 ThrowMogrifyException(OptionError,"MissingArgument",option);
4992 if (IsGeometry(argv[i]) == MagickFalse)
4993 ThrowMogrifyInvalidArgumentException(option,argv[i]);
4994 break;
4995 }
4996 if (LocaleCompare("fx",option+1) == 0)
4997 {
4998 i++;
4999 if (i == (ssize_t) argc)
5000 ThrowMogrifyException(OptionError,"MissingArgument",option);
5001 break;
5002 }
5003 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5004 }
5005 case 'g':
5006 {
5007 if (LocaleCompare("gamma",option+1) == 0)
5008 {
5009 i++;
5010 if (i == (ssize_t) argc)
5011 ThrowMogrifyException(OptionError,"MissingArgument",option);
5012 if (IsGeometry(argv[i]) == MagickFalse)
5013 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5014 break;
5015 }
5016 if ((LocaleCompare("gaussian-blur",option+1) == 0) ||
5017 (LocaleCompare("gaussian",option+1) == 0))
5018 {
5019 i++;
5020 if (i == (ssize_t) argc)
5021 ThrowMogrifyException(OptionError,"MissingArgument",option);
5022 if (IsGeometry(argv[i]) == MagickFalse)
5023 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5024 break;
5025 }
5026 if (LocaleCompare("geometry",option+1) == 0)
5027 {
5028 if (*option == '+')
5029 break;
5030 i++;
5031 if (i == (ssize_t) argc)
5032 ThrowMogrifyException(OptionError,"MissingArgument",option);
5033 if (IsGeometry(argv[i]) == MagickFalse)
5034 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5035 break;
5036 }
5037 if (LocaleCompare("gravity",option+1) == 0)
5038 {
5039 ssize_t
5040 gravity;
5041
5042 if (*option == '+')
5043 break;
5044 i++;
5045 if (i == (ssize_t) argc)
5046 ThrowMogrifyException(OptionError,"MissingArgument",option);
5047 gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
5048 argv[i]);
5049 if (gravity < 0)
5050 ThrowMogrifyException(OptionError,"UnrecognizedGravityType",
5051 argv[i]);
5052 break;
5053 }
5054 if (LocaleCompare("grayscale",option+1) == 0)
5055 {
5056 ssize_t
5057 method;
5058
5059 if (*option == '+')
5060 break;
5061 i++;
5062 if (i == (ssize_t) argc)
5063 ThrowMogrifyException(OptionError,"MissingArgument",option);
5064 method=ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,
5065 argv[i]);
5066 if (method < 0)
5067 ThrowMogrifyException(OptionError,"UnrecognizedIntensityMethod",
5068 argv[i]);
5069 break;
5070 }
5071 if (LocaleCompare("green-primary",option+1) == 0)
5072 {
5073 if (*option == '+')
5074 break;
5075 i++;
5076 if (i == (ssize_t) argc)
5077 ThrowMogrifyException(OptionError,"MissingArgument",option);
5078 if (IsGeometry(argv[i]) == MagickFalse)
5079 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5080 break;
5081 }
5082 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5083 }
5084 case 'h':
5085 {
5086 if (LocaleCompare("hald-clut",option+1) == 0)
5087 break;
5088 if ((LocaleCompare("help",option+1) == 0) ||
5089 (LocaleCompare("-help",option+1) == 0))
5090 {
5091 DestroyMogrify();
5092 return(MogrifyUsage());
5093 }
5094 if (LocaleCompare("hough-lines",option+1) == 0)
5095 {
5096 if (*option == '+')
5097 break;
5098 i++;
5099 if (i == (ssize_t) argc)
5100 ThrowMogrifyException(OptionError,"MissingArgument",option);
5101 if (IsGeometry(argv[i]) == MagickFalse)
5102 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5103 break;
5104 }
5105 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5106 }
5107 case 'i':
5108 {
5109 if (LocaleCompare("identify",option+1) == 0)
5110 break;
5111 if (LocaleCompare("idft",option+1) == 0)
5112 break;
5113 if (LocaleCompare("illuminant",option+1) == 0)
5114 {
5115 ssize_t
5116 type;
5117
5118 if (*option == '+')
5119 break;
5120 i++;
5121 if (i == (ssize_t) argc)
5122 ThrowMogrifyException(OptionError,"MissingArgument",option);
5123 type=ParseCommandOption(MagickIlluminantOptions,MagickFalse,
5124 argv[i]);
5125 if (type < 0)
5126 ThrowMogrifyException(OptionError,"UnrecognizedIlluminantMethod",
5127 argv[i]);
5128 break;
5129 }
5130 if (LocaleCompare("implode",option+1) == 0)
5131 {
5132 if (*option == '+')
5133 break;
5134 i++;
5135 if (i == (ssize_t) argc)
5136 ThrowMogrifyException(OptionError,"MissingArgument",option);
5137 if (IsGeometry(argv[i]) == MagickFalse)
5138 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5139 break;
5140 }
5141 if (LocaleCompare("intensity",option+1) == 0)
5142 {
5143 ssize_t
5144 intensity;
5145
5146 if (*option == '+')
5147 break;
5148 i++;
5149 if (i == (ssize_t) argc)
5150 ThrowMogrifyException(OptionError,"MissingArgument",option);
5151 intensity=ParseCommandOption(MagickPixelIntensityOptions,
5152 MagickFalse,argv[i]);
5153 if (intensity < 0)
5154 ThrowMogrifyException(OptionError,
5155 "UnrecognizedPixelIntensityMethod",argv[i]);
5156 break;
5157 }
5158 if (LocaleCompare("integral",option+1) == 0)
5159 break;
5160 if (LocaleCompare("intent",option+1) == 0)
5161 {
5162 ssize_t
5163 intent;
5164
5165 if (*option == '+')
5166 break;
5167 i++;
5168 if (i == (ssize_t) argc)
5169 ThrowMogrifyException(OptionError,"MissingArgument",option);
5170 intent=ParseCommandOption(MagickIntentOptions,MagickFalse,argv[i]);
5171 if (intent < 0)
5172 ThrowMogrifyException(OptionError,"UnrecognizedIntentType",
5173 argv[i]);
5174 break;
5175 }
5176 if (LocaleCompare("interlace",option+1) == 0)
5177 {
5178 ssize_t
5179 interlace;
5180
5181 if (*option == '+')
5182 break;
5183 i++;
5184 if (i == (ssize_t) argc)
5185 ThrowMogrifyException(OptionError,"MissingArgument",option);
5186 interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
5187 argv[i]);
5188 if (interlace < 0)
5189 ThrowMogrifyException(OptionError,"UnrecognizedInterlaceType",
5190 argv[i]);
5191 break;
5192 }
5193 if (LocaleCompare("interline-spacing",option+1) == 0)
5194 {
5195 if (*option == '+')
5196 break;
5197 i++;
5198 if (i == (ssize_t) argc)
5199 ThrowMogrifyException(OptionError,"MissingArgument",option);
5200 if (IsGeometry(argv[i]) == MagickFalse)
5201 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5202 break;
5203 }
5204 if (LocaleCompare("interpolate",option+1) == 0)
5205 {
5206 ssize_t
5207 interpolate;
5208
5209 if (*option == '+')
5210 break;
5211 i++;
5212 if (i == (ssize_t) argc)
5213 ThrowMogrifyException(OptionError,"MissingArgument",option);
5214 interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
5215 argv[i]);
5216 if (interpolate < 0)
5217 ThrowMogrifyException(OptionError,"UnrecognizedInterpolateMethod",
5218 argv[i]);
5219 break;
5220 }
5221 if (LocaleCompare("interword-spacing",option+1) == 0)
5222 {
5223 if (*option == '+')
5224 break;
5225 i++;
5226 if (i == (ssize_t) argc)
5227 ThrowMogrifyException(OptionError,"MissingArgument",option);
5228 if (IsGeometry(argv[i]) == MagickFalse)
5229 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5230 break;
5231 }
5232 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5233 }
5234 case 'k':
5235 {
5236 if (LocaleCompare("kerning",option+1) == 0)
5237 {
5238 if (*option == '+')
5239 break;
5240 i++;
5241 if (i == (ssize_t) argc)
5242 ThrowMogrifyException(OptionError,"MissingArgument",option);
5243 if (IsGeometry(argv[i]) == MagickFalse)
5244 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5245 break;
5246 }
5247 if (LocaleCompare("kmeans",option+1) == 0)
5248 {
5249 i++;
5250 if (i == (ssize_t) argc)
5251 ThrowMogrifyException(OptionError,"MissingArgument",option);
5252 if (IsGeometry(argv[i]) == MagickFalse)
5253 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5254 break;
5255 }
5256 if (LocaleCompare("kuwahara",option+1) == 0)
5257 {
5258 i++;
5259 if (i == (ssize_t) argc)
5260 ThrowMogrifyException(OptionError,"MissingArgument",option);
5261 if (IsGeometry(argv[i]) == MagickFalse)
5262 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5263 break;
5264 }
5265 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5266 }
5267 case 'l':
5268 {
5269 if (LocaleCompare("label",option+1) == 0)
5270 {
5271 if (*option == '+')
5272 break;
5273 i++;
5274 if (i == (ssize_t) argc)
5275 ThrowMogrifyException(OptionError,"MissingArgument",option);
5276 break;
5277 }
5278 if (LocaleCompare("lat",option+1) == 0)
5279 {
5280 if (*option == '+')
5281 break;
5282 i++;
5283 if (i == (ssize_t) argc)
5284 ThrowMogrifyException(OptionError,"MissingArgument",option);
5285 if (IsGeometry(argv[i]) == MagickFalse)
5286 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5287 break;
5288 }
5289 if (LocaleCompare("layers",option+1) == 0)
5290 {
5291 ssize_t
5292 type;
5293
5294 if (*option == '+')
5295 break;
5296 i++;
5297 if (i == (ssize_t) argc)
5298 ThrowMogrifyException(OptionError,"MissingArgument",option);
5299 type=ParseCommandOption(MagickLayerOptions,MagickFalse,argv[i]);
5300 if (type < 0)
5301 ThrowMogrifyException(OptionError,"UnrecognizedLayerMethod",
5302 argv[i]);
5303 break;
5304 }
5305 if (LocaleCompare("level",option+1) == 0)
5306 {
5307 i++;
5308 if (i == (ssize_t) argc)
5309 ThrowMogrifyException(OptionError,"MissingArgument",option);
5310 if (IsGeometry(argv[i]) == MagickFalse)
5311 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5312 break;
5313 }
5314 if (LocaleCompare("level-colors",option+1) == 0)
5315 {
5316 i++;
5317 if (i == (ssize_t) argc)
5318 ThrowMogrifyException(OptionError,"MissingArgument",option);
5319 break;
5320 }
5321 if (LocaleCompare("limit",option+1) == 0)
5322 {
5323 char
5324 *p;
5325
5326 double
5327 value;
5328
5329 ssize_t
5330 resource;
5331
5332 if (*option == '+')
5333 break;
5334 i++;
5335 if (i == (ssize_t) argc)
5336 ThrowMogrifyException(OptionError,"MissingArgument",option);
5337 resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
5338 argv[i]);
5339 if (resource < 0)
5340 ThrowMogrifyException(OptionError,"UnrecognizedResourceType",
5341 argv[i]);
5342 i++;
5343 if (i == (ssize_t) argc)
5344 ThrowMogrifyException(OptionError,"MissingArgument",option);
5345 value=StringToDouble(argv[i],&p);
5346 (void) value;
5347 if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
5348 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5349 break;
5350 }
5351 if (LocaleCompare("liquid-rescale",option+1) == 0)
5352 {
5353 i++;
5354 if (i == (ssize_t) argc)
5355 ThrowMogrifyException(OptionError,"MissingArgument",option);
5356 if (IsGeometry(argv[i]) == MagickFalse)
5357 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5358 break;
5359 }
5360 if (LocaleCompare("list",option+1) == 0)
5361 {
5362 ssize_t
5363 list;
5364
5365 if (*option == '+')
5366 break;
5367 i++;
5368 if (i == (ssize_t) argc)
5369 ThrowMogrifyException(OptionError,"MissingArgument",option);
5370 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
5371 if (list < 0)
5372 ThrowMogrifyException(OptionError,"UnrecognizedListType",argv[i]);
5373 status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
5374 argv+j,exception);
5375 return(status == 0 ? MagickFalse : MagickTrue);
5376 }
5377 if (LocaleCompare("log",option+1) == 0)
5378 {
5379 if (*option == '+')
5380 break;
5381 i++;
5382 if ((i == (ssize_t) argc) ||
5383 (strchr(argv[i],'%') == (char *) NULL))
5384 ThrowMogrifyException(OptionError,"MissingArgument",option);
5385 break;
5386 }
5387 if (LocaleCompare("loop",option+1) == 0)
5388 {
5389 if (*option == '+')
5390 break;
5391 i++;
5392 if (i == (ssize_t) argc)
5393 ThrowMogrifyException(OptionError,"MissingArgument",option);
5394 if (IsGeometry(argv[i]) == MagickFalse)
5395 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5396 break;
5397 }
5398 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5399 }
5400 case 'm':
5401 {
5402 if (LocaleCompare("magnify",option+1) == 0)
5403 break;
5404 if (LocaleCompare("map",option+1) == 0)
5405 {
5406 global_colormap=(*option == '+') ? MagickTrue : MagickFalse;
5407 if (*option == '+')
5408 break;
5409 i++;
5410 if (i == (ssize_t) argc)
5411 ThrowMogrifyException(OptionError,"MissingArgument",option);
5412 break;
5413 }
5414 if (LocaleCompare("mask",option+1) == 0)
5415 {
5416 if (*option == '+')
5417 break;
5418 i++;
5419 if (i == (ssize_t) argc)
5420 ThrowMogrifyException(OptionError,"MissingArgument",option);
5421 break;
5422 }
5423 if (LocaleCompare("matte",option+1) == 0)
5424 break;
5425 if (LocaleCompare("mattecolor",option+1) == 0)
5426 {
5427 if (*option == '+')
5428 break;
5429 i++;
5430 if (i == (ssize_t) argc)
5431 ThrowMogrifyException(OptionError,"MissingArgument",option);
5432 break;
5433 }
5434 if (LocaleCompare("maximum",option+1) == 0)
5435 break;
5436 if (LocaleCompare("mean-shift",option+1) == 0)
5437 {
5438 if (*option == '+')
5439 break;
5440 i++;
5441 if (i == (ssize_t) argc)
5442 ThrowMogrifyException(OptionError,"MissingArgument",option);
5443 if (IsGeometry(argv[i]) == MagickFalse)
5444 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5445 break;
5446 }
5447 if (LocaleCompare("median",option+1) == 0)
5448 {
5449 if (*option == '+')
5450 break;
5451 i++;
5452 if (i == (ssize_t) argc)
5453 ThrowMogrifyException(OptionError,"MissingArgument",option);
5454 if (IsGeometry(argv[i]) == MagickFalse)
5455 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5456 break;
5457 }
5458 if (LocaleCompare("metric",option+1) == 0)
5459 {
5460 ssize_t
5461 type;
5462
5463 if (*option == '+')
5464 break;
5465 i++;
5466 if (i == (ssize_t) argc)
5467 ThrowMogrifyException(OptionError,"MissingArgument",option);
5468 type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
5469 if (type < 0)
5470 ThrowMogrifyException(OptionError,"UnrecognizedMetricType",
5471 argv[i]);
5472 break;
5473 }
5474 if (LocaleCompare("minimum",option+1) == 0)
5475 break;
5476 if (LocaleCompare("modulate",option+1) == 0)
5477 {
5478 if (*option == '+')
5479 break;
5480 i++;
5481 if (i == (ssize_t) argc)
5482 ThrowMogrifyException(OptionError,"MissingArgument",option);
5483 if (IsGeometry(argv[i]) == MagickFalse)
5484 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5485 break;
5486 }
5487 if (LocaleCompare("mode",option+1) == 0)
5488 {
5489 if (*option == '+')
5490 break;
5491 i++;
5492 if (i == (ssize_t) argc)
5493 ThrowMogrifyException(OptionError,"MissingArgument",option);
5494 if (IsGeometry(argv[i]) == MagickFalse)
5495 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5496 break;
5497 }
5498 if (LocaleCompare("monitor",option+1) == 0)
5499 break;
5500 if (LocaleCompare("monochrome",option+1) == 0)
5501 break;
5502 if (LocaleCompare("morph",option+1) == 0)
5503 {
5504 if (*option == '+')
5505 break;
5506 i++;
5507 if (i == (ssize_t) argc)
5508 ThrowMogrifyException(OptionError,"MissingArgument",option);
5509 if (IsGeometry(argv[i]) == MagickFalse)
5510 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5511 break;
5512 }
5513 if (LocaleCompare("morphology",option+1) == 0)
5514 {
5515 char
5516 token[MagickPathExtent];
5517
5518 KernelInfo
5519 *kernel_info;
5520
5521 ssize_t
5522 op;
5523
5524 i++;
5525 if (i == (ssize_t) argc)
5526 ThrowMogrifyException(OptionError,"MissingArgument",option);
5527 (void) GetNextToken(argv[i],(const char **) NULL,MagickPathExtent,
5528 token);
5529 op=ParseCommandOption(MagickMorphologyOptions,MagickFalse,token);
5530 if (op < 0)
5531 ThrowMogrifyException(OptionError,"UnrecognizedMorphologyMethod",
5532 token);
5533 i++;
5534 if (i == (ssize_t) argc)
5535 ThrowMogrifyException(OptionError,"MissingArgument",option);
5536 kernel_info=AcquireKernelInfo(argv[i],exception);
5537 if (kernel_info == (KernelInfo *) NULL)
5538 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5539 kernel_info=DestroyKernelInfo(kernel_info);
5540 break;
5541 }
5542 if (LocaleCompare("mosaic",option+1) == 0)
5543 break;
5544 if (LocaleCompare("motion-blur",option+1) == 0)
5545 {
5546 if (*option == '+')
5547 break;
5548 i++;
5549 if (i == (ssize_t) argc)
5550 ThrowMogrifyException(OptionError,"MissingArgument",option);
5551 if (IsGeometry(argv[i]) == MagickFalse)
5552 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5553 break;
5554 }
5555 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5556 }
5557 case 'n':
5558 {
5559 if (LocaleCompare("negate",option+1) == 0)
5560 break;
5561 if (LocaleCompare("noise",option+1) == 0)
5562 {
5563 i++;
5564 if (i == (ssize_t) argc)
5565 ThrowMogrifyException(OptionError,"MissingArgument",option);
5566 if (*option == '+')
5567 {
5568 ssize_t
5569 noise;
5570
5571 noise=ParseCommandOption(MagickNoiseOptions,MagickFalse,
5572 argv[i]);
5573 if (noise < 0)
5574 ThrowMogrifyException(OptionError,"UnrecognizedNoiseType",
5575 argv[i]);
5576 break;
5577 }
5578 if (IsGeometry(argv[i]) == MagickFalse)
5579 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5580 break;
5581 }
5582 if (LocaleCompare("noop",option+1) == 0)
5583 break;
5584 if (LocaleCompare("normalize",option+1) == 0)
5585 break;
5586 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5587 }
5588 case 'o':
5589 {
5590 if (LocaleCompare("opaque",option+1) == 0)
5591 {
5592 i++;
5593 if (i == (ssize_t) argc)
5594 ThrowMogrifyException(OptionError,"MissingArgument",option);
5595 break;
5596 }
5597 if (LocaleCompare("ordered-dither",option+1) == 0)
5598 {
5599 if (*option == '+')
5600 break;
5601 i++;
5602 if (i == (ssize_t) argc)
5603 ThrowMogrifyException(OptionError,"MissingArgument",option);
5604 break;
5605 }
5606 if (LocaleCompare("orient",option+1) == 0)
5607 {
5608 ssize_t
5609 orientation;
5610
5611 orientation=UndefinedOrientation;
5612 if (*option == '+')
5613 break;
5614 i++;
5615 if (i == (ssize_t) argc)
5616 ThrowMogrifyException(OptionError,"MissingArgument",option);
5617 orientation=ParseCommandOption(MagickOrientationOptions,MagickFalse,
5618 argv[i]);
5619 if (orientation < 0)
5620 ThrowMogrifyException(OptionError,"UnrecognizedImageOrientation",
5621 argv[i]);
5622 break;
5623 }
5624 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5625 }
5626 case 'p':
5627 {
5628 if (LocaleCompare("page",option+1) == 0)
5629 {
5630 if (*option == '+')
5631 break;
5632 i++;
5633 if (i == (ssize_t) argc)
5634 ThrowMogrifyException(OptionError,"MissingArgument",option);
5635 break;
5636 }
5637 if (LocaleCompare("paint",option+1) == 0)
5638 {
5639 if (*option == '+')
5640 break;
5641 i++;
5642 if (i == (ssize_t) argc)
5643 ThrowMogrifyException(OptionError,"MissingArgument",option);
5644 if (IsGeometry(argv[i]) == MagickFalse)
5645 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5646 break;
5647 }
5648 if (LocaleCompare("path",option+1) == 0)
5649 {
5650 (void) CloneString(&path,(char *) NULL);
5651 if (*option == '+')
5652 break;
5653 i++;
5654 if (i == (ssize_t) argc)
5655 ThrowMogrifyException(OptionError,"MissingArgument",option);
5656 (void) CloneString(&path,argv[i]);
5657 break;
5658 }
5659 if (LocaleCompare("perceptible",option+1) == 0)
5660 {
5661 if (*option == '+')
5662 break;
5663 i++;
5664 if (i == (ssize_t) argc)
5665 ThrowMogrifyException(OptionError,"MissingArgument",option);
5666 if (IsGeometry(argv[i]) == MagickFalse)
5667 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5668 break;
5669 }
5670 if (LocaleCompare("pointsize",option+1) == 0)
5671 {
5672 if (*option == '+')
5673 break;
5674 i++;
5675 if (i == (ssize_t) argc)
5676 ThrowMogrifyException(OptionError,"MissingArgument",option);
5677 if (IsGeometry(argv[i]) == MagickFalse)
5678 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5679 break;
5680 }
5681 if (LocaleCompare("polaroid",option+1) == 0)
5682 {
5683 if (*option == '+')
5684 break;
5685 i++;
5686 if (i == (ssize_t) argc)
5687 ThrowMogrifyException(OptionError,"MissingArgument",option);
5688 if (IsGeometry(argv[i]) == MagickFalse)
5689 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5690 break;
5691 }
5692 if (LocaleCompare("poly",option+1) == 0)
5693 {
5694 if (*option == '+')
5695 break;
5696 i++;
5697 if (i == (ssize_t) argc)
5698 ThrowMogrifyException(OptionError,"MissingArgument",option);
5699 if (IsGeometry(argv[i]) == MagickFalse)
5700 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5701 break;
5702 }
5703 if (LocaleCompare("posterize",option+1) == 0)
5704 {
5705 if (*option == '+')
5706 break;
5707 i++;
5708 if (i == (ssize_t) argc)
5709 ThrowMogrifyException(OptionError,"MissingArgument",option);
5710 if (IsGeometry(argv[i]) == MagickFalse)
5711 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5712 break;
5713 }
5714 if (LocaleCompare("precision",option+1) == 0)
5715 {
5716 if (*option == '+')
5717 break;
5718 i++;
5719 if (i == (ssize_t) argc)
5720 ThrowMogrifyException(OptionError,"MissingArgument",option);
5721 if (IsGeometry(argv[i]) == MagickFalse)
5722 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5723 break;
5724 }
5725 if (LocaleCompare("print",option+1) == 0)
5726 {
5727 if (*option == '+')
5728 break;
5729 i++;
5730 if (i == (ssize_t) argc)
5731 ThrowMogrifyException(OptionError,"MissingArgument",option);
5732 break;
5733 }
5734 if (LocaleCompare("process",option+1) == 0)
5735 {
5736 if (*option == '+')
5737 break;
5738 i++;
5739 if (i == (ssize_t) argc)
5740 ThrowMogrifyException(OptionError,"MissingArgument",option);
5741 break;
5742 }
5743 if (LocaleCompare("profile",option+1) == 0)
5744 {
5745 i++;
5746 if (i == (ssize_t) argc)
5747 ThrowMogrifyException(OptionError,"MissingArgument",option);
5748 break;
5749 }
5750 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5751 }
5752 case 'q':
5753 {
5754 if (LocaleCompare("quality",option+1) == 0)
5755 {
5756 if (*option == '+')
5757 break;
5758 i++;
5759 if (i == (ssize_t) argc)
5760 ThrowMogrifyException(OptionError,"MissingArgument",option);
5761 if (IsGeometry(argv[i]) == MagickFalse)
5762 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5763 break;
5764 }
5765 if (LocaleCompare("quantize",option+1) == 0)
5766 {
5767 ssize_t
5768 colorspace;
5769
5770 if (*option == '+')
5771 break;
5772 i++;
5773 if (i == (ssize_t) argc)
5774 ThrowMogrifyException(OptionError,"MissingArgument",option);
5775 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
5776 argv[i]);
5777 if (colorspace < 0)
5778 ThrowMogrifyException(OptionError,"UnrecognizedColorspace",
5779 argv[i]);
5780 break;
5781 }
5782 if (LocaleCompare("quiet",option+1) == 0)
5783 break;
5784 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5785 }
5786 case 'r':
5787 {
5788 if (LocaleCompare("rotational-blur",option+1) == 0)
5789 {
5790 i++;
5791 if (i == (ssize_t) argc)
5792 ThrowMogrifyException(OptionError,"MissingArgument",option);
5793 if (IsGeometry(argv[i]) == MagickFalse)
5794 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5795 break;
5796 }
5797 if (LocaleCompare("raise",option+1) == 0)
5798 {
5799 i++;
5800 if (i == (ssize_t) argc)
5801 ThrowMogrifyException(OptionError,"MissingArgument",option);
5802 if (IsGeometry(argv[i]) == MagickFalse)
5803 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5804 break;
5805 }
5806 if (LocaleCompare("random-threshold",option+1) == 0)
5807 {
5808 if (*option == '+')
5809 break;
5810 i++;
5811 if (i == (ssize_t) argc)
5812 ThrowMogrifyException(OptionError,"MissingArgument",option);
5813 if (IsGeometry(argv[i]) == MagickFalse)
5814 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5815 break;
5816 }
5817 if (LocaleCompare("range-threshold",option+1) == 0)
5818 {
5819 if (*option == '+')
5820 break;
5821 i++;
5822 if (i == (ssize_t) argc)
5823 ThrowMogrifyException(OptionError,"MissingArgument",option);
5824 if (IsGeometry(argv[i]) == MagickFalse)
5825 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5826 break;
5827 }
5828 if (LocaleCompare("read-mask",option+1) == 0)
5829 {
5830 if (*option == '+')
5831 break;
5832 i++;
5833 if (i == (ssize_t) argc)
5834 ThrowMogrifyException(OptionError,"MissingArgument",option);
5835 break;
5836 }
5837 if (LocaleCompare("red-primary",option+1) == 0)
5838 {
5839 if (*option == '+')
5840 break;
5841 i++;
5842 if (i == (ssize_t) argc)
5843 ThrowMogrifyException(OptionError,"MissingArgument",option);
5844 if (IsGeometry(argv[i]) == MagickFalse)
5845 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5846 }
5847 if (LocaleCompare("regard-warnings",option+1) == 0)
5848 break;
5849 if (LocaleCompare("region",option+1) == 0)
5850 {
5851 if (*option == '+')
5852 break;
5853 i++;
5854 if (i == (ssize_t) argc)
5855 ThrowMogrifyException(OptionError,"MissingArgument",option);
5856 if (IsGeometry(argv[i]) == MagickFalse)
5857 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5858 break;
5859 }
5860 if (LocaleCompare("remap",option+1) == 0)
5861 {
5862 if (*option == '+')
5863 break;
5864 i++;
5865 if (i == (ssize_t) argc)
5866 ThrowMogrifyException(OptionError,"MissingArgument",option);
5867 break;
5868 }
5869 if (LocaleCompare("render",option+1) == 0)
5870 break;
5871 if (LocaleCompare("repage",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 break;
5881 }
5882 if (LocaleCompare("resample",option+1) == 0)
5883 {
5884 if (*option == '+')
5885 break;
5886 i++;
5887 if (i == (ssize_t) argc)
5888 ThrowMogrifyException(OptionError,"MissingArgument",option);
5889 if (IsGeometry(argv[i]) == MagickFalse)
5890 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5891 break;
5892 }
5893 if (LocaleCompare("reshape",option+1) == 0)
5894 {
5895 if (*option == '+')
5896 break;
5897 i++;
5898 if (i == (ssize_t) argc)
5899 ThrowMogrifyException(OptionError,"MissingArgument",option);
5900 if (IsGeometry(argv[i]) == MagickFalse)
5901 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5902 break;
5903 }
5904 if (LocaleCompare("resize",option+1) == 0)
5905 {
5906 if (*option == '+')
5907 break;
5908 i++;
5909 if (i == (ssize_t) argc)
5910 ThrowMogrifyException(OptionError,"MissingArgument",option);
5911 if (IsGeometry(argv[i]) == MagickFalse)
5912 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5913 break;
5914 }
5915 if ((LocaleNCompare("respect-parentheses",option+1,17) == 0) ||
5916 (LocaleNCompare("respect-parenthesis",option+1,17) == 0))
5917 {
5918 respect_parentheses=(*option == '-') ? MagickTrue : MagickFalse;
5919 break;
5920 }
5921 if (LocaleCompare("reverse",option+1) == 0)
5922 break;
5923 if (LocaleCompare("roll",option+1) == 0)
5924 {
5925 if (*option == '+')
5926 break;
5927 i++;
5928 if (i == (ssize_t) argc)
5929 ThrowMogrifyException(OptionError,"MissingArgument",option);
5930 if (IsGeometry(argv[i]) == MagickFalse)
5931 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5932 break;
5933 }
5934 if (LocaleCompare("rotate",option+1) == 0)
5935 {
5936 i++;
5937 if (i == (ssize_t) argc)
5938 ThrowMogrifyException(OptionError,"MissingArgument",option);
5939 if (IsGeometry(argv[i]) == MagickFalse)
5940 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5941 break;
5942 }
5943 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
5944 }
5945 case 's':
5946 {
5947 if (LocaleCompare("sample",option+1) == 0)
5948 {
5949 if (*option == '+')
5950 break;
5951 i++;
5952 if (i == (ssize_t) argc)
5953 ThrowMogrifyException(OptionError,"MissingArgument",option);
5954 if (IsGeometry(argv[i]) == MagickFalse)
5955 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5956 break;
5957 }
5958 if (LocaleCompare("sampling-factor",option+1) == 0)
5959 {
5960 if (*option == '+')
5961 break;
5962 i++;
5963 if (i == (ssize_t) argc)
5964 ThrowMogrifyException(OptionError,"MissingArgument",option);
5965 if (IsGeometry(argv[i]) == MagickFalse)
5966 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5967 break;
5968 }
5969 if (LocaleCompare("scale",option+1) == 0)
5970 {
5971 if (*option == '+')
5972 break;
5973 i++;
5974 if (i == (ssize_t) argc)
5975 ThrowMogrifyException(OptionError,"MissingArgument",option);
5976 if (IsGeometry(argv[i]) == MagickFalse)
5977 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5978 break;
5979 }
5980 if (LocaleCompare("scene",option+1) == 0)
5981 {
5982 if (*option == '+')
5983 break;
5984 i++;
5985 if (i == (ssize_t) argc)
5986 ThrowMogrifyException(OptionError,"MissingArgument",option);
5987 if (IsGeometry(argv[i]) == MagickFalse)
5988 ThrowMogrifyInvalidArgumentException(option,argv[i]);
5989 break;
5990 }
5991 if (LocaleCompare("seed",option+1) == 0)
5992 {
5993 if (*option == '+')
5994 break;
5995 i++;
5996 if (i == (ssize_t) argc)
5997 ThrowMogrifyException(OptionError,"MissingArgument",option);
5998 if (IsGeometry(argv[i]) == MagickFalse)
5999 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6000 break;
6001 }
6002 if (LocaleCompare("segment",option+1) == 0)
6003 {
6004 if (*option == '+')
6005 break;
6006 i++;
6007 if (i == (ssize_t) argc)
6008 ThrowMogrifyException(OptionError,"MissingArgument",option);
6009 if (IsGeometry(argv[i]) == MagickFalse)
6010 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6011 break;
6012 }
6013 if (LocaleCompare("selective-blur",option+1) == 0)
6014 {
6015 i++;
6016 if (i == (ssize_t) argc)
6017 ThrowMogrifyException(OptionError,"MissingArgument",option);
6018 if (IsGeometry(argv[i]) == MagickFalse)
6019 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6020 break;
6021 }
6022 if (LocaleCompare("separate",option+1) == 0)
6023 break;
6024 if (LocaleCompare("sepia-tone",option+1) == 0)
6025 {
6026 if (*option == '+')
6027 break;
6028 i++;
6029 if (i == (ssize_t) argc)
6030 ThrowMogrifyException(OptionError,"MissingArgument",option);
6031 if (IsGeometry(argv[i]) == MagickFalse)
6032 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6033 break;
6034 }
6035 if (LocaleCompare("set",option+1) == 0)
6036 {
6037 i++;
6038 if (i == (ssize_t) argc)
6039 ThrowMogrifyException(OptionError,"MissingArgument",option);
6040 if (*option == '+')
6041 break;
6042 i++;
6043 if (i == (ssize_t) argc)
6044 ThrowMogrifyException(OptionError,"MissingArgument",option);
6045 break;
6046 }
6047 if (LocaleCompare("shade",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("shadow",option+1) == 0)
6057 {
6058 if (*option == '+')
6059 break;
6060 i++;
6061 if (i == (ssize_t) argc)
6062 ThrowMogrifyException(OptionError,"MissingArgument",option);
6063 if (IsGeometry(argv[i]) == MagickFalse)
6064 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6065 break;
6066 }
6067 if (LocaleCompare("sharpen",option+1) == 0)
6068 {
6069 i++;
6070 if (i == (ssize_t) argc)
6071 ThrowMogrifyException(OptionError,"MissingArgument",option);
6072 if (IsGeometry(argv[i]) == MagickFalse)
6073 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6074 break;
6075 }
6076 if (LocaleCompare("shave",option+1) == 0)
6077 {
6078 if (*option == '+')
6079 break;
6080 i++;
6081 if (i == (ssize_t) argc)
6082 ThrowMogrifyException(OptionError,"MissingArgument",option);
6083 if (IsGeometry(argv[i]) == MagickFalse)
6084 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6085 break;
6086 }
6087 if (LocaleCompare("shear",option+1) == 0)
6088 {
6089 i++;
6090 if (i == (ssize_t) argc)
6091 ThrowMogrifyException(OptionError,"MissingArgument",option);
6092 if (IsGeometry(argv[i]) == MagickFalse)
6093 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6094 break;
6095 }
6096 if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
6097 {
6098 i++;
6099 if (i == (ssize_t) argc)
6100 ThrowMogrifyException(OptionError,"MissingArgument",option);
6101 if (IsGeometry(argv[i]) == MagickFalse)
6102 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6103 break;
6104 }
6105 if (LocaleCompare("size",option+1) == 0)
6106 {
6107 if (*option == '+')
6108 break;
6109 i++;
6110 if (i == (ssize_t) argc)
6111 ThrowMogrifyException(OptionError,"MissingArgument",option);
6112 if (IsGeometry(argv[i]) == MagickFalse)
6113 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6114 break;
6115 }
6116 if (LocaleCompare("sketch",option+1) == 0)
6117 {
6118 if (*option == '+')
6119 break;
6120 i++;
6121 if (i == (ssize_t) argc)
6122 ThrowMogrifyException(OptionError,"MissingArgument",option);
6123 if (IsGeometry(argv[i]) == MagickFalse)
6124 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6125 break;
6126 }
6127 if (LocaleCompare("smush",option+1) == 0)
6128 {
6129 i++;
6130 if (i == (ssize_t) argc)
6131 ThrowMogrifyException(OptionError,"MissingArgument",option);
6132 if (IsGeometry(argv[i]) == MagickFalse)
6133 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6134 i++;
6135 break;
6136 }
6137 if (LocaleCompare("solarize",option+1) == 0)
6138 {
6139 if (*option == '+')
6140 break;
6141 i++;
6142 if (i == (ssize_t) argc)
6143 ThrowMogrifyException(OptionError,"MissingArgument",option);
6144 if (IsGeometry(argv[i]) == MagickFalse)
6145 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6146 break;
6147 }
6148 if (LocaleCompare("sort",option+1) == 0)
6149 break;
6150 if (LocaleCompare("sparse-color",option+1) == 0)
6151 {
6152 ssize_t
6153 op;
6154
6155 i++;
6156 if (i == (ssize_t) argc)
6157 ThrowMogrifyException(OptionError,"MissingArgument",option);
6158 op=ParseCommandOption(MagickSparseColorOptions,MagickFalse,argv[i]);
6159 if (op < 0)
6160 ThrowMogrifyException(OptionError,"UnrecognizedSparseColorMethod",
6161 argv[i]);
6162 i++;
6163 if (i == (ssize_t) argc)
6164 ThrowMogrifyException(OptionError,"MissingArgument",option);
6165 break;
6166 }
6167 if (LocaleCompare("splice",option+1) == 0)
6168 {
6169 if (*option == '+')
6170 break;
6171 i++;
6172 if (i == (ssize_t) argc)
6173 ThrowMogrifyException(OptionError,"MissingArgument",option);
6174 if (IsGeometry(argv[i]) == MagickFalse)
6175 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6176 break;
6177 }
6178 if (LocaleCompare("spread",option+1) == 0)
6179 {
6180 if (*option == '+')
6181 break;
6182 i++;
6183 if (i == (ssize_t) argc)
6184 ThrowMogrifyException(OptionError,"MissingArgument",option);
6185 if (IsGeometry(argv[i]) == MagickFalse)
6186 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6187 break;
6188 }
6189 if (LocaleCompare("statistic",option+1) == 0)
6190 {
6191 ssize_t
6192 op;
6193
6194 if (*option == '+')
6195 break;
6196 i++;
6197 if (i == (ssize_t) argc)
6198 ThrowMogrifyException(OptionError,"MissingArgument",option);
6199 op=ParseCommandOption(MagickStatisticOptions,MagickFalse,argv[i]);
6200 if (op < 0)
6201 ThrowMogrifyException(OptionError,"UnrecognizedStatisticType",
6202 argv[i]);
6203 i++;
6204 if (i == (ssize_t) argc)
6205 ThrowMogrifyException(OptionError,"MissingArgument",option);
6206 if (IsGeometry(argv[i]) == MagickFalse)
6207 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6208 break;
6209 }
6210 if (LocaleCompare("stretch",option+1) == 0)
6211 {
6212 ssize_t
6213 stretch;
6214
6215 if (*option == '+')
6216 break;
6217 i++;
6218 if (i == (ssize_t) argc)
6219 ThrowMogrifyException(OptionError,"MissingArgument",option);
6220 stretch=ParseCommandOption(MagickStretchOptions,MagickFalse,
6221 argv[i]);
6222 if (stretch < 0)
6223 ThrowMogrifyException(OptionError,"UnrecognizedStyleType",
6224 argv[i]);
6225 break;
6226 }
6227 if (LocaleCompare("strip",option+1) == 0)
6228 break;
6229 if (LocaleCompare("stroke",option+1) == 0)
6230 {
6231 if (*option == '+')
6232 break;
6233 i++;
6234 if (i == (ssize_t) argc)
6235 ThrowMogrifyException(OptionError,"MissingArgument",option);
6236 break;
6237 }
6238 if (LocaleCompare("strokewidth",option+1) == 0)
6239 {
6240 if (*option == '+')
6241 break;
6242 i++;
6243 if (i == (ssize_t) argc)
6244 ThrowMogrifyException(OptionError,"MissingArgument",option);
6245 if (IsGeometry(argv[i]) == MagickFalse)
6246 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6247 break;
6248 }
6249 if (LocaleCompare("style",option+1) == 0)
6250 {
6251 ssize_t
6252 style;
6253
6254 if (*option == '+')
6255 break;
6256 i++;
6257 if (i == (ssize_t) argc)
6258 ThrowMogrifyException(OptionError,"MissingArgument",option);
6259 style=ParseCommandOption(MagickStyleOptions,MagickFalse,argv[i]);
6260 if (style < 0)
6261 ThrowMogrifyException(OptionError,"UnrecognizedStyleType",
6262 argv[i]);
6263 break;
6264 }
6265 if (LocaleCompare("swap",option+1) == 0)
6266 {
6267 if (*option == '+')
6268 break;
6269 i++;
6270 if (i == (ssize_t) argc)
6271 ThrowMogrifyException(OptionError,"MissingArgument",option);
6272 if (IsGeometry(argv[i]) == MagickFalse)
6273 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6274 break;
6275 }
6276 if (LocaleCompare("swirl",option+1) == 0)
6277 {
6278 if (*option == '+')
6279 break;
6280 i++;
6281 if (i == (ssize_t) argc)
6282 ThrowMogrifyException(OptionError,"MissingArgument",option);
6283 if (IsGeometry(argv[i]) == MagickFalse)
6284 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6285 break;
6286 }
6287 if (LocaleCompare("synchronize",option+1) == 0)
6288 break;
6289 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6290 }
6291 case 't':
6292 {
6293 if (LocaleCompare("taint",option+1) == 0)
6294 break;
6295 if (LocaleCompare("texture",option+1) == 0)
6296 {
6297 if (*option == '+')
6298 break;
6299 i++;
6300 if (i == (ssize_t) argc)
6301 ThrowMogrifyException(OptionError,"MissingArgument",option);
6302 break;
6303 }
6304 if (LocaleCompare("tile",option+1) == 0)
6305 {
6306 if (*option == '+')
6307 break;
6308 i++;
6309 if (i == (ssize_t) argc)
6310 ThrowMogrifyException(OptionError,"MissingArgument",option);
6311 break;
6312 }
6313 if (LocaleCompare("tile-offset",option+1) == 0)
6314 {
6315 if (*option == '+')
6316 break;
6317 i++;
6318 if (i == (ssize_t) argc)
6319 ThrowMogrifyException(OptionError,"MissingArgument",option);
6320 if (IsGeometry(argv[i]) == MagickFalse)
6321 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6322 break;
6323 }
6324 if (LocaleCompare("tint",option+1) == 0)
6325 {
6326 if (*option == '+')
6327 break;
6328 i++;
6329 if (i == (ssize_t) argc)
6330 ThrowMogrifyException(OptionError,"MissingArgument",option);
6331 if (IsGeometry(argv[i]) == MagickFalse)
6332 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6333 break;
6334 }
6335 if (LocaleCompare("transform",option+1) == 0)
6336 break;
6337 if (LocaleCompare("transpose",option+1) == 0)
6338 break;
6339 if (LocaleCompare("transverse",option+1) == 0)
6340 break;
6341 if (LocaleCompare("threshold",option+1) == 0)
6342 {
6343 if (*option == '+')
6344 break;
6345 i++;
6346 if (i == (ssize_t) argc)
6347 ThrowMogrifyException(OptionError,"MissingArgument",option);
6348 if (IsGeometry(argv[i]) == MagickFalse)
6349 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6350 break;
6351 }
6352 if (LocaleCompare("thumbnail",option+1) == 0)
6353 {
6354 if (*option == '+')
6355 break;
6356 i++;
6357 if (i == (ssize_t) argc)
6358 ThrowMogrifyException(OptionError,"MissingArgument",option);
6359 if (IsGeometry(argv[i]) == MagickFalse)
6360 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6361 break;
6362 }
6363 if (LocaleCompare("transparent",option+1) == 0)
6364 {
6365 i++;
6366 if (i == (ssize_t) argc)
6367 ThrowMogrifyException(OptionError,"MissingArgument",option);
6368 break;
6369 }
6370 if (LocaleCompare("transparent-color",option+1) == 0)
6371 {
6372 if (*option == '+')
6373 break;
6374 i++;
6375 if (i == (ssize_t) argc)
6376 ThrowMogrifyException(OptionError,"MissingArgument",option);
6377 break;
6378 }
6379 if (LocaleCompare("treedepth",option+1) == 0)
6380 {
6381 if (*option == '+')
6382 break;
6383 i++;
6384 if (i == (ssize_t) argc)
6385 ThrowMogrifyException(OptionError,"MissingArgument",option);
6386 if (IsGeometry(argv[i]) == MagickFalse)
6387 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6388 break;
6389 }
6390 if (LocaleCompare("trim",option+1) == 0)
6391 break;
6392 if (LocaleCompare("type",option+1) == 0)
6393 {
6394 ssize_t
6395 type;
6396
6397 if (*option == '+')
6398 break;
6399 i++;
6400 if (i == (ssize_t) argc)
6401 ThrowMogrifyException(OptionError,"MissingArgument",option);
6402 type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
6403 if (type < 0)
6404 ThrowMogrifyException(OptionError,"UnrecognizedImageType",
6405 argv[i]);
6406 break;
6407 }
6408 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6409 }
6410 case 'u':
6411 {
6412 if (LocaleCompare("undercolor",option+1) == 0)
6413 {
6414 if (*option == '+')
6415 break;
6416 i++;
6417 if (i == (ssize_t) argc)
6418 ThrowMogrifyException(OptionError,"MissingArgument",option);
6419 break;
6420 }
6421 if (LocaleCompare("unique-colors",option+1) == 0)
6422 break;
6423 if (LocaleCompare("units",option+1) == 0)
6424 {
6425 ssize_t
6426 units;
6427
6428 if (*option == '+')
6429 break;
6430 i++;
6431 if (i == (ssize_t) argc)
6432 ThrowMogrifyException(OptionError,"MissingArgument",option);
6433 units=ParseCommandOption(MagickResolutionOptions,MagickFalse,
6434 argv[i]);
6435 if (units < 0)
6436 ThrowMogrifyException(OptionError,"UnrecognizedUnitsType",
6437 argv[i]);
6438 break;
6439 }
6440 if (LocaleCompare("unsharp",option+1) == 0)
6441 {
6442 i++;
6443 if (i == (ssize_t) argc)
6444 ThrowMogrifyException(OptionError,"MissingArgument",option);
6445 if (IsGeometry(argv[i]) == MagickFalse)
6446 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6447 break;
6448 }
6449 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6450 }
6451 case 'v':
6452 {
6453 if (LocaleCompare("verbose",option+1) == 0)
6454 {
6455 image_info->verbose=(*option == '-') ? MagickTrue : MagickFalse;
6456 break;
6457 }
6458 if ((LocaleCompare("version",option+1) == 0) ||
6459 (LocaleCompare("-version",option+1) == 0))
6460 {
6461 ListMagickVersion(stdout);
6462 break;
6463 }
6464 if (LocaleCompare("vignette",option+1) == 0)
6465 {
6466 if (*option == '+')
6467 break;
6468 i++;
6469 if (i == (ssize_t) argc)
6470 ThrowMogrifyException(OptionError,"MissingArgument",option);
6471 if (IsGeometry(argv[i]) == MagickFalse)
6472 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6473 break;
6474 }
6475 if (LocaleCompare("virtual-pixel",option+1) == 0)
6476 {
6477 ssize_t
6478 method;
6479
6480 if (*option == '+')
6481 break;
6482 i++;
6483 if (i == (ssize_t) argc)
6484 ThrowMogrifyException(OptionError,"MissingArgument",option);
6485 method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
6486 argv[i]);
6487 if (method < 0)
6488 ThrowMogrifyException(OptionError,
6489 "UnrecognizedVirtualPixelMethod",argv[i]);
6490 break;
6491 }
6492 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6493 }
6494 case 'w':
6495 {
6496 if (LocaleCompare("wave",option+1) == 0)
6497 {
6498 i++;
6499 if (i == (ssize_t) argc)
6500 ThrowMogrifyException(OptionError,"MissingArgument",option);
6501 if (IsGeometry(argv[i]) == MagickFalse)
6502 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6503 break;
6504 }
6505 if (LocaleCompare("wavelet-denoise",option+1) == 0)
6506 {
6507 i++;
6508 if (i == (ssize_t) argc)
6509 ThrowMogrifyException(OptionError,"MissingArgument",option);
6510 if (IsGeometry(argv[i]) == MagickFalse)
6511 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6512 break;
6513 }
6514 if (LocaleCompare("weight",option+1) == 0)
6515 {
6516 if (*option == '+')
6517 break;
6518 i++;
6519 if (i == (ssize_t) argc)
6520 ThrowMogrifyException(OptionError,"MissingArgument",option);
6521 break;
6522 }
6523 if (LocaleCompare("word-break",option+1) == 0)
6524 {
6525 ssize_t
6526 word_break;
6527
6528 if (*option == '+')
6529 break;
6530 i++;
6531 if (i == (ssize_t) argc)
6532 ThrowMogrifyException(OptionError,"MissingArgument",option);
6533 word_break=ParseCommandOption(MagickWordBreakOptions,MagickFalse,
6534 argv[i]);
6535 if (word_break < 0)
6536 ThrowMogrifyException(OptionError,"UnrecognizedArgument",argv[i]);
6537 break;
6538 }
6539 if (LocaleCompare("white-balance",option+1) == 0)
6540 break;
6541 if (LocaleCompare("white-point",option+1) == 0)
6542 {
6543 if (*option == '+')
6544 break;
6545 i++;
6546 if (i == (ssize_t) argc)
6547 ThrowMogrifyException(OptionError,"MissingArgument",option);
6548 if (IsGeometry(argv[i]) == MagickFalse)
6549 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6550 break;
6551 }
6552 if (LocaleCompare("white-threshold",option+1) == 0)
6553 {
6554 if (*option == '+')
6555 break;
6556 i++;
6557 if (i == (ssize_t) argc)
6558 ThrowMogrifyException(OptionError,"MissingArgument",option);
6559 if (IsGeometry(argv[i]) == MagickFalse)
6560 ThrowMogrifyInvalidArgumentException(option,argv[i]);
6561 break;
6562 }
6563 if (LocaleCompare("write",option+1) == 0)
6564 {
6565 i++;
6566 if (i == (ssize_t) argc)
6567 ThrowMogrifyException(OptionError,"MissingArgument",option);
6568 break;
6569 }
6570 if (LocaleCompare("write-mask",option+1) == 0)
6571 {
6572 if (*option == '+')
6573 break;
6574 i++;
6575 if (i == (ssize_t) argc)
6576 ThrowMogrifyException(OptionError,"MissingArgument",option);
6577 break;
6578 }
6579 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6580 }
6581 case '?':
6582 break;
6583 default:
6584 ThrowMogrifyException(OptionError,"UnrecognizedOption",option)
6585 }
6586 fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
6587 FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
6588 if (fire != MagickFalse)
6589 FireImageStack(MagickFalse,MagickTrue,MagickTrue);
6590 }
6591 if (k != 0)
6592 ThrowMogrifyException(OptionError,"UnbalancedParenthesis",argv[i]);
6593 if (i != (ssize_t) argc)
6594 ThrowMogrifyException(OptionError,"MissingAnImageFilename",argv[i]);
6595 DestroyMogrify();
6596 return(status != 0 ? MagickTrue : MagickFalse);
6597}
6598␌
6599/*
6600%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6601% %
6602% %
6603% %
6604+ M o g r i f y I m a g e I n f o %
6605% %
6606% %
6607% %
6608%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6609%
6610% MogrifyImageInfo() applies image processing settings to the image as
6611% prescribed by command line options.
6612%
6613% The format of the MogrifyImageInfo method is:
6614%
6615% MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,const int argc,
6616% const char **argv,ExceptionInfo *exception)
6617%
6618% A description of each parameter follows:
6619%
6620% o image_info: the image info..
6621%
6622% o argc: Specifies a pointer to an integer describing the number of
6623% elements in the argument vector.
6624%
6625% o argv: Specifies a pointer to a text array containing the command line
6626% arguments.
6627%
6628% o exception: return any errors or warnings in this structure.
6629%
6630*/
6631WandExport MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,
6632 const int argc,const char **argv,ExceptionInfo *exception)
6633{
6634 const char
6635 *option;
6636
6637 GeometryInfo
6638 geometry_info;
6639
6640 ssize_t
6641 count;
6642
6643 ssize_t
6644 i;
6645
6646 /*
6647 Initialize method variables.
6648 */
6649 assert(image_info != (ImageInfo *) NULL);
6650 assert(image_info->signature == MagickCoreSignature);
6651 if (IsEventLogging() != MagickFalse)
6652 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
6653 image_info->filename);
6654 if (argc < 0)
6655 return(MagickTrue);
6656 /*
6657 Set the image settings.
6658 */
6659 for (i=0; i < (ssize_t) argc; i++)
6660 {
6661 option=argv[i];
6662 if (IsCommandOption(option) == MagickFalse)
6663 continue;
6664 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
6665 count=MagickMax(count,0L);
6666 if ((i+count) >= (ssize_t) argc)
6667 break;
6668 switch (*(option+1))
6669 {
6670 case 'a':
6671 {
6672 if (LocaleCompare("adjoin",option+1) == 0)
6673 {
6674 image_info->adjoin=(*option == '-') ? MagickTrue : MagickFalse;
6675 break;
6676 }
6677 if (LocaleCompare("antialias",option+1) == 0)
6678 {
6679 image_info->antialias=(*option == '-') ? MagickTrue : MagickFalse;
6680 break;
6681 }
6682 if (LocaleCompare("authenticate",option+1) == 0)
6683 {
6684 if (*option == '+')
6685 (void) DeleteImageOption(image_info,option+1);
6686 else
6687 (void) SetImageOption(image_info,option+1,argv[i+1]);
6688 break;
6689 }
6690 break;
6691 }
6692 case 'b':
6693 {
6694 if (LocaleCompare("background",option+1) == 0)
6695 {
6696 if (*option == '+')
6697 {
6698 (void) DeleteImageOption(image_info,option+1);
6699 (void) QueryColorCompliance(MogrifyBackgroundColor,
6700 AllCompliance,&image_info->background_color,exception);
6701 break;
6702 }
6703 (void) SetImageOption(image_info,option+1,argv[i+1]);
6704 (void) QueryColorCompliance(argv[i+1],AllCompliance,
6705 &image_info->background_color,exception);
6706 break;
6707 }
6708 if (LocaleCompare("bias",option+1) == 0)
6709 {
6710 if (*option == '+')
6711 {
6712 (void) SetImageOption(image_info,"convolve:bias","0.0");
6713 break;
6714 }
6715 (void) SetImageOption(image_info,"convolve:bias",argv[i+1]);
6716 break;
6717 }
6718 if (LocaleCompare("black-point-compensation",option+1) == 0)
6719 {
6720 if (*option == '+')
6721 {
6722 (void) SetImageOption(image_info,option+1,"false");
6723 break;
6724 }
6725 (void) SetImageOption(image_info,option+1,"true");
6726 break;
6727 }
6728 if (LocaleCompare("blue-primary",option+1) == 0)
6729 {
6730 if (*option == '+')
6731 {
6732 (void) SetImageOption(image_info,option+1,"0.0");
6733 break;
6734 }
6735 (void) SetImageOption(image_info,option+1,argv[i+1]);
6736 break;
6737 }
6738 if (LocaleCompare("bordercolor",option+1) == 0)
6739 {
6740 if (*option == '+')
6741 {
6742 (void) DeleteImageOption(image_info,option+1);
6743 (void) QueryColorCompliance(MogrifyBorderColor,AllCompliance,
6744 &image_info->border_color,exception);
6745 break;
6746 }
6747 (void) QueryColorCompliance(argv[i+1],AllCompliance,
6748 &image_info->border_color,exception);
6749 (void) SetImageOption(image_info,option+1,argv[i+1]);
6750 break;
6751 }
6752 if (LocaleCompare("box",option+1) == 0)
6753 {
6754 if (*option == '+')
6755 {
6756 (void) SetImageOption(image_info,"undercolor","none");
6757 break;
6758 }
6759 (void) SetImageOption(image_info,"undercolor",argv[i+1]);
6760 break;
6761 }
6762 break;
6763 }
6764 case 'c':
6765 {
6766 if (LocaleCompare("cache",option+1) == 0)
6767 {
6768 MagickSizeType
6769 limit;
6770
6771 limit=MagickResourceInfinity;
6772 if (LocaleCompare("unlimited",argv[i+1]) != 0)
6773 limit=(MagickSizeType) SiPrefixToDoubleInterval(argv[i+1],
6774 100.0);
6775 (void) SetMagickResourceLimit(MemoryResource,limit);
6776 (void) SetMagickResourceLimit(MapResource,2*limit);
6777 break;
6778 }
6779 if (LocaleCompare("caption",option+1) == 0)
6780 {
6781 if (*option == '+')
6782 {
6783 (void) DeleteImageOption(image_info,option+1);
6784 break;
6785 }
6786 (void) SetImageOption(image_info,option+1,argv[i+1]);
6787 break;
6788 }
6789 if (LocaleCompare("colorspace",option+1) == 0)
6790 {
6791 if (*option == '+')
6792 {
6793 image_info->colorspace=UndefinedColorspace;
6794 (void) SetImageOption(image_info,option+1,"undefined");
6795 break;
6796 }
6797 image_info->colorspace=(ColorspaceType) ParseCommandOption(
6798 MagickColorspaceOptions,MagickFalse,argv[i+1]);
6799 (void) SetImageOption(image_info,option+1,argv[i+1]);
6800 break;
6801 }
6802 if (LocaleCompare("comment",option+1) == 0)
6803 {
6804 if (*option == '+')
6805 {
6806 (void) DeleteImageOption(image_info,option+1);
6807 break;
6808 }
6809 (void) SetImageOption(image_info,option+1,argv[i+1]);
6810 break;
6811 }
6812 if (LocaleCompare("compose",option+1) == 0)
6813 {
6814 if (*option == '+')
6815 {
6816 (void) SetImageOption(image_info,option+1,"undefined");
6817 break;
6818 }
6819 (void) SetImageOption(image_info,option+1,argv[i+1]);
6820 break;
6821 }
6822 if (LocaleCompare("compress",option+1) == 0)
6823 {
6824 if (*option == '+')
6825 {
6826 image_info->compression=UndefinedCompression;
6827 (void) SetImageOption(image_info,option+1,"undefined");
6828 break;
6829 }
6830 image_info->compression=(CompressionType) ParseCommandOption(
6831 MagickCompressOptions,MagickFalse,argv[i+1]);
6832 (void) SetImageOption(image_info,option+1,argv[i+1]);
6833 break;
6834 }
6835 break;
6836 }
6837 case 'd':
6838 {
6839 if (LocaleCompare("debug",option+1) == 0)
6840 {
6841 if (*option == '+')
6842 (void) SetLogEventMask("none");
6843 else
6844 (void) SetLogEventMask(argv[i+1]);
6845 image_info->debug=IsEventLogging();
6846 break;
6847 }
6848 if (LocaleCompare("define",option+1) == 0)
6849 {
6850 if (*option == '+')
6851 {
6852 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6853 (void) DeleteImageRegistry(argv[i+1]+9);
6854 else
6855 (void) DeleteImageOption(image_info,argv[i+1]);
6856 break;
6857 }
6858 if (LocaleNCompare(argv[i+1],"registry:",9) == 0)
6859 {
6860 (void) DefineImageRegistry(StringRegistryType,argv[i+1]+9,
6861 exception);
6862 break;
6863 }
6864 (void) DefineImageOption(image_info,argv[i+1]);
6865 break;
6866 }
6867 if (LocaleCompare("delay",option+1) == 0)
6868 {
6869 if (*option == '+')
6870 {
6871 (void) SetImageOption(image_info,option+1,"0");
6872 break;
6873 }
6874 (void) SetImageOption(image_info,option+1,argv[i+1]);
6875 break;
6876 }
6877 if (LocaleCompare("density",option+1) == 0)
6878 {
6879 /*
6880 Set image density.
6881 */
6882 if (*option == '+')
6883 {
6884 if (image_info->density != (char *) NULL)
6885 image_info->density=DestroyString(image_info->density);
6886 (void) SetImageOption(image_info,option+1,"72");
6887 break;
6888 }
6889 (void) CloneString(&image_info->density,argv[i+1]);
6890 (void) SetImageOption(image_info,option+1,argv[i+1]);
6891 break;
6892 }
6893 if (LocaleCompare("depth",option+1) == 0)
6894 {
6895 if (*option == '+')
6896 {
6897 image_info->depth=MAGICKCORE_QUANTUM_DEPTH;
6898 break;
6899 }
6900 image_info->depth=StringToUnsignedLong(argv[i+1]);
6901 break;
6902 }
6903 if (LocaleCompare("direction",option+1) == 0)
6904 {
6905 if (*option == '+')
6906 {
6907 (void) SetImageOption(image_info,option+1,"undefined");
6908 break;
6909 }
6910 (void) SetImageOption(image_info,option+1,argv[i+1]);
6911 break;
6912 }
6913 if (LocaleCompare("display",option+1) == 0)
6914 {
6915 if (*option == '+')
6916 {
6917 if (image_info->server_name != (char *) NULL)
6918 image_info->server_name=DestroyString(
6919 image_info->server_name);
6920 break;
6921 }
6922 (void) CloneString(&image_info->server_name,argv[i+1]);
6923 break;
6924 }
6925 if (LocaleCompare("dispose",option+1) == 0)
6926 {
6927 if (*option == '+')
6928 {
6929 (void) SetImageOption(image_info,option+1,"undefined");
6930 break;
6931 }
6932 (void) SetImageOption(image_info,option+1,argv[i+1]);
6933 break;
6934 }
6935 if (LocaleCompare("dither",option+1) == 0)
6936 {
6937 if (*option == '+')
6938 {
6939 image_info->dither=MagickFalse;
6940 (void) SetImageOption(image_info,option+1,"none");
6941 break;
6942 }
6943 (void) SetImageOption(image_info,option+1,argv[i+1]);
6944 image_info->dither=MagickTrue;
6945 break;
6946 }
6947 break;
6948 }
6949 case 'e':
6950 {
6951 if (LocaleCompare("encoding",option+1) == 0)
6952 {
6953 if (*option == '+')
6954 {
6955 (void) SetImageOption(image_info,option+1,"undefined");
6956 break;
6957 }
6958 (void) SetImageOption(image_info,option+1,argv[i+1]);
6959 break;
6960 }
6961 if (LocaleCompare("endian",option+1) == 0)
6962 {
6963 if (*option == '+')
6964 {
6965 image_info->endian=UndefinedEndian;
6966 (void) SetImageOption(image_info,option+1,"undefined");
6967 break;
6968 }
6969 image_info->endian=(EndianType) ParseCommandOption(
6970 MagickEndianOptions,MagickFalse,argv[i+1]);
6971 (void) SetImageOption(image_info,option+1,argv[i+1]);
6972 break;
6973 }
6974 if (LocaleCompare("extract",option+1) == 0)
6975 {
6976 /*
6977 Set image extract geometry.
6978 */
6979 if (*option == '+')
6980 {
6981 if (image_info->extract != (char *) NULL)
6982 image_info->extract=DestroyString(image_info->extract);
6983 break;
6984 }
6985 (void) CloneString(&image_info->extract,argv[i+1]);
6986 break;
6987 }
6988 break;
6989 }
6990 case 'f':
6991 {
6992 if (LocaleCompare("family",option+1) == 0)
6993 {
6994 if (*option != '+')
6995 (void) SetImageOption(image_info,option+1,argv[i+1]);
6996 break;
6997 }
6998 if (LocaleCompare("fill",option+1) == 0)
6999 {
7000 if (*option == '+')
7001 {
7002 (void) SetImageOption(image_info,option+1,"none");
7003 break;
7004 }
7005 (void) SetImageOption(image_info,option+1,argv[i+1]);
7006 break;
7007 }
7008 if (LocaleCompare("filter",option+1) == 0)
7009 {
7010 if (*option == '+')
7011 {
7012 (void) SetImageOption(image_info,option+1,"undefined");
7013 break;
7014 }
7015 (void) SetImageOption(image_info,option+1,argv[i+1]);
7016 break;
7017 }
7018 if (LocaleCompare("font",option+1) == 0)
7019 {
7020 if (*option == '+')
7021 {
7022 if (image_info->font != (char *) NULL)
7023 image_info->font=DestroyString(image_info->font);
7024 break;
7025 }
7026 (void) CloneString(&image_info->font,argv[i+1]);
7027 break;
7028 }
7029 if (LocaleCompare("format",option+1) == 0)
7030 {
7031 (void) SetImageOption(image_info,option+1,argv[i+1]);
7032 break;
7033 }
7034 if (LocaleCompare("fuzz",option+1) == 0)
7035 {
7036 if (*option == '+')
7037 {
7038 image_info->fuzz=0.0;
7039 (void) SetImageOption(image_info,option+1,"0");
7040 break;
7041 }
7042 image_info->fuzz=StringToDoubleInterval(argv[i+1],(double)
7043 QuantumRange+1.0);
7044 (void) SetImageOption(image_info,option+1,argv[i+1]);
7045 break;
7046 }
7047 break;
7048 }
7049 case 'g':
7050 {
7051 if (LocaleCompare("gravity",option+1) == 0)
7052 {
7053 if (*option == '+')
7054 {
7055 (void) SetImageOption(image_info,option+1,"undefined");
7056 break;
7057 }
7058 (void) SetImageOption(image_info,option+1,argv[i+1]);
7059 break;
7060 }
7061 if (LocaleCompare("green-primary",option+1) == 0)
7062 {
7063 if (*option == '+')
7064 {
7065 (void) SetImageOption(image_info,option+1,"0.0");
7066 break;
7067 }
7068 (void) SetImageOption(image_info,option+1,argv[i+1]);
7069 break;
7070 }
7071 break;
7072 }
7073 case 'i':
7074 {
7075 if (LocaleCompare("intensity",option+1) == 0)
7076 {
7077 if (*option == '+')
7078 {
7079 (void) SetImageOption(image_info,option+1,"undefined");
7080 break;
7081 }
7082 (void) SetImageOption(image_info,option+1,argv[i+1]);
7083 break;
7084 }
7085 if (LocaleCompare("intent",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("interlace",option+1) == 0)
7096 {
7097 if (*option == '+')
7098 {
7099 image_info->interlace=UndefinedInterlace;
7100 (void) SetImageOption(image_info,option+1,"undefined");
7101 break;
7102 }
7103 image_info->interlace=(InterlaceType) ParseCommandOption(
7104 MagickInterlaceOptions,MagickFalse,argv[i+1]);
7105 (void) SetImageOption(image_info,option+1,argv[i+1]);
7106 break;
7107 }
7108 if (LocaleCompare("interline-spacing",option+1) == 0)
7109 {
7110 if (*option == '+')
7111 {
7112 (void) SetImageOption(image_info,option+1,"undefined");
7113 break;
7114 }
7115 (void) SetImageOption(image_info,option+1,argv[i+1]);
7116 break;
7117 }
7118 if (LocaleCompare("interpolate",option+1) == 0)
7119 {
7120 if (*option == '+')
7121 {
7122 (void) SetImageOption(image_info,option+1,"undefined");
7123 break;
7124 }
7125 (void) SetImageOption(image_info,option+1,argv[i+1]);
7126 break;
7127 }
7128 if (LocaleCompare("interword-spacing",option+1) == 0)
7129 {
7130 if (*option == '+')
7131 {
7132 (void) SetImageOption(image_info,option+1,"undefined");
7133 break;
7134 }
7135 (void) SetImageOption(image_info,option+1,argv[i+1]);
7136 break;
7137 }
7138 break;
7139 }
7140 case 'k':
7141 {
7142 if (LocaleCompare("kerning",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 break;
7153 }
7154 case 'l':
7155 {
7156 if (LocaleCompare("label",option+1) == 0)
7157 {
7158 if (*option == '+')
7159 {
7160 (void) DeleteImageOption(image_info,option+1);
7161 break;
7162 }
7163 (void) SetImageOption(image_info,option+1,argv[i+1]);
7164 break;
7165 }
7166 if (LocaleCompare("limit",option+1) == 0)
7167 {
7168 MagickSizeType
7169 limit;
7170
7171 ResourceType
7172 type;
7173
7174 if (*option == '+')
7175 break;
7176 type=(ResourceType) ParseCommandOption(MagickResourceOptions,
7177 MagickFalse,argv[i+1]);
7178 limit=MagickResourceInfinity;
7179 if (LocaleCompare("unlimited",argv[i+2]) != 0)
7180 limit=(MagickSizeType) SiPrefixToDoubleInterval(argv[i+2],100.0);
7181 if (type == TimeResource)
7182 limit=(MagickSizeType) ParseMagickTimeToLive(argv[i+2]);
7183 (void) SetMagickResourceLimit(type,limit);
7184 break;
7185 }
7186 if (LocaleCompare("list",option+1) == 0)
7187 {
7188 ssize_t
7189 list;
7190
7191 /*
7192 Display configuration list.
7193 */
7194 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i+1]);
7195 switch (list)
7196 {
7197 case MagickCoderOptions:
7198 {
7199 (void) ListCoderInfo((FILE *) NULL,exception);
7200 break;
7201 }
7202 case MagickColorOptions:
7203 {
7204 (void) ListColorInfo((FILE *) NULL,exception);
7205 break;
7206 }
7207 case MagickConfigureOptions:
7208 {
7209 (void) ListConfigureInfo((FILE *) NULL,exception);
7210 break;
7211 }
7212 case MagickDelegateOptions:
7213 {
7214 (void) ListDelegateInfo((FILE *) NULL,exception);
7215 break;
7216 }
7217 case MagickFontOptions:
7218 {
7219 (void) ListTypeInfo((FILE *) NULL,exception);
7220 break;
7221 }
7222 case MagickFormatOptions:
7223 {
7224 (void) ListMagickInfo((FILE *) NULL,exception);
7225 break;
7226 }
7227 case MagickLocaleOptions:
7228 {
7229 (void) ListLocaleInfo((FILE *) NULL,exception);
7230 break;
7231 }
7232 case MagickLogOptions:
7233 {
7234 (void) ListLogInfo((FILE *) NULL,exception);
7235 break;
7236 }
7237 case MagickMagicOptions:
7238 {
7239 (void) ListMagicInfo((FILE *) NULL,exception);
7240 break;
7241 }
7242 case MagickMimeOptions:
7243 {
7244 (void) ListMimeInfo((FILE *) NULL,exception);
7245 break;
7246 }
7247 case MagickModuleOptions:
7248 {
7249 (void) ListModuleInfo((FILE *) NULL,exception);
7250 break;
7251 }
7252 case MagickPagesizeOptions:
7253 {
7254 (void) ListPagesizes((FILE *) NULL,exception);
7255 break;
7256 }
7257 case MagickPolicyOptions:
7258 {
7259 (void) ListPolicyInfo((FILE *) NULL,exception);
7260 break;
7261 }
7262 case MagickResourceOptions:
7263 {
7264 (void) ListMagickResourceInfo((FILE *) NULL,exception);
7265 break;
7266 }
7267 case MagickThresholdOptions:
7268 {
7269 (void) ListThresholdMaps((FILE *) NULL,exception);
7270 break;
7271 }
7272 default:
7273 {
7274 (void) ListCommandOptions((FILE *) NULL,(CommandOption) list,
7275 exception);
7276 break;
7277 }
7278 }
7279 break;
7280 }
7281 if (LocaleCompare("log",option+1) == 0)
7282 {
7283 if (*option == '+')
7284 break;
7285 (void) SetLogFormat(argv[i+1]);
7286 break;
7287 }
7288 if (LocaleCompare("loop",option+1) == 0)
7289 {
7290 if (*option == '+')
7291 {
7292 (void) SetImageOption(image_info,option+1,"0");
7293 break;
7294 }
7295 (void) SetImageOption(image_info,option+1,argv[i+1]);
7296 break;
7297 }
7298 break;
7299 }
7300 case 'm':
7301 {
7302 if (LocaleCompare("matte",option+1) == 0)
7303 {
7304 if (*option == '+')
7305 {
7306 (void) SetImageOption(image_info,option+1,"false");
7307 break;
7308 }
7309 (void) SetImageOption(image_info,option+1,"true");
7310 break;
7311 }
7312 if (LocaleCompare("mattecolor",option+1) == 0)
7313 {
7314 if (*option == '+')
7315 {
7316 (void) SetImageOption(image_info,option+1,argv[i+1]);
7317 (void) QueryColorCompliance(MogrifyAlphaColor,AllCompliance,
7318 &image_info->matte_color,exception);
7319 break;
7320 }
7321 (void) SetImageOption(image_info,option+1,argv[i+1]);
7322 (void) QueryColorCompliance(argv[i+1],AllCompliance,
7323 &image_info->matte_color,exception);
7324 break;
7325 }
7326 if (LocaleCompare("metric",option+1) == 0)
7327 {
7328 if (*option == '+')
7329 (void) DeleteImageOption(image_info,option+1);
7330 else
7331 (void) SetImageOption(image_info,option+1,argv[i+1]);
7332 break;
7333 }
7334 if (LocaleCompare("monitor",option+1) == 0)
7335 {
7336 (void) SetImageInfoProgressMonitor(image_info,MonitorProgress,
7337 (void *) NULL);
7338 break;
7339 }
7340 if (LocaleCompare("monochrome",option+1) == 0)
7341 {
7342 image_info->monochrome=(*option == '-') ? MagickTrue : MagickFalse;
7343 break;
7344 }
7345 break;
7346 }
7347 case 'o':
7348 {
7349 if (LocaleCompare("orient",option+1) == 0)
7350 {
7351 if (*option == '+')
7352 {
7353 image_info->orientation=UndefinedOrientation;
7354 (void) SetImageOption(image_info,option+1,"undefined");
7355 break;
7356 }
7357 image_info->orientation=(OrientationType) ParseCommandOption(
7358 MagickOrientationOptions,MagickFalse,argv[i+1]);
7359 (void) SetImageOption(image_info,option+1,argv[i+1]);
7360 break;
7361 }
7362 break;
7363 }
7364 case 'p':
7365 {
7366 if (LocaleCompare("page",option+1) == 0)
7367 {
7368 char
7369 *canonical_page,
7370 page[MagickPathExtent];
7371
7372 const char
7373 *image_option;
7374
7375 MagickStatusType
7376 flags;
7377
7378 RectangleInfo
7379 geometry;
7380
7381 if (*option == '+')
7382 {
7383 (void) DeleteImageOption(image_info,option+1);
7384 (void) CloneString(&image_info->page,(char *) NULL);
7385 break;
7386 }
7387 (void) memset(&geometry,0,sizeof(geometry));
7388 image_option=GetImageOption(image_info,"page");
7389 if (image_option != (const char *) NULL)
7390 flags=ParseAbsoluteGeometry(image_option,&geometry);
7391 canonical_page=GetPageGeometry(argv[i+1]);
7392 flags=ParseAbsoluteGeometry(canonical_page,&geometry);
7393 canonical_page=DestroyString(canonical_page);
7394 (void) FormatLocaleString(page,MagickPathExtent,"%lux%lu",
7395 (unsigned long) geometry.width,(unsigned long) geometry.height);
7396 if (((flags & XValue) != 0) || ((flags & YValue) != 0))
7397 (void) FormatLocaleString(page,MagickPathExtent,"%lux%lu%+ld%+ld",
7398 (unsigned long) geometry.width,(unsigned long) geometry.height,
7399 (long) geometry.x,(long) geometry.y);
7400 (void) SetImageOption(image_info,option+1,page);
7401 (void) CloneString(&image_info->page,page);
7402 break;
7403 }
7404 if (LocaleCompare("ping",option+1) == 0)
7405 {
7406 image_info->ping=(*option == '-') ? MagickTrue : MagickFalse;
7407 break;
7408 }
7409 if (LocaleCompare("pointsize",option+1) == 0)
7410 {
7411 if (*option == '+')
7412 geometry_info.rho=0.0;
7413 else
7414 (void) ParseGeometry(argv[i+1],&geometry_info);
7415 image_info->pointsize=geometry_info.rho;
7416 break;
7417 }
7418 if (LocaleCompare("precision",option+1) == 0)
7419 {
7420 (void) SetMagickPrecision(StringToInteger(argv[i+1]));
7421 break;
7422 }
7423 break;
7424 }
7425 case 'q':
7426 {
7427 if (LocaleCompare("quality",option+1) == 0)
7428 {
7429 /*
7430 Set image compression quality.
7431 */
7432 if (*option == '+')
7433 {
7434 image_info->quality=UndefinedCompressionQuality;
7435 (void) SetImageOption(image_info,option+1,"0");
7436 break;
7437 }
7438 image_info->quality=StringToUnsignedLong(argv[i+1]);
7439 (void) SetImageOption(image_info,option+1,argv[i+1]);
7440 break;
7441 }
7442 if (LocaleCompare("quiet",option+1) == 0)
7443 {
7444 static WarningHandler
7445 warning_handler = (WarningHandler) NULL;
7446
7447 if (*option == '+')
7448 {
7449 /*
7450 Restore error or warning messages.
7451 */
7452 warning_handler=SetWarningHandler(warning_handler);
7453 break;
7454 }
7455 /*
7456 Suppress error or warning messages.
7457 */
7458 warning_handler=SetWarningHandler((WarningHandler) NULL);
7459 break;
7460 }
7461 break;
7462 }
7463 case 'r':
7464 {
7465 if (LocaleCompare("red-primary",option+1) == 0)
7466 {
7467 if (*option == '+')
7468 {
7469 (void) SetImageOption(image_info,option+1,"0.0");
7470 break;
7471 }
7472 (void) SetImageOption(image_info,option+1,argv[i+1]);
7473 break;
7474 }
7475 break;
7476 }
7477 case 's':
7478 {
7479 if (LocaleCompare("sampling-factor",option+1) == 0)
7480 {
7481 /*
7482 Set image sampling factor.
7483 */
7484 if (*option == '+')
7485 {
7486 if (image_info->sampling_factor != (char *) NULL)
7487 image_info->sampling_factor=DestroyString(
7488 image_info->sampling_factor);
7489 break;
7490 }
7491 (void) CloneString(&image_info->sampling_factor,argv[i+1]);
7492 break;
7493 }
7494 if (LocaleCompare("scene",option+1) == 0)
7495 {
7496 /*
7497 Set image scene.
7498 */
7499 if (*option == '+')
7500 {
7501 image_info->scene=0;
7502 (void) SetImageOption(image_info,option+1,"0");
7503 break;
7504 }
7505 image_info->scene=StringToUnsignedLong(argv[i+1]);
7506 (void) SetImageOption(image_info,option+1,argv[i+1]);
7507 break;
7508 }
7509 if (LocaleCompare("seed",option+1) == 0)
7510 {
7511 unsigned long
7512 seed;
7513
7514 if (*option == '+')
7515 {
7516 seed=(unsigned long) time((time_t *) NULL);
7517 SetRandomSecretKey(seed);
7518 break;
7519 }
7520 seed=StringToUnsignedLong(argv[i+1]);
7521 SetRandomSecretKey(seed);
7522 break;
7523 }
7524 if (LocaleCompare("size",option+1) == 0)
7525 {
7526 if (*option == '+')
7527 {
7528 if (image_info->size != (char *) NULL)
7529 image_info->size=DestroyString(image_info->size);
7530 break;
7531 }
7532 (void) CloneString(&image_info->size,argv[i+1]);
7533 break;
7534 }
7535 if (LocaleCompare("stroke",option+1) == 0)
7536 {
7537 if (*option == '+')
7538 {
7539 (void) SetImageOption(image_info,option+1,"none");
7540 break;
7541 }
7542 (void) SetImageOption(image_info,option+1,argv[i+1]);
7543 break;
7544 }
7545 if (LocaleCompare("strokewidth",option+1) == 0)
7546 {
7547 if (*option == '+')
7548 (void) SetImageOption(image_info,option+1,"0");
7549 else
7550 (void) SetImageOption(image_info,option+1,argv[i+1]);
7551 break;
7552 }
7553 if (LocaleCompare("style",option+1) == 0)
7554 {
7555 if (*option == '+')
7556 {
7557 (void) SetImageOption(image_info,option+1,"none");
7558 break;
7559 }
7560 (void) SetImageOption(image_info,option+1,argv[i+1]);
7561 break;
7562 }
7563 if (LocaleCompare("synchronize",option+1) == 0)
7564 {
7565 if (*option == '+')
7566 {
7567 image_info->synchronize=MagickFalse;
7568 break;
7569 }
7570 image_info->synchronize=MagickTrue;
7571 break;
7572 }
7573 break;
7574 }
7575 case 't':
7576 {
7577 if (LocaleCompare("taint",option+1) == 0)
7578 {
7579 if (*option == '+')
7580 {
7581 (void) SetImageOption(image_info,option+1,"false");
7582 break;
7583 }
7584 (void) SetImageOption(image_info,option+1,"true");
7585 break;
7586 }
7587 if (LocaleCompare("texture",option+1) == 0)
7588 {
7589 if (*option == '+')
7590 {
7591 if (image_info->texture != (char *) NULL)
7592 image_info->texture=DestroyString(image_info->texture);
7593 break;
7594 }
7595 (void) CloneString(&image_info->texture,argv[i+1]);
7596 break;
7597 }
7598 if (LocaleCompare("tile-offset",option+1) == 0)
7599 {
7600 if (*option == '+')
7601 (void) SetImageOption(image_info,option+1,"0");
7602 else
7603 (void) SetImageOption(image_info,option+1,argv[i+1]);
7604 break;
7605 }
7606 if (LocaleCompare("transparent-color",option+1) == 0)
7607 {
7608 if (*option == '+')
7609 {
7610 (void) QueryColorCompliance("none",AllCompliance,
7611 &image_info->transparent_color,exception);
7612 (void) SetImageOption(image_info,option+1,"none");
7613 break;
7614 }
7615 (void) QueryColorCompliance(argv[i+1],AllCompliance,
7616 &image_info->transparent_color,exception);
7617 (void) SetImageOption(image_info,option+1,argv[i+1]);
7618 break;
7619 }
7620 if (LocaleCompare("type",option+1) == 0)
7621 {
7622 if (*option == '+')
7623 {
7624 image_info->type=UndefinedType;
7625 (void) SetImageOption(image_info,option+1,"undefined");
7626 break;
7627 }
7628 image_info->type=(ImageType) ParseCommandOption(MagickTypeOptions,
7629 MagickFalse,argv[i+1]);
7630 (void) SetImageOption(image_info,option+1,argv[i+1]);
7631 break;
7632 }
7633 break;
7634 }
7635 case 'u':
7636 {
7637 if (LocaleCompare("undercolor",option+1) == 0)
7638 {
7639 if (*option == '+')
7640 (void) DeleteImageOption(image_info,option+1);
7641 else
7642 (void) SetImageOption(image_info,option+1,argv[i+1]);
7643 break;
7644 }
7645 if (LocaleCompare("units",option+1) == 0)
7646 {
7647 if (*option == '+')
7648 {
7649 image_info->units=UndefinedResolution;
7650 (void) SetImageOption(image_info,option+1,"undefined");
7651 break;
7652 }
7653 image_info->units=(ResolutionType) ParseCommandOption(
7654 MagickResolutionOptions,MagickFalse,argv[i+1]);
7655 (void) SetImageOption(image_info,option+1,argv[i+1]);
7656 break;
7657 }
7658 break;
7659 }
7660 case 'v':
7661 {
7662 if (LocaleCompare("verbose",option+1) == 0)
7663 {
7664 if (*option == '+')
7665 {
7666 image_info->verbose=MagickFalse;
7667 break;
7668 }
7669 image_info->verbose=MagickTrue;
7670 image_info->ping=MagickFalse;
7671 break;
7672 }
7673 if (LocaleCompare("virtual-pixel",option+1) == 0)
7674 {
7675 if (*option == '+')
7676 (void) SetImageOption(image_info,option+1,"undefined");
7677 else
7678 (void) SetImageOption(image_info,option+1,argv[i+1]);
7679 break;
7680 }
7681 break;
7682 }
7683 case 'w':
7684 {
7685 if (LocaleCompare("weight",option+1) == 0)
7686 {
7687 if (*option == '+')
7688 (void) SetImageOption(image_info,option+1,"0");
7689 else
7690 (void) SetImageOption(image_info,option+1,argv[i+1]);
7691 break;
7692 }
7693 if (LocaleCompare("white-point",option+1) == 0)
7694 {
7695 if (*option == '+')
7696 (void) SetImageOption(image_info,option+1,"0.0");
7697 else
7698 (void) SetImageOption(image_info,option+1,argv[i+1]);
7699 break;
7700 }
7701 if (LocaleCompare("word-break",option+1) == 0)
7702 {
7703 if (*option == '+')
7704 {
7705 (void) SetImageOption(image_info,option+1,"undefined");
7706 break;
7707 }
7708 (void) SetImageOption(image_info,option+1,argv[i+1]);
7709 break;
7710 }
7711 break;
7712 }
7713 default:
7714 break;
7715 }
7716 i+=count;
7717 }
7718 return(MagickTrue);
7719}
7720␌
7721/*
7722%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7723% %
7724% %
7725% %
7726+ M o g r i f y I m a g e L i s t %
7727% %
7728% %
7729% %
7730%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7731%
7732% MogrifyImageList() applies any command line options that might affect the
7733% entire image list (e.g. -append, -coalesce, etc.).
7734%
7735% The format of the MogrifyImage method is:
7736%
7737% MagickBooleanType MogrifyImageList(ImageInfo *image_info,const int argc,
7738% const char **argv,Image **images,ExceptionInfo *exception)
7739%
7740% A description of each parameter follows:
7741%
7742% o image_info: the image info..
7743%
7744% o argc: Specifies a pointer to an integer describing the number of
7745% elements in the argument vector.
7746%
7747% o argv: Specifies a pointer to a text array containing the command line
7748% arguments.
7749%
7750% o images: pointer to pointer of the first image in image list.
7751%
7752% o exception: return any errors or warnings in this structure.
7753%
7754*/
7755WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
7756 const int argc,const char **argv,Image **images,ExceptionInfo *exception)
7757{
7758 const char
7759 *option;
7760
7761 ImageInfo
7762 *mogrify_info;
7763
7764 MagickStatusType
7765 status;
7766
7767 PixelInterpolateMethod
7768 interpolate_method;
7769
7770 QuantizeInfo
7771 *quantize_info;
7772
7773 ssize_t
7774 i;
7775
7776 ssize_t
7777 count,
7778 index;
7779
7780 /*
7781 Apply options to the image list.
7782 */
7783 assert(image_info != (ImageInfo *) NULL);
7784 assert(image_info->signature == MagickCoreSignature);
7785 assert(images != (Image **) NULL);
7786 assert((*images)->previous == (Image *) NULL);
7787 assert((*images)->signature == MagickCoreSignature);
7788 if (IsEventLogging() != MagickFalse)
7789 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
7790 (*images)->filename);
7791 if ((argc <= 0) || (*argv == (char *) NULL))
7792 return(MagickTrue);
7793 interpolate_method=UndefinedInterpolatePixel;
7794 mogrify_info=CloneImageInfo(image_info);
7795 quantize_info=AcquireQuantizeInfo(mogrify_info);
7796 status=MagickTrue;
7797 for (i=0; i < (ssize_t) argc; i++)
7798 {
7799 if (*images == (Image *) NULL)
7800 break;
7801 option=argv[i];
7802 if (IsCommandOption(option) == MagickFalse)
7803 continue;
7804 count=ParseCommandOption(MagickCommandOptions,MagickFalse,option);
7805 count=MagickMax(count,0L);
7806 if ((i+count) >= (ssize_t) argc)
7807 break;
7808 status=MogrifyImageInfo(mogrify_info,(int) count+1,argv+i,exception);
7809 switch (*(option+1))
7810 {
7811 case 'a':
7812 {
7813 if (LocaleCompare("affinity",option+1) == 0)
7814 {
7815 (void) SyncImagesSettings(mogrify_info,*images,exception);
7816 if (*option == '+')
7817 {
7818 (void) RemapImages(quantize_info,*images,(Image *) NULL,
7819 exception);
7820 break;
7821 }
7822 i++;
7823 break;
7824 }
7825 if (LocaleCompare("append",option+1) == 0)
7826 {
7827 Image
7828 *append_image;
7829
7830 (void) SyncImagesSettings(mogrify_info,*images,exception);
7831 append_image=AppendImages(*images,*option == '-' ? MagickTrue :
7832 MagickFalse,exception);
7833 if (append_image == (Image *) NULL)
7834 {
7835 status=MagickFalse;
7836 break;
7837 }
7838 *images=DestroyImageList(*images);
7839 *images=append_image;
7840 break;
7841 }
7842 if (LocaleCompare("average",option+1) == 0)
7843 {
7844 Image
7845 *average_image;
7846
7847 /*
7848 Average an image sequence (deprecated).
7849 */
7850 (void) SyncImagesSettings(mogrify_info,*images,exception);
7851 average_image=EvaluateImages(*images,MeanEvaluateOperator,
7852 exception);
7853 if (average_image == (Image *) NULL)
7854 {
7855 status=MagickFalse;
7856 break;
7857 }
7858 *images=DestroyImageList(*images);
7859 *images=average_image;
7860 break;
7861 }
7862 break;
7863 }
7864 case 'c':
7865 {
7866 if (LocaleCompare("channel-fx",option+1) == 0)
7867 {
7868 Image
7869 *channel_image;
7870
7871 (void) SyncImagesSettings(mogrify_info,*images,exception);
7872 channel_image=ChannelFxImage(*images,argv[i+1],exception);
7873 if (channel_image == (Image *) NULL)
7874 {
7875 status=MagickFalse;
7876 break;
7877 }
7878 *images=DestroyImageList(*images);
7879 *images=channel_image;
7880 break;
7881 }
7882 if (LocaleCompare("clut",option+1) == 0)
7883 {
7884 Image
7885 *clut_image,
7886 *image;
7887
7888 (void) SyncImagesSettings(mogrify_info,*images,exception);
7889 image=RemoveFirstImageFromList(images);
7890 clut_image=RemoveFirstImageFromList(images);
7891 if (clut_image == (Image *) NULL)
7892 {
7893 (void) ThrowMagickException(exception,GetMagickModule(),
7894 OptionError,"ImageSequenceRequired","`%s'",option);
7895 image=DestroyImage(image);
7896 status=MagickFalse;
7897 break;
7898 }
7899 (void) ClutImage(image,clut_image,interpolate_method,exception);
7900 clut_image=DestroyImage(clut_image);
7901 *images=DestroyImageList(*images);
7902 *images=image;
7903 break;
7904 }
7905 if (LocaleCompare("coalesce",option+1) == 0)
7906 {
7907 Image
7908 *coalesce_image;
7909
7910 (void) SyncImagesSettings(mogrify_info,*images,exception);
7911 coalesce_image=CoalesceImages(*images,exception);
7912 if (coalesce_image == (Image *) NULL)
7913 {
7914 status=MagickFalse;
7915 break;
7916 }
7917 *images=DestroyImageList(*images);
7918 *images=coalesce_image;
7919 break;
7920 }
7921 if (LocaleCompare("combine",option+1) == 0)
7922 {
7923 ColorspaceType
7924 colorspace;
7925
7926 Image
7927 *combine_image;
7928
7929 (void) SyncImagesSettings(mogrify_info,*images,exception);
7930 colorspace=(*images)->colorspace;
7931 if ((*images)->number_channels < GetImageListLength(*images))
7932 colorspace=sRGBColorspace;
7933 if (*option == '+')
7934 colorspace=(ColorspaceType) ParseCommandOption(
7935 MagickColorspaceOptions,MagickFalse,argv[i+1]);
7936 combine_image=CombineImages(*images,colorspace,exception);
7937 if (combine_image == (Image *) NULL)
7938 {
7939 status=MagickFalse;
7940 break;
7941 }
7942 *images=DestroyImageList(*images);
7943 *images=combine_image;
7944 break;
7945 }
7946 if (LocaleCompare("compare",option+1) == 0)
7947 {
7948 double
7949 distortion;
7950
7951 Image
7952 *difference_image,
7953 *image,
7954 *reconstruct_image;
7955
7956 MetricType
7957 metric;
7958
7959 /*
7960 Mathematically and visually annotate the difference between an
7961 image and its reconstruction.
7962 */
7963 (void) SyncImagesSettings(mogrify_info,*images,exception);
7964 image=RemoveFirstImageFromList(images);
7965 reconstruct_image=RemoveFirstImageFromList(images);
7966 if (reconstruct_image == (Image *) NULL)
7967 {
7968 (void) ThrowMagickException(exception,GetMagickModule(),
7969 OptionError,"ImageSequenceRequired","`%s'",option);
7970 image=DestroyImage(image);
7971 status=MagickFalse;
7972 break;
7973 }
7974 metric=UndefinedErrorMetric;
7975 option=GetImageOption(mogrify_info,"metric");
7976 if (option != (const char *) NULL)
7977 metric=(MetricType) ParseCommandOption(MagickMetricOptions,
7978 MagickFalse,option);
7979 difference_image=CompareImages(image,reconstruct_image,metric,
7980 &distortion,exception);
7981 if (difference_image == (Image *) NULL)
7982 break;
7983 reconstruct_image=DestroyImage(reconstruct_image);
7984 image=DestroyImage(image);
7985 if (*images != (Image *) NULL)
7986 *images=DestroyImageList(*images);
7987 *images=difference_image;
7988 break;
7989 }
7990 if (LocaleCompare("complex",option+1) == 0)
7991 {
7992 ComplexOperator
7993 op;
7994
7995 Image
7996 *complex_images;
7997
7998 (void) SyncImageSettings(mogrify_info,*images,exception);
7999 op=(ComplexOperator) ParseCommandOption(MagickComplexOptions,
8000 MagickFalse,argv[i+1]);
8001 complex_images=ComplexImages(*images,op,exception);
8002 if (complex_images == (Image *) NULL)
8003 {
8004 status=MagickFalse;
8005 break;
8006 }
8007 *images=DestroyImageList(*images);
8008 *images=complex_images;
8009 break;
8010 }
8011 if (LocaleCompare("composite",option+1) == 0)
8012 {
8013 CompositeOperator
8014 compose;
8015
8016 const char*
8017 value;
8018
8019 MagickBooleanType
8020 clip_to_self;
8021
8022 Image
8023 *mask_image,
8024 *new_images,
8025 *source_image;
8026
8027 RectangleInfo
8028 geometry;
8029
8030 /* Compose value from "-compose" option only */
8031 (void) SyncImageSettings(mogrify_info,*images,exception);
8032 value=GetImageOption(mogrify_info,"compose");
8033 if (value == (const char *) NULL)
8034 compose=OverCompositeOp; /* use Over not source_image->compose */
8035 else
8036 compose=(CompositeOperator) ParseCommandOption(
8037 MagickComposeOptions,MagickFalse,value);
8038
8039 /* Get "clip-to-self" expert setting (false is normal) */
8040 clip_to_self=GetCompositeClipToSelf(compose);
8041 value=GetImageOption(mogrify_info,"compose:clip-to-self");
8042 if (value != (const char *) NULL)
8043 clip_to_self=IsStringTrue(value);
8044 value=GetImageOption(mogrify_info,"compose:outside-overlay");
8045 if (value != (const char *) NULL)
8046 clip_to_self=IsStringFalse(value); /* deprecated */
8047
8048 new_images=RemoveFirstImageFromList(images);
8049 source_image=RemoveFirstImageFromList(images);
8050 if (source_image == (Image *) NULL)
8051 {
8052 (void) ThrowMagickException(exception,GetMagickModule(),
8053 OptionError,"ImageSequenceRequired","`%s'",option);
8054 new_images=DestroyImage(new_images);
8055 status=MagickFalse;
8056 break;
8057 }
8058
8059 /* FUTURE: this should not be here! - should be part of -geometry */
8060 if (source_image->geometry != (char *) NULL)
8061 {
8062 RectangleInfo
8063 resize_geometry;
8064
8065 (void) ParseRegionGeometry(source_image,source_image->geometry,
8066 &resize_geometry,exception);
8067 if ((source_image->columns != resize_geometry.width) ||
8068 (source_image->rows != resize_geometry.height))
8069 {
8070 Image
8071 *resize_image;
8072
8073 resize_image=ResizeImage(source_image,resize_geometry.width,
8074 resize_geometry.height,source_image->filter,exception);
8075 if (resize_image != (Image *) NULL)
8076 {
8077 source_image=DestroyImage(source_image);
8078 source_image=resize_image;
8079 }
8080 }
8081 }
8082 SetGeometry(source_image,&geometry);
8083 (void) ParseAbsoluteGeometry(source_image->geometry,&geometry);
8084 GravityAdjustGeometry(new_images->columns,new_images->rows,
8085 new_images->gravity,&geometry);
8086 mask_image=RemoveFirstImageFromList(images);
8087 if (mask_image == (Image *) NULL)
8088 status&=(MagickStatusType) CompositeImage(new_images,source_image,
8089 compose,clip_to_self,geometry.x,geometry.y,exception);
8090 else
8091 {
8092 Image
8093 *canvas_image;
8094
8095 canvas_image=CloneImage(new_images,0,0,MagickTrue,exception);
8096 if (canvas_image == (Image *) NULL)
8097 break;
8098 switch (compose)
8099 {
8100 case BlendCompositeOp:
8101 {
8102 status&=(MagickStatusType) CompositeImage(new_images,
8103 source_image,compose,clip_to_self,geometry.x,geometry.y,
8104 exception);
8105 status&=(MagickStatusType) CompositeImage(new_images,
8106 mask_image,CopyAlphaCompositeOp,MagickTrue,0,0,exception);
8107 break;
8108 }
8109 case DisplaceCompositeOp:
8110 case DistortCompositeOp:
8111 {
8112 status&=(MagickStatusType) CompositeImage(source_image,
8113 mask_image,CopyGreenCompositeOp,MagickTrue,0,0,exception);
8114 (void) SetImageColorspace(source_image,sRGBColorspace,
8115 exception);
8116 status&=(MagickStatusType) CompositeImage(new_images,
8117 source_image,compose,clip_to_self,geometry.x,geometry.y,
8118 exception);
8119 break;
8120 }
8121 case SaliencyBlendCompositeOp:
8122 case SeamlessBlendCompositeOp:
8123 {
8124 status&=(MagickStatusType) CompositeImage(source_image,
8125 mask_image,CopyAlphaCompositeOp,MagickTrue,0,0,exception);
8126 status&=(MagickStatusType) CompositeImage(new_images,
8127 source_image,compose,clip_to_self,geometry.x,geometry.y,
8128 exception);
8129 break;
8130 }
8131 default:
8132 {
8133 Image
8134 *clone_image;
8135
8136 clone_image=CloneImage(new_images,0,0,MagickTrue,exception);
8137 if (clone_image == (Image *) NULL)
8138 break;
8139 status&=(MagickStatusType) CompositeImage(new_images,
8140 source_image,compose,clip_to_self,geometry.x,geometry.y,
8141 exception);
8142 status&=(MagickStatusType) CompositeImage(new_images,
8143 mask_image,CopyAlphaCompositeOp,MagickTrue,0,0,exception);
8144 status&=(MagickStatusType) CompositeImage(clone_image,
8145 new_images,OverCompositeOp,clip_to_self,0,0,exception);
8146 new_images=DestroyImageList(new_images);
8147 new_images=clone_image;
8148 break;
8149 }
8150 }
8151 switch (compose)
8152 {
8153 case DisplaceCompositeOp:
8154 case DistortCompositeOp:
8155 {
8156 status&=(MagickStatusType) CompositeImage(canvas_image,
8157 new_images,CopyCompositeOp,clip_to_self,0,0,exception);
8158 break;
8159 }
8160 default:
8161 {
8162 status&=(MagickStatusType) CompositeImage(canvas_image,
8163 new_images,OverCompositeOp,clip_to_self,0,0,exception);
8164 break;
8165 }
8166 }
8167 new_images=DestroyImageList(new_images);
8168 new_images=canvas_image;
8169 mask_image=DestroyImage(mask_image);
8170 }
8171 source_image=DestroyImage(source_image);
8172 *images=DestroyImageList(*images);
8173 *images=new_images;
8174 break;
8175 }
8176 if (LocaleCompare("copy",option+1) == 0)
8177 {
8178 Image
8179 *source_image;
8180
8181 OffsetInfo
8182 offset;
8183
8184 RectangleInfo
8185 geometry;
8186
8187 /*
8188 Copy image pixels.
8189 */
8190 (void) SyncImageSettings(mogrify_info,*images,exception);
8191 (void) ParsePageGeometry(*images,argv[i+2],&geometry,exception);
8192 offset.x=geometry.x;
8193 offset.y=geometry.y;
8194 source_image=(*images);
8195 if (source_image->next != (Image *) NULL)
8196 source_image=source_image->next;
8197 (void) ParsePageGeometry(source_image,argv[i+1],&geometry,
8198 exception);
8199 status=CopyImagePixels(*images,source_image,&geometry,&offset,
8200 exception);
8201 break;
8202 }
8203 break;
8204 }
8205 case 'd':
8206 {
8207 if (LocaleCompare("deconstruct",option+1) == 0)
8208 {
8209 Image
8210 *deconstruct_image;
8211
8212 (void) SyncImagesSettings(mogrify_info,*images,exception);
8213 deconstruct_image=CompareImagesLayers(*images,CompareAnyLayer,
8214 exception);
8215 if (deconstruct_image == (Image *) NULL)
8216 {
8217 status=MagickFalse;
8218 break;
8219 }
8220 *images=DestroyImageList(*images);
8221 *images=deconstruct_image;
8222 break;
8223 }
8224 if (LocaleCompare("delete",option+1) == 0)
8225 {
8226 if (*option == '+')
8227 DeleteImages(images,"-1",exception);
8228 else
8229 DeleteImages(images,argv[i+1],exception);
8230 break;
8231 }
8232 if (LocaleCompare("dither",option+1) == 0)
8233 {
8234 if (*option == '+')
8235 {
8236 quantize_info->dither_method=NoDitherMethod;
8237 break;
8238 }
8239 quantize_info->dither_method=(DitherMethod) ParseCommandOption(
8240 MagickDitherOptions,MagickFalse,argv[i+1]);
8241 break;
8242 }
8243 if (LocaleCompare("duplicate",option+1) == 0)
8244 {
8245 Image
8246 *duplicate_images;
8247
8248 if (*option == '+')
8249 duplicate_images=DuplicateImages(*images,1,"-1",exception);
8250 else
8251 {
8252 const char
8253 *p;
8254
8255 size_t
8256 number_duplicates;
8257
8258 number_duplicates=(size_t) StringToLong(argv[i+1]);
8259 p=strchr(argv[i+1],',');
8260 if (p == (const char *) NULL)
8261 duplicate_images=DuplicateImages(*images,number_duplicates,
8262 "-1",exception);
8263 else
8264 duplicate_images=DuplicateImages(*images,number_duplicates,
8265 p+1,exception);
8266 }
8267 AppendImageToList(images, duplicate_images);
8268 (void) SyncImagesSettings(mogrify_info,*images,exception);
8269 break;
8270 }
8271 break;
8272 }
8273 case 'e':
8274 {
8275 if (LocaleCompare("evaluate-sequence",option+1) == 0)
8276 {
8277 Image
8278 *evaluate_image;
8279
8280 MagickEvaluateOperator
8281 op;
8282
8283 (void) SyncImageSettings(mogrify_info,*images,exception);
8284 op=(MagickEvaluateOperator) ParseCommandOption(
8285 MagickEvaluateOptions,MagickFalse,argv[i+1]);
8286 evaluate_image=EvaluateImages(*images,op,exception);
8287 if (evaluate_image == (Image *) NULL)
8288 {
8289 status=MagickFalse;
8290 break;
8291 }
8292 *images=DestroyImageList(*images);
8293 *images=evaluate_image;
8294 break;
8295 }
8296 break;
8297 }
8298 case 'f':
8299 {
8300 if (LocaleCompare("fft",option+1) == 0)
8301 {
8302 Image
8303 *fourier_image;
8304
8305 /*
8306 Implements the discrete Fourier transform (DFT).
8307 */
8308 (void) SyncImageSettings(mogrify_info,*images,exception);
8309 fourier_image=ForwardFourierTransformImage(*images,*option == '-' ?
8310 MagickTrue : MagickFalse,exception);
8311 if (fourier_image == (Image *) NULL)
8312 break;
8313 *images=DestroyImageList(*images);
8314 *images=fourier_image;
8315 break;
8316 }
8317 if (LocaleCompare("flatten",option+1) == 0)
8318 {
8319 Image
8320 *flatten_image;
8321
8322 (void) SyncImagesSettings(mogrify_info,*images,exception);
8323 flatten_image=MergeImageLayers(*images,FlattenLayer,exception);
8324 if (flatten_image == (Image *) NULL)
8325 break;
8326 *images=DestroyImageList(*images);
8327 *images=flatten_image;
8328 break;
8329 }
8330 if (LocaleCompare("fx",option+1) == 0)
8331 {
8332 Image
8333 *fx_image;
8334
8335 (void) SyncImagesSettings(mogrify_info,*images,exception);
8336 fx_image=FxImage(*images,argv[i+1],exception);
8337 if (fx_image == (Image *) NULL)
8338 {
8339 status=MagickFalse;
8340 break;
8341 }
8342 *images=DestroyImageList(*images);
8343 *images=fx_image;
8344 break;
8345 }
8346 break;
8347 }
8348 case 'h':
8349 {
8350 if (LocaleCompare("hald-clut",option+1) == 0)
8351 {
8352 Image
8353 *hald_image,
8354 *image;
8355
8356 (void) SyncImagesSettings(mogrify_info,*images,exception);
8357 image=RemoveFirstImageFromList(images);
8358 hald_image=RemoveFirstImageFromList(images);
8359 if (hald_image == (Image *) NULL)
8360 {
8361 (void) ThrowMagickException(exception,GetMagickModule(),
8362 OptionError,"ImageSequenceRequired","`%s'",option);
8363 image=DestroyImage(image);
8364 status=MagickFalse;
8365 break;
8366 }
8367 (void) HaldClutImage(image,hald_image,exception);
8368 hald_image=DestroyImage(hald_image);
8369 if (*images != (Image *) NULL)
8370 *images=DestroyImageList(*images);
8371 *images=image;
8372 break;
8373 }
8374 break;
8375 }
8376 case 'i':
8377 {
8378 if (LocaleCompare("ift",option+1) == 0)
8379 {
8380 Image
8381 *fourier_image,
8382 *magnitude_image,
8383 *phase_image;
8384
8385 /*
8386 Implements the inverse fourier discrete Fourier transform (DFT).
8387 */
8388 (void) SyncImagesSettings(mogrify_info,*images,exception);
8389 magnitude_image=RemoveFirstImageFromList(images);
8390 phase_image=RemoveFirstImageFromList(images);
8391 if (phase_image == (Image *) NULL)
8392 {
8393 (void) ThrowMagickException(exception,GetMagickModule(),
8394 OptionError,"ImageSequenceRequired","`%s'",option);
8395 magnitude_image=DestroyImage(magnitude_image);
8396 status=MagickFalse;
8397 break;
8398 }
8399 fourier_image=InverseFourierTransformImage(magnitude_image,
8400 phase_image,*option == '-' ? MagickTrue : MagickFalse,exception);
8401 magnitude_image=DestroyImage(magnitude_image);
8402 phase_image=DestroyImage(phase_image);
8403 if (fourier_image == (Image *) NULL)
8404 break;
8405 if (*images != (Image *) NULL)
8406 *images=DestroyImageList(*images);
8407 *images=fourier_image;
8408 break;
8409 }
8410 if (LocaleCompare("insert",option+1) == 0)
8411 {
8412 Image
8413 *p,
8414 *q;
8415
8416 index=0;
8417 if (*option != '+')
8418 index=(ssize_t) StringToLong(argv[i+1]);
8419 p=RemoveLastImageFromList(images);
8420 if (p == (Image *) NULL)
8421 {
8422 (void) ThrowMagickException(exception,GetMagickModule(),
8423 OptionError,"NoSuchImage","`%s'",argv[i+1]);
8424 status=MagickFalse;
8425 break;
8426 }
8427 q=p;
8428 if (index == 0)
8429 PrependImageToList(images,q);
8430 else
8431 if (index == (ssize_t) GetImageListLength(*images))
8432 AppendImageToList(images,q);
8433 else
8434 {
8435 q=GetImageFromList(*images,index-1);
8436 if (q == (Image *) NULL)
8437 {
8438 p=DestroyImage(p);
8439 (void) ThrowMagickException(exception,GetMagickModule(),
8440 OptionError,"NoSuchImage","`%s'",argv[i+1]);
8441 status=MagickFalse;
8442 break;
8443 }
8444 InsertImageInList(&q,p);
8445 }
8446 *images=GetFirstImageInList(q);
8447 break;
8448 }
8449 if (LocaleCompare("interpolate",option+1) == 0)
8450 {
8451 interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
8452 MagickInterpolateOptions,MagickFalse,argv[i+1]);
8453 break;
8454 }
8455 break;
8456 }
8457 case 'l':
8458 {
8459 if (LocaleCompare("layers",option+1) == 0)
8460 {
8461 Image
8462 *layers;
8463
8464 LayerMethod
8465 method;
8466
8467 (void) SyncImagesSettings(mogrify_info,*images,exception);
8468 layers=(Image *) NULL;
8469 method=(LayerMethod) ParseCommandOption(MagickLayerOptions,
8470 MagickFalse,argv[i+1]);
8471 switch (method)
8472 {
8473 case CoalesceLayer:
8474 {
8475 layers=CoalesceImages(*images,exception);
8476 break;
8477 }
8478 case CompareAnyLayer:
8479 case CompareClearLayer:
8480 case CompareOverlayLayer:
8481 default:
8482 {
8483 layers=CompareImagesLayers(*images,method,exception);
8484 break;
8485 }
8486 case MergeLayer:
8487 case FlattenLayer:
8488 case MosaicLayer:
8489 case TrimBoundsLayer:
8490 {
8491 layers=MergeImageLayers(*images,method,exception);
8492 break;
8493 }
8494 case DisposeLayer:
8495 {
8496 layers=DisposeImages(*images,exception);
8497 break;
8498 }
8499 case OptimizeImageLayer:
8500 {
8501 layers=OptimizeImageLayers(*images,exception);
8502 break;
8503 }
8504 case OptimizePlusLayer:
8505 {
8506 layers=OptimizePlusImageLayers(*images,exception);
8507 break;
8508 }
8509 case OptimizeTransLayer:
8510 {
8511 OptimizeImageTransparency(*images,exception);
8512 break;
8513 }
8514 case RemoveDupsLayer:
8515 {
8516 RemoveDuplicateLayers(images,exception);
8517 break;
8518 }
8519 case RemoveZeroLayer:
8520 {
8521 RemoveZeroDelayLayers(images,exception);
8522 break;
8523 }
8524 case OptimizeLayer:
8525 {
8526 /*
8527 General Purpose, GIF Animation Optimizer.
8528 */
8529 layers=CoalesceImages(*images,exception);
8530 if (layers == (Image *) NULL)
8531 {
8532 status=MagickFalse;
8533 break;
8534 }
8535 *images=DestroyImageList(*images);
8536 *images=layers;
8537 layers=OptimizeImageLayers(*images,exception);
8538 if (layers == (Image *) NULL)
8539 {
8540 status=MagickFalse;
8541 break;
8542 }
8543 *images=DestroyImageList(*images);
8544 *images=layers;
8545 layers=(Image *) NULL;
8546 OptimizeImageTransparency(*images,exception);
8547 (void) RemapImages(quantize_info,*images,(Image *) NULL,
8548 exception);
8549 break;
8550 }
8551 case CompositeLayer:
8552 {
8553 CompositeOperator
8554 compose;
8555
8556 Image
8557 *source;
8558
8559 RectangleInfo
8560 geometry;
8561
8562 /*
8563 Split image sequence at the first 'NULL:' image.
8564 */
8565 source=(*images);
8566 while (source != (Image *) NULL)
8567 {
8568 source=GetNextImageInList(source);
8569 if ((source != (Image *) NULL) &&
8570 (LocaleCompare(source->magick,"NULL") == 0))
8571 break;
8572 }
8573 if (source != (Image *) NULL)
8574 {
8575 if ((GetPreviousImageInList(source) == (Image *) NULL) ||
8576 (GetNextImageInList(source) == (Image *) NULL))
8577 source=(Image *) NULL;
8578 else
8579 {
8580 /*
8581 Separate the two lists, junk the null: image.
8582 */
8583 source=SplitImageList(source->previous);
8584 DeleteImageFromList(&source);
8585 }
8586 }
8587 if (source == (Image *) NULL)
8588 {
8589 (void) ThrowMagickException(exception,GetMagickModule(),
8590 OptionError,"MissingNullSeparator","layers Composite");
8591 status=MagickFalse;
8592 break;
8593 }
8594 /*
8595 Adjust offset with gravity and virtual canvas.
8596 */
8597 SetGeometry(*images,&geometry);
8598 (void) ParseAbsoluteGeometry((*images)->geometry,&geometry);
8599 geometry.width=source->page.width != 0 ?
8600 source->page.width : source->columns;
8601 geometry.height=source->page.height != 0 ?
8602 source->page.height : source->rows;
8603 GravityAdjustGeometry((*images)->page.width != 0 ?
8604 (*images)->page.width : (*images)->columns,
8605 (*images)->page.height != 0 ? (*images)->page.height :
8606 (*images)->rows,(*images)->gravity,&geometry);
8607 compose=OverCompositeOp;
8608 option=GetImageOption(mogrify_info,"compose");
8609 if (option != (const char *) NULL)
8610 compose=(CompositeOperator) ParseCommandOption(
8611 MagickComposeOptions,MagickFalse,option);
8612 CompositeLayers(*images,compose,source,geometry.x,geometry.y,
8613 exception);
8614 source=DestroyImageList(source);
8615 break;
8616 }
8617 }
8618 if (layers == (Image *) NULL)
8619 break;
8620 *images=DestroyImageList(*images);
8621 *images=layers;
8622 break;
8623 }
8624 break;
8625 }
8626 case 'm':
8627 {
8628 if (LocaleCompare("map",option+1) == 0)
8629 {
8630 (void) SyncImagesSettings(mogrify_info,*images,exception);
8631 if (*option == '+')
8632 {
8633 (void) RemapImages(quantize_info,*images,(Image *) NULL,
8634 exception);
8635 break;
8636 }
8637 i++;
8638 break;
8639 }
8640 if (LocaleCompare("maximum",option+1) == 0)
8641 {
8642 Image
8643 *maximum_image;
8644
8645 /*
8646 Maximum image sequence (deprecated).
8647 */
8648 (void) SyncImagesSettings(mogrify_info,*images,exception);
8649 maximum_image=EvaluateImages(*images,MaxEvaluateOperator,exception);
8650 if (maximum_image == (Image *) NULL)
8651 {
8652 status=MagickFalse;
8653 break;
8654 }
8655 *images=DestroyImageList(*images);
8656 *images=maximum_image;
8657 break;
8658 }
8659 if (LocaleCompare("minimum",option+1) == 0)
8660 {
8661 Image
8662 *minimum_image;
8663
8664 /*
8665 Minimum image sequence (deprecated).
8666 */
8667 (void) SyncImagesSettings(mogrify_info,*images,exception);
8668 minimum_image=EvaluateImages(*images,MinEvaluateOperator,exception);
8669 if (minimum_image == (Image *) NULL)
8670 {
8671 status=MagickFalse;
8672 break;
8673 }
8674 *images=DestroyImageList(*images);
8675 *images=minimum_image;
8676 break;
8677 }
8678 if (LocaleCompare("morph",option+1) == 0)
8679 {
8680 Image
8681 *morph_image;
8682
8683 (void) SyncImagesSettings(mogrify_info,*images,exception);
8684 morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]),
8685 exception);
8686 if (morph_image == (Image *) NULL)
8687 {
8688 status=MagickFalse;
8689 break;
8690 }
8691 *images=DestroyImageList(*images);
8692 *images=morph_image;
8693 break;
8694 }
8695 if (LocaleCompare("mosaic",option+1) == 0)
8696 {
8697 Image
8698 *mosaic_image;
8699
8700 (void) SyncImagesSettings(mogrify_info,*images,exception);
8701 mosaic_image=MergeImageLayers(*images,MosaicLayer,exception);
8702 if (mosaic_image == (Image *) NULL)
8703 {
8704 status=MagickFalse;
8705 break;
8706 }
8707 *images=DestroyImageList(*images);
8708 *images=mosaic_image;
8709 break;
8710 }
8711 break;
8712 }
8713 case 'p':
8714 {
8715 if (LocaleCompare("poly",option+1) == 0)
8716 {
8717 char
8718 *args,
8719 token[MagickPathExtent];
8720
8721 const char
8722 *p;
8723
8724 double
8725 *arguments;
8726
8727 Image
8728 *polynomial_image;
8729
8730 ssize_t
8731 x;
8732
8733 size_t
8734 number_arguments;
8735
8736 /*
8737 Polynomial image.
8738 */
8739 (void) SyncImageSettings(mogrify_info,*images,exception);
8740 args=InterpretImageProperties(mogrify_info,*images,argv[i+1],
8741 exception);
8742 if (args == (char *) NULL)
8743 break;
8744 p=(char *) args;
8745 for (x=0; *p != '\0'; x++)
8746 {
8747 (void) GetNextToken(p,&p,MagickPathExtent,token);
8748 if (*token == ',')
8749 (void) GetNextToken(p,&p,MagickPathExtent,token);
8750 }
8751 number_arguments=(size_t) x;
8752 arguments=(double *) AcquireQuantumMemory(number_arguments,
8753 sizeof(*arguments));
8754 if (arguments == (double *) NULL)
8755 ThrowWandFatalException(ResourceLimitFatalError,
8756 "MemoryAllocationFailed",(*images)->filename);
8757 (void) memset(arguments,0,number_arguments*
8758 sizeof(*arguments));
8759 p=(char *) args;
8760 for (x=0; (x < (ssize_t) number_arguments) && (*p != '\0'); x++)
8761 {
8762 (void) GetNextToken(p,&p,MagickPathExtent,token);
8763 if (*token == ',')
8764 (void) GetNextToken(p,&p,MagickPathExtent,token);
8765 arguments[x]=StringToDouble(token,(char **) NULL);
8766 }
8767 args=DestroyString(args);
8768 polynomial_image=PolynomialImage(*images,number_arguments >> 1,
8769 arguments,exception);
8770 arguments=(double *) RelinquishMagickMemory(arguments);
8771 if (polynomial_image == (Image *) NULL)
8772 {
8773 status=MagickFalse;
8774 break;
8775 }
8776 *images=DestroyImageList(*images);
8777 *images=polynomial_image;
8778 }
8779 if (LocaleCompare("print",option+1) == 0)
8780 {
8781 char
8782 *string;
8783
8784 (void) SyncImagesSettings(mogrify_info,*images,exception);
8785 string=InterpretImageProperties(mogrify_info,*images,argv[i+1],
8786 exception);
8787 if (string == (char *) NULL)
8788 break;
8789 (void) FormatLocaleFile(stdout,"%s",string);
8790 string=DestroyString(string);
8791 }
8792 if (LocaleCompare("process",option+1) == 0)
8793 {
8794 char
8795 **arguments;
8796
8797 int
8798 j,
8799 number_arguments;
8800
8801 (void) SyncImagesSettings(mogrify_info,*images,exception);
8802 arguments=StringToArgv(argv[i+1],&number_arguments);
8803 if ((arguments == (char **) NULL) || (number_arguments == 1))
8804 break;
8805 if ((argc > 1) && (strchr(arguments[1],'=') != (char *) NULL))
8806 {
8807 char
8808 breaker,
8809 quote,
8810 *token;
8811
8812 const char
8813 *argument;
8814
8815 int
8816 next,
8817 token_status;
8818
8819 size_t
8820 length;
8821
8822 TokenInfo
8823 *token_info;
8824
8825 /*
8826 Support old style syntax, filter="-option arg".
8827 */
8828 length=strlen(argv[i+1]);
8829 token=(char *) NULL;
8830 if (~length >= (MagickPathExtent-1))
8831 token=(char *) AcquireQuantumMemory(length+MagickPathExtent,
8832 sizeof(*token));
8833 if (token == (char *) NULL)
8834 break;
8835 next=0;
8836 argument=argv[i+1];
8837 token_info=AcquireTokenInfo();
8838 token_status=Tokenizer(token_info,0,token,length,argument,"",
8839 "=","\"",'\0',&breaker,&next,&quote);
8840 token_info=DestroyTokenInfo(token_info);
8841 if (token_status == 0)
8842 {
8843 const char
8844 *arg;
8845
8846 arg=(&(argument[next]));
8847 (void) InvokeDynamicImageFilter(token,&(*images),1,&arg,
8848 exception);
8849 }
8850 token=DestroyString(token);
8851 break;
8852 }
8853 (void) SubstituteString(&arguments[1],"-","");
8854 (void) InvokeDynamicImageFilter(arguments[1],&(*images),
8855 number_arguments-2,(const char **) arguments+2,exception);
8856 for (j=0; j < number_arguments; j++)
8857 arguments[j]=DestroyString(arguments[j]);
8858 arguments=(char **) RelinquishMagickMemory(arguments);
8859 break;
8860 }
8861 break;
8862 }
8863 case 'r':
8864 {
8865 if (LocaleCompare("reverse",option+1) == 0)
8866 {
8867 ReverseImageList(images);
8868 break;
8869 }
8870 break;
8871 }
8872 case 's':
8873 {
8874 if (LocaleCompare("smush",option+1) == 0)
8875 {
8876 Image
8877 *smush_image;
8878
8879 ssize_t
8880 offset;
8881
8882 (void) SyncImagesSettings(mogrify_info,*images,exception);
8883 offset=(ssize_t) StringToLong(argv[i+1]);
8884 smush_image=SmushImages(*images,*option == '-' ? MagickTrue :
8885 MagickFalse,offset,exception);
8886 if (smush_image == (Image *) NULL)
8887 {
8888 status=MagickFalse;
8889 break;
8890 }
8891 *images=DestroyImageList(*images);
8892 *images=smush_image;
8893 break;
8894 }
8895 if (LocaleCompare("swap",option+1) == 0)
8896 {
8897 Image
8898 *p,
8899 *q,
8900 *u,
8901 *v;
8902
8903 ssize_t
8904 swap_index;
8905
8906 index=(-1);
8907 swap_index=(-2);
8908 if (*option != '+')
8909 {
8910 GeometryInfo
8911 geometry_info;
8912
8913 MagickStatusType
8914 flags;
8915
8916 swap_index=(-1);
8917 flags=ParseGeometry(argv[i+1],&geometry_info);
8918 index=(ssize_t) geometry_info.rho;
8919 if ((flags & SigmaValue) != 0)
8920 swap_index=(ssize_t) geometry_info.sigma;
8921 }
8922 p=GetImageFromList(*images,index);
8923 q=GetImageFromList(*images,swap_index);
8924 if ((p == (Image *) NULL) || (q == (Image *) NULL))
8925 {
8926 (void) ThrowMagickException(exception,GetMagickModule(),
8927 OptionError,"NoSuchImage","`%s'",(*images)->filename);
8928 status=MagickFalse;
8929 break;
8930 }
8931 if (p == q)
8932 break;
8933 u=CloneImage(p,0,0,MagickTrue,exception);
8934 if (u == (Image *) NULL)
8935 break;
8936 v=CloneImage(q,0,0,MagickTrue,exception);
8937 if (v == (Image *) NULL)
8938 {
8939 u=DestroyImage(u);
8940 break;
8941 }
8942 ReplaceImageInList(&p,v);
8943 ReplaceImageInList(&q,u);
8944 *images=GetFirstImageInList(q);
8945 break;
8946 }
8947 break;
8948 }
8949 case 'w':
8950 {
8951 if (LocaleCompare("write",option+1) == 0)
8952 {
8953 char
8954 key[MagickPathExtent];
8955
8956 Image
8957 *write_images;
8958
8959 ImageInfo
8960 *write_info;
8961
8962 (void) SyncImagesSettings(mogrify_info,*images,exception);
8963 (void) FormatLocaleString(key,MagickPathExtent,"cache:%s",
8964 argv[i+1]);
8965 (void) DeleteImageRegistry(key);
8966 write_images=CloneImageList(*images,exception);
8967 write_info=CloneImageInfo(mogrify_info);
8968 status&=(MagickStatusType) WriteImages(write_info,write_images,
8969 argv[i+1],exception);
8970 write_info=DestroyImageInfo(write_info);
8971 write_images=DestroyImageList(write_images);
8972 break;
8973 }
8974 break;
8975 }
8976 default:
8977 break;
8978 }
8979 i+=count;
8980 }
8981 quantize_info=DestroyQuantizeInfo(quantize_info);
8982 mogrify_info=DestroyImageInfo(mogrify_info);
8983 status&=(MagickStatusType) MogrifyImageInfo(image_info,argc,argv,exception);
8984 return(status != 0 ? MagickTrue : MagickFalse);
8985}
8986␌
8987/*
8988%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8989% %
8990% %
8991% %
8992+ M o g r i f y I m a g e s %
8993% %
8994% %
8995% %
8996%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8997%
8998% MogrifyImages() applies image processing options to a sequence of images as
8999% prescribed by command line options.
9000%
9001% The format of the MogrifyImage method is:
9002%
9003% MagickBooleanType MogrifyImages(ImageInfo *image_info,
9004% const MagickBooleanType post,const int argc,const char **argv,
9005% Image **images,Exceptioninfo *exception)
9006%
9007% A description of each parameter follows:
9008%
9009% o image_info: the image info..
9010%
9011% o post: If true, post process image list operators otherwise pre-process.
9012%
9013% o argc: Specifies a pointer to an integer describing the number of
9014% elements in the argument vector.
9015%
9016% o argv: Specifies a pointer to a text array containing the command line
9017% arguments.
9018%
9019% o images: pointer to a pointer of the first image in image list.
9020%
9021% o exception: return any errors or warnings in this structure.
9022%
9023*/
9024WandExport MagickBooleanType MogrifyImages(ImageInfo *image_info,
9025 const MagickBooleanType post,const int argc,const char **argv,
9026 Image **images,ExceptionInfo *exception)
9027{
9028#define MogrifyImageTag "Mogrify/Image"
9029
9030 MagickStatusType
9031 status;
9032
9033 MagickBooleanType
9034 proceed;
9035
9036 size_t
9037 n;
9038
9039 ssize_t
9040 i;
9041
9042 assert(image_info != (ImageInfo *) NULL);
9043 assert(image_info->signature == MagickCoreSignature);
9044 if (images == (Image **) NULL)
9045 return(MogrifyImage(image_info,argc,argv,images,exception));
9046 assert((*images)->previous == (Image *) NULL);
9047 assert((*images)->signature == MagickCoreSignature);
9048 if (IsEventLogging() != MagickFalse)
9049 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
9050 (*images)->filename);
9051 if ((argc <= 0) || (*argv == (char *) NULL))
9052 return(MagickTrue);
9053 (void) SetImageInfoProgressMonitor(image_info,(MagickProgressMonitor) NULL,
9054 (void *) NULL);
9055 status=MagickTrue;
9056#if 0
9057 (void) FormatLocaleFile(stderr, "mogrify start %s %d (%s)\n",argv[0],argc,
9058 post?"post":"pre");
9059#endif
9060 /*
9061 Pre-process multi-image sequence operators
9062 */
9063 if (post == MagickFalse)
9064 status&=(MagickStatusType) MogrifyImageList(image_info,argc,argv,images,
9065 exception);
9066 /*
9067 For each image, process simple single image operators
9068 */
9069 i=0;
9070 n=GetImageListLength(*images);
9071 for ( ; ; )
9072 {
9073#if 0
9074 (void) FormatLocaleFile(stderr,"mogrify %ld of %ld\n",(long)
9075 GetImageIndexInList(*images),(long)GetImageListLength(*images));
9076#endif
9077 status&=(MagickStatusType) MogrifyImage(image_info,argc,argv,images,
9078 exception);
9079 proceed=SetImageProgress(*images,MogrifyImageTag,(MagickOffsetType) i, n);
9080 if (proceed == MagickFalse)
9081 break;
9082 if ( (*images)->next == (Image *) NULL )
9083 break;
9084 *images=(*images)->next;
9085 i++;
9086 }
9087 assert( *images != (Image *) NULL );
9088#if 0
9089 (void) FormatLocaleFile(stderr,"mogrify end %ld of %ld\n",(long)
9090 GetImageIndexInList(*images),(long)GetImageListLength(*images));
9091#endif
9092 /*
9093 Post-process, multi-image sequence operators
9094 */
9095 *images=GetFirstImageInList(*images);
9096 if (post != MagickFalse)
9097 status&=(MagickStatusType) MogrifyImageList(image_info,argc,argv,images,
9098 exception);
9099 return(status != 0 ? MagickTrue : MagickFalse);
9100}