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