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