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