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