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