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