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