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