MagickWand  6.9.12-67
Convert, Edit, Or Compose Bitmap Images
 All Data Structures
compare.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % CCCC OOO M M PPPP AAA RRRR EEEEE %
7 % C O O MM MM P P A A R R E %
8 % C O O M M M PPPP AAAAA RRRR EEE %
9 % C O O M M P A A R R E %
10 % CCCC OOO M M P A A R R EEEEE %
11 % %
12 % %
13 % Image Comparison Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % December 2003 %
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 compare program to mathematically and visually annotate the
37 % difference between an image and its reconstruction.
38 %
39 */
40 
41 /*
42  Include declarations.
43 */
44 #include "wand/studio.h"
45 #include "wand/MagickWand.h"
46 #include "wand/mogrify-private.h"
47 #include "magick/string-private.h"
48 
49 /*
50 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
51 % %
52 % %
53 % %
54 % C o m p a r e I m a g e C o m m a n d %
55 % %
56 % %
57 % %
58 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
59 %
60 % CompareImageCommand() compares two images and returns the difference between
61 % them as a distortion metric and as a new image visually annotating their
62 % differences.
63 %
64 % The format of the CompareImageCommand method is:
65 %
66 % MagickBooleanType CompareImageCommand(ImageInfo *image_info,int argc,
67 % char **argv,char **metadata,ExceptionInfo *exception)
68 %
69 % A description of each parameter follows:
70 %
71 % o image_info: the image info.
72 %
73 % o argc: the number of elements in the argument vector.
74 %
75 % o argv: A text array containing the command line arguments.
76 %
77 % o metadata: any metadata is returned here.
78 %
79 % o exception: return any errors or warnings in this structure.
80 %
81 */
82 
83 static MagickBooleanType CompareUsage(void)
84 {
85  static const char
86  miscellaneous[] =
87  " -debug events display copious debugging information\n"
88  " -help print program options\n"
89  " -list type print a list of supported option arguments\n"
90  " -log format format of debugging information",
91  operators[] =
92  " -brightness-contrast geometry\n"
93  " improve brightness / contrast of the image\n"
94  " -distort method args\n"
95  " distort images according to given method and args\n"
96  " -level value adjust the level of image contrast\n"
97  " -resize geometry resize the image\n"
98  " -rotate degrees apply Paeth rotation to the image\n"
99  " -sigmoidal-contrast geometry\n"
100  " increase the contrast without saturating highlights or\n"
101  " -trim trim image edges",
102  sequence_operators[] =
103  " -crop geometry cut out a rectangular region of the image\n"
104  " -separate separate an image channel into a grayscale image\n"
105  " -write filename write images to this file",
106  settings[] =
107  " -alpha option on, activate, off, deactivate, set, opaque, copy\n"
108  " transparent, extract, background, or shape\n"
109  " -authenticate password\n"
110  " decipher image with this password\n"
111  " -background color background color\n"
112  " -channel type apply option to select image channels\n"
113  " -colorspace type alternate image colorspace\n"
114  " -compose operator set image composite operator\n"
115  " -compress type type of pixel compression when writing the image\n"
116  " -decipher filename convert cipher pixels to plain pixels\n"
117  " -define format:option\n"
118  " define one or more image format options\n"
119  " -density geometry horizontal and vertical density of the image\n"
120  " -depth value image depth\n"
121  " -dissimilarity-threshold value\n"
122  " maximum distortion for (sub)image match\n"
123  " -encipher filename convert plain pixels to cipher pixels\n"
124  " -extract geometry extract area from image\n"
125  " -format \"string\" output formatted image characteristics\n"
126  " -fuzz distance colors within this distance are considered equal\n"
127  " -gravity type horizontal and vertical text placement\n"
128  " -highlight-color color\n"
129  " empasize pixel differences with this color\n"
130  " -identify identify the format and characteristics of the image\n"
131  " -interlace type type of image interlacing scheme\n"
132  " -limit type value pixel cache resource limit\n"
133  " -lowlight-color color\n"
134  " de-emphasize pixel differences with this color\n"
135  " -mask filename associate a mask with the image\n"
136  " -metric type measure differences between images with this metric\n"
137  " -monitor monitor progress\n"
138  " -passphrase filename get the passphrase from this file\n"
139  " -precision value maximum number of significant digits to print\n"
140  " -profile filename add, delete, or apply an image profile\n"
141  " -quality value JPEG/MIFF/PNG compression level\n"
142  " -quiet suppress all warning messages\n"
143  " -quantize colorspace reduce colors in this colorspace\n"
144  " -regard-warnings pay attention to warning messages\n"
145  " -repage geometry size and location of an image canvas\n"
146  " -respect-parentheses settings remain in effect until parenthesis boundary\n"
147  " -sampling-factor geometry\n"
148  " horizontal and vertical sampling factor\n"
149  " -seed value seed a new sequence of pseudo-random numbers\n"
150  " -set attribute value set an image attribute\n"
151  " -quality value JPEG/MIFF/PNG compression level\n"
152  " -similarity-threshold value\n"
153  " minimum distortion for (sub)image match\n"
154  " -size geometry width and height of image\n"
155  " -subimage-search search for subimage\n"
156  " -synchronize synchronize image to storage device\n"
157  " -taint declare the image as modified\n"
158  " -transparent-color color\n"
159  " transparent color\n"
160  " -type type image type\n"
161  " -verbose print detailed information about the image\n"
162  " -version print version information\n"
163  " -virtual-pixel method\n"
164  " virtual pixel access method",
165  stack_operators[] =
166  " -delete indexes delete the image from the image sequence";
167 
168  ListMagickVersion(stdout);
169  (void) printf("Usage: %s [options ...] image reconstruct difference\n",
170  GetClientName());
171  (void) printf("\nImage Settings:\n");
172  (void) puts(settings);
173  (void) printf("\nImage Operators:\n");
174  (void) puts(operators);
175  (void) printf("\nImage Sequence Operators:\n");
176  (void) puts(sequence_operators);
177  (void) printf("\nImage Stack Operators:\n");
178  (void) puts(stack_operators);
179  (void) printf("\nMiscellaneous Options:\n");
180  (void) puts(miscellaneous);
181  (void) printf(
182  "\nBy default, the image format of `file' is determined by its magic\n");
183  (void) printf(
184  "number. To specify a particular image format, precede the filename\n");
185  (void) printf(
186  "with an image format name and a colon (i.e. ps:image) or specify the\n");
187  (void) printf(
188  "image type as the filename suffix (i.e. image.ps). Specify 'file' as\n");
189  (void) printf("'-' for standard input or output.\n");
190  return(MagickTrue);
191 }
192 
193 WandExport MagickBooleanType CompareImageCommand(ImageInfo *image_info,
194  int argc,char **argv,char **metadata,ExceptionInfo *exception)
195 {
196 #define CompareEpsilon (1.0e-06)
197 #define DefaultDissimilarityThreshold 0.31830988618379067154
198 #define DefaultSimilarityThreshold (-1.0)
199 #define DestroyCompare() \
200 { \
201  if (similarity_image != (Image *) NULL) \
202  similarity_image=DestroyImageList(similarity_image); \
203  if (difference_image != (Image *) NULL) \
204  difference_image=DestroyImageList(difference_image); \
205  DestroyImageStack(); \
206  for (i=0; i < (ssize_t) argc; i++) \
207  argv[i]=DestroyString(argv[i]); \
208  argv=(char **) RelinquishMagickMemory(argv); \
209 }
210 #define ThrowCompareException(asperity,tag,option) \
211 { \
212  if (exception->severity < (asperity)) \
213  (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag, \
214  "`%s'",option); \
215  DestroyCompare(); \
216  return(MagickFalse); \
217 }
218 #define ThrowCompareInvalidArgumentException(option,argument) \
219 { \
220  (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
221  "InvalidArgument","`%s': %s",option,argument); \
222  DestroyCompare(); \
223  return(MagickFalse); \
224 }
225 
226  char
227  *filename,
228  *option;
229 
230  const char
231  *format;
232 
233  ChannelType
234  channels;
235 
236  double
237  dissimilarity_threshold,
238  distortion,
239  similarity_metric,
240  similarity_threshold;
241 
242  Image
243  *difference_image,
244  *image,
245  *reconstruct_image,
246  *similarity_image;
247 
248  ImageInfo
249  *restore_info;
250 
251  ImageStack
252  image_stack[MaxImageStackDepth+1];
253 
254  MagickBooleanType
255  fire,
256  pend,
257  respect_parenthesis,
258  subimage_search;
259 
260  MagickStatusType
261  status;
262 
263  MetricType
264  metric;
265 
266  RectangleInfo
267  offset;
268 
269  ssize_t
270  i;
271 
272  ssize_t
273  j,
274  k;
275 
276  /*
277  Set defaults.
278  */
279  assert(image_info != (ImageInfo *) NULL);
280  assert(image_info->signature == MagickCoreSignature);
281  assert(exception != (ExceptionInfo *) NULL);
282  if (IsEventLogging() != MagickFalse)
283  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
284  if (argc == 2)
285  {
286  option=argv[1];
287  if ((LocaleCompare("version",option+1) == 0) ||
288  (LocaleCompare("-version",option+1) == 0))
289  {
290  ListMagickVersion(stdout);
291  return(MagickTrue);
292  }
293  }
294  if (argc < 3)
295  return(CompareUsage());
296  restore_info=image_info;
297  channels=DefaultChannels;
298  difference_image=NewImageList();
299  similarity_image=NewImageList();
300  dissimilarity_threshold=DefaultDissimilarityThreshold;
301  similarity_threshold=DefaultSimilarityThreshold;
302  distortion=0.0;
303  format=(char *) NULL;
304  j=1;
305  k=0;
306  metric=UndefinedErrorMetric;
307  NewImageStack();
308  option=(char *) NULL;
309  pend=MagickFalse;
310  reconstruct_image=NewImageList();
311  respect_parenthesis=MagickFalse;
312  status=MagickTrue;
313  subimage_search=MagickFalse;
314  /*
315  Compare an image.
316  */
317  ReadCommandlLine(argc,&argv);
318  status=ExpandFilenames(&argc,&argv);
319  if (status == MagickFalse)
320  ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
321  GetExceptionMessage(errno));
322  for (i=1; i < (ssize_t) (argc-1); i++)
323  {
324  option=argv[i];
325  if (LocaleCompare(option,"(") == 0)
326  {
327  FireImageStack(MagickTrue,MagickTrue,pend);
328  if (k == MaxImageStackDepth)
329  ThrowCompareException(OptionError,"ParenthesisNestedTooDeeply",
330  option);
331  PushImageStack();
332  continue;
333  }
334  if (LocaleCompare(option,")") == 0)
335  {
336  FireImageStack(MagickTrue,MagickTrue,MagickTrue);
337  if (k == 0)
338  ThrowCompareException(OptionError,"UnableToParseExpression",option);
339  PopImageStack();
340  continue;
341  }
342  if (IsCommandOption(option) == MagickFalse)
343  {
344  Image
345  *images;
346 
347  /*
348  Read input image.
349  */
350  FireImageStack(MagickFalse,MagickFalse,pend);
351  filename=argv[i];
352  if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
353  filename=argv[++i];
354  (void) SetImageOption(image_info,"filename",filename);
355  (void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
356  images=ReadImages(image_info,exception);
357  status&=(images != (Image *) NULL) &&
358  (exception->severity < ErrorException);
359  if (images == (Image *) NULL)
360  continue;
361  AppendImageStack(images);
362  continue;
363  }
364  pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
365  switch (*(option+1))
366  {
367  case 'a':
368  {
369  if (LocaleCompare("alpha",option+1) == 0)
370  {
371  ssize_t
372  type;
373 
374  if (*option == '+')
375  break;
376  i++;
377  if (i == (ssize_t) argc)
378  ThrowCompareException(OptionError,"MissingArgument",option);
379  type=ParseCommandOption(MagickAlphaOptions,MagickFalse,argv[i]);
380  if (type < 0)
381  ThrowCompareException(OptionError,"UnrecognizedAlphaChannelType",
382  argv[i]);
383  break;
384  }
385  if (LocaleCompare("authenticate",option+1) == 0)
386  {
387  if (*option == '+')
388  break;
389  i++;
390  if (i == (ssize_t) argc)
391  ThrowCompareException(OptionError,"MissingArgument",option);
392  break;
393  }
394  ThrowCompareException(OptionError,"UnrecognizedOption",option);
395  }
396  case 'b':
397  {
398  if (LocaleCompare("background",option+1) == 0)
399  {
400  if (*option == '+')
401  break;
402  i++;
403  if (i == (ssize_t) argc)
404  ThrowCompareException(OptionError,"MissingArgument",option);
405  break;
406  }
407  if (LocaleCompare("brightness-contrast",option+1) == 0)
408  {
409  i++;
410  if (i == (ssize_t) argc)
411  ThrowCompareException(OptionError,"MissingArgument",option);
412  if (IsGeometry(argv[i]) == MagickFalse)
413  ThrowCompareInvalidArgumentException(option,argv[i]);
414  break;
415  }
416  ThrowCompareException(OptionError,"UnrecognizedOption",option);
417  }
418  case 'c':
419  {
420  if (LocaleCompare("cache",option+1) == 0)
421  {
422  if (*option == '+')
423  break;
424  i++;
425  if (i == (ssize_t) argc)
426  ThrowCompareException(OptionError,"MissingArgument",option);
427  if (IsGeometry(argv[i]) == MagickFalse)
428  ThrowCompareInvalidArgumentException(option,argv[i]);
429  break;
430  }
431  if (LocaleCompare("channel",option+1) == 0)
432  {
433  ssize_t
434  channel;
435 
436  if (*option == '+')
437  break;
438  i++;
439  if (i == (ssize_t) argc)
440  ThrowCompareException(OptionError,"MissingArgument",option);
441  channel=ParseChannelOption(argv[i]);
442  if (channel < 0)
443  ThrowCompareException(OptionError,"UnrecognizedChannelType",
444  argv[i]);
445  channels=(ChannelType) channel;
446  break;
447  }
448  if (LocaleCompare("colorspace",option+1) == 0)
449  {
450  ssize_t
451  colorspace;
452 
453  if (*option == '+')
454  break;
455  i++;
456  if (i == (ssize_t) argc)
457  ThrowCompareException(OptionError,"MissingArgument",option);
458  colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
459  argv[i]);
460  if (colorspace < 0)
461  ThrowCompareException(OptionError,"UnrecognizedColorspace",
462  argv[i]);
463  break;
464  }
465  if (LocaleCompare("compose",option+1) == 0)
466  {
467  ssize_t
468  compose;
469 
470  if (*option == '+')
471  break;
472  i++;
473  if (i == (ssize_t) argc)
474  ThrowCompareException(OptionError,"MissingArgument",option);
475  compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
476  argv[i]);
477  if (compose < 0)
478  ThrowCompareException(OptionError,"UnrecognizedComposeOperator",
479  argv[i]);
480  break;
481  }
482  if (LocaleCompare("compress",option+1) == 0)
483  {
484  ssize_t
485  compress;
486 
487  if (*option == '+')
488  break;
489  i++;
490  if (i == (ssize_t) argc)
491  ThrowCompareException(OptionError,"MissingArgument",option);
492  compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
493  argv[i]);
494  if (compress < 0)
495  ThrowCompareException(OptionError,"UnrecognizedImageCompression",
496  argv[i]);
497  break;
498  }
499  if (LocaleCompare("concurrent",option+1) == 0)
500  break;
501  if (LocaleCompare("crop",option+1) == 0)
502  {
503  if (*option == '+')
504  break;
505  i++;
506  if (i == (ssize_t) argc)
507  ThrowCompareException(OptionError,"MissingArgument",option);
508  if (IsGeometry(argv[i]) == MagickFalse)
509  ThrowCompareInvalidArgumentException(option,argv[i]);
510  break;
511  }
512  ThrowCompareException(OptionError,"UnrecognizedOption",option)
513  }
514  case 'd':
515  {
516  if (LocaleCompare("debug",option+1) == 0)
517  {
518  LogEventType
519  event_mask;
520 
521  if (*option == '+')
522  break;
523  i++;
524  if (i == (ssize_t) argc)
525  ThrowCompareException(OptionError,"MissingArgument",option);
526  event_mask=SetLogEventMask(argv[i]);
527  if (event_mask == UndefinedEvents)
528  ThrowCompareException(OptionError,"UnrecognizedEventType",
529  argv[i]);
530  break;
531  }
532  if (LocaleCompare("decipher",option+1) == 0)
533  {
534  if (*option == '+')
535  break;
536  i++;
537  if (i == (ssize_t) argc)
538  ThrowCompareException(OptionError,"MissingArgument",option);
539  break;
540  }
541  if (LocaleCompare("define",option+1) == 0)
542  {
543  i++;
544  if (i == (ssize_t) argc)
545  ThrowCompareException(OptionError,"MissingArgument",option);
546  if (*option == '+')
547  {
548  const char
549  *define;
550 
551  define=GetImageOption(image_info,argv[i]);
552  if (define == (const char *) NULL)
553  ThrowCompareException(OptionError,"NoSuchOption",argv[i]);
554  break;
555  }
556  break;
557  }
558  if (LocaleCompare("delete",option+1) == 0)
559  {
560  if (*option == '+')
561  break;
562  i++;
563  if (i == (ssize_t) argc)
564  ThrowCompareException(OptionError,"MissingArgument",option);
565  if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
566  ThrowCompareInvalidArgumentException(option,argv[i]);
567  break;
568  }
569  if (LocaleCompare("density",option+1) == 0)
570  {
571  if (*option == '+')
572  break;
573  i++;
574  if (i == (ssize_t) argc)
575  ThrowCompareException(OptionError,"MissingArgument",option);
576  if (IsGeometry(argv[i]) == MagickFalse)
577  ThrowCompareInvalidArgumentException(option,argv[i]);
578  break;
579  }
580  if (LocaleCompare("depth",option+1) == 0)
581  {
582  if (*option == '+')
583  break;
584  i++;
585  if (i == (ssize_t) argc)
586  ThrowCompareException(OptionError,"MissingArgument",option);
587  if (IsGeometry(argv[i]) == MagickFalse)
588  ThrowCompareInvalidArgumentException(option,argv[i]);
589  break;
590  }
591  if (LocaleCompare("dissimilarity-threshold",option+1) == 0)
592  {
593  if (*option == '+')
594  break;
595  i++;
596  if (i == (ssize_t) argc)
597  ThrowCompareException(OptionError,"MissingArgument",option);
598  if (IsGeometry(argv[i]) == MagickFalse)
599  ThrowCompareInvalidArgumentException(option,argv[i]);
600  if (*option == '+')
601  dissimilarity_threshold=DefaultDissimilarityThreshold;
602  else
603  dissimilarity_threshold=StringToDouble(argv[i],(char **) NULL);
604  break;
605  }
606  if (LocaleCompare("distort",option+1) == 0)
607  {
608  ssize_t
609  op;
610 
611  i++;
612  if (i == (ssize_t) argc)
613  ThrowCompareException(OptionError,"MissingArgument",option);
614  op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
615  if (op < 0)
616  ThrowCompareException(OptionError,"UnrecognizedDistortMethod",
617  argv[i]);
618  i++;
619  if (i == (ssize_t) argc)
620  ThrowCompareException(OptionError,"MissingArgument",option);
621  break;
622  }
623  if (LocaleCompare("duration",option+1) == 0)
624  {
625  if (*option == '+')
626  break;
627  i++;
628  if (i == (ssize_t) argc)
629  ThrowCompareException(OptionError,"MissingArgument",option);
630  if (IsGeometry(argv[i]) == MagickFalse)
631  ThrowCompareInvalidArgumentException(option,argv[i]);
632  break;
633  }
634  ThrowCompareException(OptionError,"UnrecognizedOption",option)
635  }
636  case 'e':
637  {
638  if (LocaleCompare("encipher",option+1) == 0)
639  {
640  if (*option == '+')
641  break;
642  i++;
643  if (i == (ssize_t) argc)
644  ThrowCompareException(OptionError,"MissingArgument",option);
645  break;
646  }
647  if (LocaleCompare("extract",option+1) == 0)
648  {
649  if (*option == '+')
650  break;
651  i++;
652  if (i == (ssize_t) argc)
653  ThrowCompareException(OptionError,"MissingArgument",option);
654  if (IsGeometry(argv[i]) == MagickFalse)
655  ThrowCompareInvalidArgumentException(option,argv[i]);
656  break;
657  }
658  ThrowCompareException(OptionError,"UnrecognizedOption",option)
659  }
660  case 'f':
661  {
662  if (LocaleCompare("format",option+1) == 0)
663  {
664  if (*option == '+')
665  break;
666  i++;
667  if (i == (ssize_t) argc)
668  ThrowCompareException(OptionError,"MissingArgument",option);
669  format=argv[i];
670  break;
671  }
672  if (LocaleCompare("fuzz",option+1) == 0)
673  {
674  if (*option == '+')
675  break;
676  i++;
677  if (i == (ssize_t) argc)
678  ThrowCompareException(OptionError,"MissingArgument",option);
679  if (IsGeometry(argv[i]) == MagickFalse)
680  ThrowCompareInvalidArgumentException(option,argv[i]);
681  break;
682  }
683  ThrowCompareException(OptionError,"UnrecognizedOption",option)
684  }
685  case 'g':
686  {
687  if (LocaleCompare("gravity",option+1) == 0)
688  {
689  ssize_t
690  gravity;
691 
692  if (*option == '+')
693  break;
694  i++;
695  if (i == (ssize_t) argc)
696  ThrowCompareException(OptionError,"MissingArgument",option);
697  gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
698  argv[i]);
699  if (gravity < 0)
700  ThrowCompareException(OptionError,"UnrecognizedGravityType",
701  argv[i]);
702  break;
703  }
704  ThrowCompareException(OptionError,"UnrecognizedOption",option)
705  }
706  case 'h':
707  {
708  if ((LocaleCompare("help",option+1) == 0) ||
709  (LocaleCompare("-help",option+1) == 0))
710  {
711  DestroyCompare();
712  return(CompareUsage());
713  }
714  if (LocaleCompare("highlight-color",option+1) == 0)
715  {
716  if (*option == '+')
717  break;
718  i++;
719  if (i == (ssize_t) argc)
720  ThrowCompareException(OptionError,"MissingArgument",option);
721  break;
722  }
723  ThrowCompareException(OptionError,"UnrecognizedOption",option)
724  }
725  case 'i':
726  {
727  if (LocaleCompare("identify",option+1) == 0)
728  break;
729  if (LocaleCompare("interlace",option+1) == 0)
730  {
731  ssize_t
732  interlace;
733 
734  if (*option == '+')
735  break;
736  i++;
737  if (i == (ssize_t) argc)
738  ThrowCompareException(OptionError,"MissingArgument",option);
739  interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
740  argv[i]);
741  if (interlace < 0)
742  ThrowCompareException(OptionError,"UnrecognizedInterlaceType",
743  argv[i]);
744  break;
745  }
746  ThrowCompareException(OptionError,"UnrecognizedOption",option)
747  }
748  case 'l':
749  {
750  if (LocaleCompare("level",option+1) == 0)
751  {
752  i++;
753  if (i == (ssize_t) argc)
754  ThrowCompareException(OptionError,"MissingArgument",option);
755  if (IsGeometry(argv[i]) == MagickFalse)
756  ThrowCompareInvalidArgumentException(option,argv[i]);
757  break;
758  }
759  if (LocaleCompare("limit",option+1) == 0)
760  {
761  char
762  *p;
763 
764  double
765  value;
766 
767  ssize_t
768  resource;
769 
770  if (*option == '+')
771  break;
772  i++;
773  if (i == (ssize_t) argc)
774  ThrowCompareException(OptionError,"MissingArgument",option);
775  resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
776  argv[i]);
777  if (resource < 0)
778  ThrowCompareException(OptionError,"UnrecognizedResourceType",
779  argv[i]);
780  i++;
781  if (i == (ssize_t) argc)
782  ThrowCompareException(OptionError,"MissingArgument",option);
783  value=StringToDouble(argv[i],&p);
784  (void) value;
785  if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
786  ThrowCompareInvalidArgumentException(option,argv[i]);
787  break;
788  }
789  if (LocaleCompare("list",option+1) == 0)
790  {
791  ssize_t
792  list;
793 
794  if (*option == '+')
795  break;
796  i++;
797  if (i == (ssize_t) argc)
798  ThrowCompareException(OptionError,"MissingArgument",option);
799  list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
800  if (list < 0)
801  ThrowCompareException(OptionError,"UnrecognizedListType",argv[i]);
802  status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
803  argv+j,exception);
804  DestroyCompare();
805  return(status == 0 ? MagickFalse : MagickTrue);
806  }
807  if (LocaleCompare("log",option+1) == 0)
808  {
809  if (*option == '+')
810  break;
811  i++;
812  if ((i == (ssize_t) argc) || (strchr(argv[i],'%') == (char *) NULL))
813  ThrowCompareException(OptionError,"MissingArgument",option);
814  break;
815  }
816  if (LocaleCompare("lowlight-color",option+1) == 0)
817  {
818  if (*option == '+')
819  break;
820  i++;
821  if (i == (ssize_t) argc)
822  ThrowCompareException(OptionError,"MissingArgument",option);
823  break;
824  }
825  ThrowCompareException(OptionError,"UnrecognizedOption",option)
826  }
827  case 'm':
828  {
829  if (LocaleCompare("mask",option+1) == 0)
830  {
831  if (*option == '+')
832  break;
833  i++;
834  if (i == (ssize_t) argc)
835  ThrowCompareException(OptionError,"MissingArgument",option);
836  break;
837  }
838  if (LocaleCompare("matte",option+1) == 0)
839  break;
840  if (LocaleCompare("metric",option+1) == 0)
841  {
842  ssize_t
843  type;
844 
845  if (*option == '+')
846  break;
847  i++;
848  if (i == (ssize_t) argc)
849  ThrowCompareException(OptionError,"MissingArgument",option);
850  type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
851  if (type < 0)
852  ThrowCompareException(OptionError,"UnrecognizedMetricType",
853  argv[i]);
854  metric=(MetricType) type;
855  break;
856  }
857  if (LocaleCompare("monitor",option+1) == 0)
858  break;
859  ThrowCompareException(OptionError,"UnrecognizedOption",option)
860  }
861  case 'p':
862  {
863  if (LocaleCompare("precision",option+1) == 0)
864  {
865  if (*option == '+')
866  break;
867  i++;
868  if (i == (ssize_t) argc)
869  ThrowCompareException(OptionError,"MissingArgument",option);
870  if (IsGeometry(argv[i]) == MagickFalse)
871  ThrowCompareInvalidArgumentException(option,argv[i]);
872  break;
873  }
874  if (LocaleCompare("passphrase",option+1) == 0)
875  {
876  if (*option == '+')
877  break;
878  i++;
879  if (i == (ssize_t) argc)
880  ThrowCompareException(OptionError,"MissingArgument",option);
881  break;
882  }
883  if (LocaleCompare("profile",option+1) == 0)
884  {
885  i++;
886  if (i == (ssize_t) argc)
887  ThrowCompareException(OptionError,"MissingArgument",option);
888  break;
889  }
890  ThrowCompareException(OptionError,"UnrecognizedOption",option)
891  }
892  case 'q':
893  {
894  if (LocaleCompare("quality",option+1) == 0)
895  {
896  if (*option == '+')
897  break;
898  i++;
899  if (i == (ssize_t) argc)
900  ThrowCompareException(OptionError,"MissingArgument",option);
901  if (IsGeometry(argv[i]) == MagickFalse)
902  ThrowCompareInvalidArgumentException(option,argv[i]);
903  break;
904  }
905  if (LocaleCompare("quantize",option+1) == 0)
906  {
907  ssize_t
908  colorspace;
909 
910  if (*option == '+')
911  break;
912  i++;
913  if (i == (ssize_t) argc)
914  ThrowCompareException(OptionError,"MissingArgument",option);
915  colorspace=ParseCommandOption(MagickColorspaceOptions,
916  MagickFalse,argv[i]);
917  if (colorspace < 0)
918  ThrowCompareException(OptionError,"UnrecognizedColorspace",
919  argv[i]);
920  break;
921  }
922  if (LocaleCompare("quiet",option+1) == 0)
923  break;
924  ThrowCompareException(OptionError,"UnrecognizedOption",option)
925  }
926  case 'r':
927  {
928  if (LocaleCompare("regard-warnings",option+1) == 0)
929  break;
930  if (LocaleCompare("repage",option+1) == 0)
931  {
932  if (*option == '+')
933  break;
934  i++;
935  if (i == (ssize_t) argc)
936  ThrowCompareException(OptionError,"MissingArgument",option);
937  if (IsGeometry(argv[i]) == MagickFalse)
938  ThrowCompareInvalidArgumentException(option,argv[i]);
939  break;
940  }
941  if (LocaleCompare("resize",option+1) == 0)
942  {
943  if (*option == '+')
944  break;
945  i++;
946  if (i == (ssize_t) argc)
947  ThrowCompareException(OptionError,"MissingArgument",option);
948  if (IsGeometry(argv[i]) == MagickFalse)
949  ThrowCompareInvalidArgumentException(option,argv[i]);
950  break;
951  }
952  if (LocaleCompare("rotate",option+1) == 0)
953  {
954  i++;
955  if (i == (ssize_t) argc)
956  ThrowCompareException(OptionError,"MissingArgument",option);
957  if (IsGeometry(argv[i]) == MagickFalse)
958  ThrowCompareInvalidArgumentException(option,argv[i]);
959  break;
960  }
961  if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
962  {
963  respect_parenthesis=(*option == '-') ? MagickTrue : MagickFalse;
964  break;
965  }
966  ThrowCompareException(OptionError,"UnrecognizedOption",option)
967  }
968  case 's':
969  {
970  if (LocaleCompare("sampling-factor",option+1) == 0)
971  {
972  if (*option == '+')
973  break;
974  i++;
975  if (i == (ssize_t) argc)
976  ThrowCompareException(OptionError,"MissingArgument",option);
977  if (IsGeometry(argv[i]) == MagickFalse)
978  ThrowCompareInvalidArgumentException(option,argv[i]);
979  break;
980  }
981  if (LocaleCompare("seed",option+1) == 0)
982  {
983  if (*option == '+')
984  break;
985  i++;
986  if (i == (ssize_t) argc)
987  ThrowCompareException(OptionError,"MissingArgument",option);
988  if (IsGeometry(argv[i]) == MagickFalse)
989  ThrowCompareInvalidArgumentException(option,argv[i]);
990  break;
991  }
992  if (LocaleCompare("separate",option+1) == 0)
993  break;
994  if (LocaleCompare("set",option+1) == 0)
995  {
996  i++;
997  if (i == (ssize_t) argc)
998  ThrowCompareException(OptionError,"MissingArgument",option);
999  if (*option == '+')
1000  break;
1001  i++;
1002  if (i == (ssize_t) argc)
1003  ThrowCompareException(OptionError,"MissingArgument",option);
1004  break;
1005  }
1006  if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
1007  {
1008  i++;
1009  if (i == (ssize_t) argc)
1010  ThrowCompareException(OptionError,"MissingArgument",option);
1011  if (IsGeometry(argv[i]) == MagickFalse)
1012  ThrowCompareInvalidArgumentException(option,argv[i]);
1013  break;
1014  }
1015  if (LocaleCompare("similarity-threshold",option+1) == 0)
1016  {
1017  if (*option == '+')
1018  break;
1019  i++;
1020  if (i == (ssize_t) argc)
1021  ThrowCompareException(OptionError,"MissingArgument",option);
1022  if (IsGeometry(argv[i]) == MagickFalse)
1023  ThrowCompareInvalidArgumentException(option,argv[i]);
1024  if (*option == '+')
1025  similarity_threshold=DefaultSimilarityThreshold;
1026  else
1027  similarity_threshold=StringToDouble(argv[i],(char **) NULL);
1028  break;
1029  }
1030  if (LocaleCompare("size",option+1) == 0)
1031  {
1032  if (*option == '+')
1033  break;
1034  i++;
1035  if (i == (ssize_t) argc)
1036  ThrowCompareException(OptionError,"MissingArgument",option);
1037  if (IsGeometry(argv[i]) == MagickFalse)
1038  ThrowCompareInvalidArgumentException(option,argv[i]);
1039  break;
1040  }
1041  if (LocaleCompare("subimage-search",option+1) == 0)
1042  {
1043  if (*option == '+')
1044  {
1045  subimage_search=MagickFalse;
1046  break;
1047  }
1048  subimage_search=MagickTrue;
1049  break;
1050  }
1051  if (LocaleCompare("synchronize",option+1) == 0)
1052  break;
1053  ThrowCompareException(OptionError,"UnrecognizedOption",option)
1054  }
1055  case 't':
1056  {
1057  if (LocaleCompare("taint",option+1) == 0)
1058  break;
1059  if (LocaleCompare("transparent-color",option+1) == 0)
1060  {
1061  if (*option == '+')
1062  break;
1063  i++;
1064  if (i == (ssize_t) argc)
1065  ThrowCompareException(OptionError,"MissingArgument",option);
1066  break;
1067  }
1068  if (LocaleCompare("trim",option+1) == 0)
1069  break;
1070  if (LocaleCompare("type",option+1) == 0)
1071  {
1072  ssize_t
1073  type;
1074 
1075  if (*option == '+')
1076  break;
1077  i++;
1078  if (i == (ssize_t) argc)
1079  ThrowCompareException(OptionError,"MissingArgument",option);
1080  type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
1081  if (type < 0)
1082  ThrowCompareException(OptionError,"UnrecognizedImageType",
1083  argv[i]);
1084  break;
1085  }
1086  ThrowCompareException(OptionError,"UnrecognizedOption",option)
1087  }
1088  case 'v':
1089  {
1090  if (LocaleCompare("verbose",option+1) == 0)
1091  break;
1092  if ((LocaleCompare("version",option+1) == 0) ||
1093  (LocaleCompare("-version",option+1) == 0))
1094  {
1095  ListMagickVersion(stdout);
1096  break;
1097  }
1098  if (LocaleCompare("virtual-pixel",option+1) == 0)
1099  {
1100  ssize_t
1101  method;
1102 
1103  if (*option == '+')
1104  break;
1105  i++;
1106  if (i == (ssize_t) argc)
1107  ThrowCompareException(OptionError,"MissingArgument",option);
1108  method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
1109  argv[i]);
1110  if (method < 0)
1111  ThrowCompareException(OptionError,
1112  "UnrecognizedVirtualPixelMethod",argv[i]);
1113  break;
1114  }
1115  ThrowCompareException(OptionError,"UnrecognizedOption",option)
1116  }
1117  case 'w':
1118  {
1119  if (LocaleCompare("write",option+1) == 0)
1120  {
1121  i++;
1122  if (i == (ssize_t) argc)
1123  ThrowCompareException(OptionError,"MissingArgument",option);
1124  break;
1125  }
1126  ThrowCompareException(OptionError,"UnrecognizedOption",option)
1127  }
1128  case '?':
1129  break;
1130  default:
1131  ThrowCompareException(OptionError,"UnrecognizedOption",option)
1132  }
1133  fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
1134  FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
1135  if (fire != MagickFalse)
1136  FireImageStack(MagickTrue,MagickTrue,MagickTrue);
1137  }
1138  if (k != 0)
1139  ThrowCompareException(OptionError,"UnbalancedParenthesis",argv[i]);
1140  if (i-- != (ssize_t) (argc-1))
1141  ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
1142  if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
1143  ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
1144  FinalizeImageSettings(image_info,image,MagickTrue);
1145  if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
1146  ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
1147  image=GetImageFromList(image,0);
1148  reconstruct_image=GetImageFromList(image,1);
1149  offset.x=0;
1150  offset.y=0;
1151  if (subimage_search != MagickFalse)
1152  {
1153  char
1154  artifact[MaxTextExtent];
1155 
1156  (void) FormatLocaleString(artifact,MaxTextExtent,"%g",
1157  similarity_threshold);
1158  (void) SetImageArtifact(image,"compare:similarity-threshold",artifact);
1159  similarity_image=SimilarityMetricImage(image,reconstruct_image,metric,
1160  &offset,&similarity_metric,exception);
1161  if (similarity_metric > dissimilarity_threshold)
1162  ThrowCompareException(ImageError,"ImagesTooDissimilar",image->filename);
1163  }
1164  if ((reconstruct_image->columns == image->columns) &&
1165  (reconstruct_image->rows == image->rows))
1166  difference_image=CompareImageChannels(image,reconstruct_image,channels,
1167  metric,&distortion,exception);
1168  else
1169  if (similarity_image == (Image *) NULL)
1170  difference_image=CompareImageChannels(image,reconstruct_image,channels,
1171  metric,&distortion,exception);
1172  else
1173  {
1174  Image
1175  *composite_image;
1176 
1177  /*
1178  Determine if reconstructed image is a subimage of the image.
1179  */
1180  composite_image=CloneImage(image,0,0,MagickTrue,exception);
1181  if (composite_image == (Image *) NULL)
1182  difference_image=CompareImageChannels(image,reconstruct_image,
1183  channels,metric,&distortion,exception);
1184  else
1185  {
1186  Image
1187  *distort_image;
1188 
1189  RectangleInfo
1190  page;
1191 
1192  (void) CompositeImage(composite_image,CopyCompositeOp,
1193  reconstruct_image,offset.x,offset.y);
1194  difference_image=CompareImageChannels(image,composite_image,
1195  channels,metric,&distortion,exception);
1196  if (difference_image != (Image *) NULL)
1197  {
1198  difference_image->page.x=offset.x;
1199  difference_image->page.y=offset.y;
1200  }
1201  composite_image=DestroyImage(composite_image);
1202  page.width=reconstruct_image->columns;
1203  page.height=reconstruct_image->rows;
1204  page.x=offset.x;
1205  page.y=offset.y;
1206  distort_image=CropImage(image,&page,exception);
1207  if (distort_image != (Image *) NULL)
1208  {
1209  Image
1210  *sans_image;
1211 
1212  sans_image=CompareImageChannels(distort_image,reconstruct_image,
1213  channels,metric,&distortion,exception);
1214  distort_image=DestroyImage(distort_image);
1215  if (sans_image != (Image *) NULL)
1216  sans_image=DestroyImage(sans_image);
1217  }
1218  }
1219  if (difference_image != (Image *) NULL)
1220  {
1221  AppendImageToList(&difference_image,similarity_image);
1222  similarity_image=(Image *) NULL;
1223  }
1224  }
1225  if (difference_image == (Image *) NULL)
1226  status=0;
1227  else
1228  {
1229  if (image_info->verbose != MagickFalse)
1230  (void) IsImagesEqual(image,reconstruct_image);
1231  if (*difference_image->magick == '\0')
1232  (void) CopyMagickString(difference_image->magick,image->magick,
1233  MaxTextExtent);
1234  if (image_info->verbose == MagickFalse)
1235  {
1236  switch (metric)
1237  {
1238  case FuzzErrorMetric:
1239  case MeanAbsoluteErrorMetric:
1240  case MeanSquaredErrorMetric:
1241  case PeakAbsoluteErrorMetric:
1242  case RootMeanSquaredErrorMetric:
1243  {
1244  (void) FormatLocaleFile(stderr,"%.*g (%.*g)",GetMagickPrecision(),
1245  QuantumRange*distortion,GetMagickPrecision(),distortion);
1246  break;
1247  }
1248  case PeakSignalToNoiseRatioMetric:
1249  {
1250  (void) FormatLocaleFile(stderr,"%.*g (%.*g)",GetMagickPrecision(),
1251  distortion,GetMagickPrecision(),0.01*distortion);
1252  break;
1253  }
1254  case AbsoluteErrorMetric:
1255  case NormalizedCrossCorrelationErrorMetric:
1256  case PerceptualHashErrorMetric:
1257  {
1258  (void) FormatLocaleFile(stderr,"%.*g",GetMagickPrecision(),
1259  distortion);
1260  break;
1261  }
1262  case MeanErrorPerPixelMetric:
1263  {
1264  (void) FormatLocaleFile(stderr,"%.*g (%.*g, %.*g)",
1265  GetMagickPrecision(),distortion,
1266  GetMagickPrecision(),image->error.normalized_mean_error,
1267  GetMagickPrecision(),image->error.normalized_maximum_error);
1268  break;
1269  }
1270  case UndefinedErrorMetric:
1271  break;
1272  }
1273  if (subimage_search != MagickFalse)
1274  (void) FormatLocaleFile(stderr," @ %.20g,%.20g",(double)
1275  difference_image->page.x,(double) difference_image->page.y);
1276  }
1277  else
1278  {
1279  double
1280  *channel_distortion;
1281 
1282  channel_distortion=GetImageChannelDistortions(image,reconstruct_image,
1283  metric,&image->exception);
1284  (void) FormatLocaleFile(stderr,"Image: %s\n",image->filename);
1285  if ((reconstruct_image->columns != image->columns) ||
1286  (reconstruct_image->rows != image->rows))
1287  (void) FormatLocaleFile(stderr,"Offset: %.20g,%.20g\n",(double)
1288  difference_image->page.x,(double) difference_image->page.y);
1289  (void) FormatLocaleFile(stderr," Channel distortion: %s\n",
1290  CommandOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
1291  switch (metric)
1292  {
1293  case FuzzErrorMetric:
1294  case MeanAbsoluteErrorMetric:
1295  case MeanSquaredErrorMetric:
1296  case PeakAbsoluteErrorMetric:
1297  case RootMeanSquaredErrorMetric:
1298  {
1299  switch (image->colorspace)
1300  {
1301  case RGBColorspace:
1302  default:
1303  {
1304  (void) FormatLocaleFile(stderr," red: %.*g (%.*g)\n",
1305  GetMagickPrecision(),QuantumRange*
1306  channel_distortion[RedChannel],GetMagickPrecision(),
1307  channel_distortion[RedChannel]);
1308  (void) FormatLocaleFile(stderr," green: %.*g (%.*g)\n",
1309  GetMagickPrecision(),QuantumRange*
1310  channel_distortion[GreenChannel],GetMagickPrecision(),
1311  channel_distortion[GreenChannel]);
1312  (void) FormatLocaleFile(stderr," blue: %.*g (%.*g)\n",
1313  GetMagickPrecision(),QuantumRange*
1314  channel_distortion[BlueChannel],GetMagickPrecision(),
1315  channel_distortion[BlueChannel]);
1316  if (image->matte != MagickFalse)
1317  (void) FormatLocaleFile(stderr," alpha: %.*g (%.*g)\n",
1318  GetMagickPrecision(),QuantumRange*
1319  channel_distortion[OpacityChannel],GetMagickPrecision(),
1320  channel_distortion[OpacityChannel]);
1321  break;
1322  }
1323  case CMYKColorspace:
1324  {
1325  (void) FormatLocaleFile(stderr," cyan: %.*g (%.*g)\n",
1326  GetMagickPrecision(),QuantumRange*
1327  channel_distortion[CyanChannel],GetMagickPrecision(),
1328  channel_distortion[CyanChannel]);
1329  (void) FormatLocaleFile(stderr," magenta: %.*g (%.*g)\n",
1330  GetMagickPrecision(),QuantumRange*
1331  channel_distortion[MagentaChannel],GetMagickPrecision(),
1332  channel_distortion[MagentaChannel]);
1333  (void) FormatLocaleFile(stderr," yellow: %.*g (%.*g)\n",
1334  GetMagickPrecision(),QuantumRange*
1335  channel_distortion[YellowChannel],GetMagickPrecision(),
1336  channel_distortion[YellowChannel]);
1337  (void) FormatLocaleFile(stderr," black: %.*g (%.*g)\n",
1338  GetMagickPrecision(),QuantumRange*
1339  channel_distortion[BlackChannel],GetMagickPrecision(),
1340  channel_distortion[BlackChannel]);
1341  if (image->matte != MagickFalse)
1342  (void) FormatLocaleFile(stderr," alpha: %.*g (%.*g)\n",
1343  GetMagickPrecision(),QuantumRange*
1344  channel_distortion[OpacityChannel],GetMagickPrecision(),
1345  channel_distortion[OpacityChannel]);
1346  break;
1347  }
1348  case LinearGRAYColorspace:
1349  case GRAYColorspace:
1350  {
1351  (void) FormatLocaleFile(stderr," gray: %.*g (%.*g)\n",
1352  GetMagickPrecision(),QuantumRange*
1353  channel_distortion[GrayChannel],GetMagickPrecision(),
1354  channel_distortion[GrayChannel]);
1355  if (image->matte != MagickFalse)
1356  (void) FormatLocaleFile(stderr," alpha: %.*g (%.*g)\n",
1357  GetMagickPrecision(),QuantumRange*
1358  channel_distortion[OpacityChannel],GetMagickPrecision(),
1359  channel_distortion[OpacityChannel]);
1360  break;
1361  }
1362  }
1363  (void) FormatLocaleFile(stderr," all: %.*g (%.*g)\n",
1364  GetMagickPrecision(),QuantumRange*
1365  channel_distortion[CompositeChannels],GetMagickPrecision(),
1366  channel_distortion[CompositeChannels]);
1367  break;
1368  }
1369  case AbsoluteErrorMetric:
1370  case NormalizedCrossCorrelationErrorMetric:
1371  case PeakSignalToNoiseRatioMetric:
1372  case PerceptualHashErrorMetric:
1373  {
1374  switch (image->colorspace)
1375  {
1376  case RGBColorspace:
1377  default:
1378  {
1379  (void) FormatLocaleFile(stderr," red: %.*g\n",
1380  GetMagickPrecision(),channel_distortion[RedChannel]);
1381  (void) FormatLocaleFile(stderr," green: %.*g\n",
1382  GetMagickPrecision(),channel_distortion[GreenChannel]);
1383  (void) FormatLocaleFile(stderr," blue: %.*g\n",
1384  GetMagickPrecision(),channel_distortion[BlueChannel]);
1385  if (image->matte != MagickFalse)
1386  (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1387  GetMagickPrecision(),channel_distortion[OpacityChannel]);
1388  break;
1389  }
1390  case CMYKColorspace:
1391  {
1392  (void) FormatLocaleFile(stderr," cyan: %.*g\n",
1393  GetMagickPrecision(),channel_distortion[CyanChannel]);
1394  (void) FormatLocaleFile(stderr," magenta: %.*g\n",
1395  GetMagickPrecision(),channel_distortion[MagentaChannel]);
1396  (void) FormatLocaleFile(stderr," yellow: %.*g\n",
1397  GetMagickPrecision(),channel_distortion[YellowChannel]);
1398  (void) FormatLocaleFile(stderr," black: %.*g\n",
1399  GetMagickPrecision(),channel_distortion[BlackChannel]);
1400  if (image->matte != MagickFalse)
1401  (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1402  GetMagickPrecision(),channel_distortion[OpacityChannel]);
1403  break;
1404  }
1405  case LinearGRAYColorspace:
1406  case GRAYColorspace:
1407  {
1408  (void) FormatLocaleFile(stderr," gray: %.*g\n",
1409  GetMagickPrecision(),channel_distortion[GrayChannel]);
1410  if (image->matte != MagickFalse)
1411  (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1412  GetMagickPrecision(),channel_distortion[OpacityChannel]);
1413  break;
1414  }
1415  }
1416  (void) FormatLocaleFile(stderr," all: %.*g\n",
1417  GetMagickPrecision(),channel_distortion[CompositeChannels]);
1418  break;
1419  }
1420  case MeanErrorPerPixelMetric:
1421  {
1422  (void) FormatLocaleFile(stderr," %.*g (%.*g, %.*g)\n",
1423  GetMagickPrecision(),channel_distortion[CompositeChannels],
1424  GetMagickPrecision(),image->error.normalized_mean_error,
1425  GetMagickPrecision(),image->error.normalized_maximum_error);
1426  break;
1427  }
1428  case UndefinedErrorMetric:
1429  break;
1430  }
1431  channel_distortion=(double *) RelinquishMagickMemory(
1432  channel_distortion);
1433  if (subimage_search != MagickFalse)
1434  (void) FormatLocaleFile(stderr," Offset: %.20g,%.20g\n",(double)
1435  difference_image->page.x,(double) difference_image->page.y);
1436  }
1437  (void) ResetImagePage(difference_image,"0x0+0+0");
1438  if (difference_image->next != (Image *) NULL)
1439  (void) ResetImagePage(difference_image->next,"0x0+0+0");
1440  status&=WriteImages(image_info,difference_image,argv[argc-1],exception);
1441  if ((metadata != (char **) NULL) && (format != (char *) NULL))
1442  {
1443  char
1444  *text;
1445 
1446  text=InterpretImageProperties(image_info,difference_image,format);
1447  InheritException(exception,&image->exception);
1448  if (text == (char *) NULL)
1449  ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
1450  GetExceptionMessage(errno));
1451  (void) ConcatenateString(&(*metadata),text);
1452  text=DestroyString(text);
1453  }
1454  difference_image=DestroyImageList(difference_image);
1455  }
1456  DestroyCompare();
1457  image_info=restore_info;
1458  if ((metric == NormalizedCrossCorrelationErrorMetric) ||
1459  (metric == UndefinedErrorMetric))
1460  {
1461  if (fabs(distortion-1.0) > CompareEpsilon)
1462  (void) SetImageOption(image_info,"compare:dissimilar","true");
1463  }
1464  else
1465  if (fabs(distortion) > CompareEpsilon)
1466  (void) SetImageOption(image_info,"compare:dissimilar","true");
1467  return(status != 0 ? MagickTrue : MagickFalse);
1468 }