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