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