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