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