MagickWand 7.1.2-21
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 if (exception->severity < (asperity)) \
225 (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag, \
226 "`%s'",option); \
227 DestroyCompare(); \
228 return(MagickFalse); \
229}
230#define ThrowCompareInvalidArgumentException(option,argument) \
231{ \
232 (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
233 "InvalidArgument","'%s': %s",option,argument); \
234 DestroyCompare(); \
235 return(MagickFalse); \
236}
237
238 char
239 *filename,
240 *option;
241
242 const char
243 *format;
244
245 double
246 dissimilarity_threshold = DefaultDissimilarityThreshold,
247 distortion = 0.0,
248 scale = (double) QuantumRange,
249 similarity_metric = 0.0,
250 similarity_threshold = DefaultSimilarityThreshold;
251
252 Image
253 *difference_image,
254 *image = (Image *) NULL,
255 *reconstruct_image,
256 *similarity_image;
257
258 ImageStack
259 image_stack[MaxImageStackDepth+1];
260
261 MagickBooleanType
262 fire,
263 pend,
264 respect_parentheses,
265 similar = MagickTrue,
266 subimage_search;
267
268 MagickStatusType
269 status;
270
271 MetricType
272 metric = UndefinedErrorMetric;
273
274 RectangleInfo
275 offset;
276
277 ssize_t
278 i;
279
280 ssize_t
281 j,
282 k;
283
284 /*
285 Set defaults.
286 */
287 assert(image_info != (ImageInfo *) NULL);
288 assert(image_info->signature == MagickCoreSignature);
289 assert(exception != (ExceptionInfo *) NULL);
290 if (IsEventLogging() != MagickFalse)
291 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
292 if (argc == 2)
293 {
294 option=argv[1];
295 if ((LocaleCompare("version",option+1) == 0) ||
296 (LocaleCompare("-version",option+1) == 0))
297 {
298 ListMagickVersion(stdout);
299 return(MagickTrue);
300 }
301 }
302 if (argc < 3)
303 {
304 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
305 "MissingArgument","%s","");
306 (void) CompareUsage();
307 return(MagickFalse);
308 }
309 difference_image=NewImageList();
310 similarity_image=NewImageList();
311 format=(char *) NULL;
312 j=1;
313 k=0;
314 NewImageStack();
315 option=(char *) NULL;
316 pend=MagickFalse;
317 reconstruct_image=NewImageList();
318 respect_parentheses=MagickFalse;
319 status=MagickTrue;
320 subimage_search=MagickFalse;
321 /*
322 Compare an image.
323 */
324 ReadCommandlLine(argc,&argv);
325 status=ExpandFilenames(&argc,&argv);
326 if (status == MagickFalse)
327 ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
328 GetExceptionMessage(errno));
329 for (i=1; i < ((ssize_t) argc-1); i++)
330 {
331 option=argv[i];
332 if (LocaleCompare(option,"(") == 0)
333 {
334 FireImageStack(MagickTrue,MagickTrue,pend);
335 if (k == MaxImageStackDepth)
336 ThrowCompareException(OptionError,"ParenthesisNestedTooDeeply",
337 option);
338 PushImageStack();
339 continue;
340 }
341 if (LocaleCompare(option,")") == 0)
342 {
343 FireImageStack(MagickTrue,MagickTrue,MagickTrue);
344 if (k == 0)
345 ThrowCompareException(OptionError,"UnableToParseExpression",option);
346 PopImageStack();
347 continue;
348 }
349 if (IsCommandOption(option) == MagickFalse)
350 {
351 Image
352 *images;
353
354 /*
355 Read input image.
356 */
357 FireImageStack(MagickFalse,MagickFalse,pend);
358 filename=argv[i];
359 if ((LocaleCompare(filename,"--") == 0) && (i < ((ssize_t) argc-1)))
360 filename=argv[++i];
361 images=ReadImages(image_info,filename,exception);
362 status&=(MagickStatusType) ((images != (Image *) NULL) &&
363 (exception->severity < ErrorException));
364 if (images == (Image *) NULL)
365 continue;
366 AppendImageStack(images);
367 continue;
368 }
369 pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
370 switch (*(option+1))
371 {
372 case 'a':
373 {
374 if (LocaleCompare("adjoin",option+1) == 0)
375 break;
376 if (LocaleCompare("alpha",option+1) == 0)
377 {
378 ssize_t
379 type;
380
381 if (*option == '+')
382 break;
383 i++;
384 if (i == (ssize_t) argc)
385 ThrowCompareException(OptionError,"MissingArgument",option);
386 type=ParseCommandOption(MagickAlphaChannelOptions,MagickFalse,
387 argv[i]);
388 if (type < 0)
389 ThrowCompareException(OptionError,
390 "UnrecognizedAlphaChannelOption",argv[i]);
391 break;
392 }
393 if (LocaleCompare("auto-orient",option+1) == 0)
394 break;
395 if (LocaleCompare("authenticate",option+1) == 0)
396 {
397 if (*option == '+')
398 break;
399 i++;
400 if (i == (ssize_t) argc)
401 ThrowCompareException(OptionError,"MissingArgument",option);
402 break;
403 }
404 ThrowCompareException(OptionError,"UnrecognizedOption",option);
405 }
406 case 'b':
407 {
408 if (LocaleCompare("background",option+1) == 0)
409 {
410 if (*option == '+')
411 break;
412 i++;
413 if (i == (ssize_t) argc)
414 ThrowCompareException(OptionError,"MissingArgument",option);
415 break;
416 }
417 if (LocaleCompare("brightness-contrast",option+1) == 0)
418 {
419 i++;
420 if (i == (ssize_t) argc)
421 ThrowCompareException(OptionError,"MissingArgument",option);
422 if (IsGeometry(argv[i]) == MagickFalse)
423 ThrowCompareInvalidArgumentException(option,argv[i]);
424 break;
425 }
426 ThrowCompareException(OptionError,"UnrecognizedOption",option);
427 }
428 case 'c':
429 {
430 if (LocaleCompare("cache",option+1) == 0)
431 {
432 if (*option == '+')
433 break;
434 i++;
435 if (i == (ssize_t) argc)
436 ThrowCompareException(OptionError,"MissingArgument",option);
437 if (IsGeometry(argv[i]) == MagickFalse)
438 ThrowCompareInvalidArgumentException(option,argv[i]);
439 break;
440 }
441 if (LocaleCompare("channel",option+1) == 0)
442 {
443 ssize_t
444 channel;
445
446 if (*option == '+')
447 break;
448 i++;
449 if (i == (ssize_t) argc)
450 ThrowCompareException(OptionError,"MissingArgument",option);
451 channel=ParseChannelOption(argv[i]);
452 if (channel < 0)
453 ThrowCompareException(OptionError,"UnrecognizedChannelType",
454 argv[i]);
455 break;
456 }
457 if (LocaleCompare("colorspace",option+1) == 0)
458 {
459 ssize_t
460 colorspace;
461
462 if (*option == '+')
463 break;
464 i++;
465 if (i == (ssize_t) argc)
466 ThrowCompareException(OptionError,"MissingArgument",option);
467 colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
468 argv[i]);
469 if (colorspace < 0)
470 ThrowCompareException(OptionError,"UnrecognizedColorspace",
471 argv[i]);
472 break;
473 }
474 if (LocaleCompare("compose",option+1) == 0)
475 {
476 ssize_t
477 compose;
478
479 if (*option == '+')
480 break;
481 i++;
482 if (i == (ssize_t) argc)
483 ThrowCompareException(OptionError,"MissingArgument",option);
484 compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
485 argv[i]);
486 if (compose < 0)
487 ThrowCompareException(OptionError,"UnrecognizedComposeOperator",
488 argv[i]);
489 break;
490 }
491 if (LocaleCompare("compress",option+1) == 0)
492 {
493 ssize_t
494 compress;
495
496 if (*option == '+')
497 break;
498 i++;
499 if (i == (ssize_t) argc)
500 ThrowCompareException(OptionError,"MissingArgument",option);
501 compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
502 argv[i]);
503 if (compress < 0)
504 ThrowCompareException(OptionError,"UnrecognizedImageCompression",
505 argv[i]);
506 break;
507 }
508 if (LocaleCompare("concurrent",option+1) == 0)
509 break;
510 if (LocaleCompare("crop",option+1) == 0)
511 {
512 if (*option == '+')
513 break;
514 i++;
515 if (i == (ssize_t) argc)
516 ThrowCompareException(OptionError,"MissingArgument",option);
517 if (IsGeometry(argv[i]) == MagickFalse)
518 ThrowCompareInvalidArgumentException(option,argv[i]);
519 break;
520 }
521 ThrowCompareException(OptionError,"UnrecognizedOption",option)
522 }
523 case 'd':
524 {
525 if (LocaleCompare("debug",option+1) == 0)
526 {
527 LogEventType
528 event_mask;
529
530 if (*option == '+')
531 break;
532 i++;
533 if (i == (ssize_t) argc)
534 ThrowCompareException(OptionError,"MissingArgument",option);
535 event_mask=SetLogEventMask(argv[i]);
536 if (event_mask == UndefinedEvents)
537 ThrowCompareException(OptionError,"UnrecognizedEventType",
538 argv[i]);
539 break;
540 }
541 if (LocaleCompare("decipher",option+1) == 0)
542 {
543 if (*option == '+')
544 break;
545 i++;
546 if (i == (ssize_t) argc)
547 ThrowCompareException(OptionError,"MissingArgument",option);
548 break;
549 }
550 if (LocaleCompare("define",option+1) == 0)
551 {
552 i++;
553 if (i == (ssize_t) argc)
554 ThrowCompareException(OptionError,"MissingArgument",option);
555 if (*option == '+')
556 {
557 const char
558 *define;
559
560 define=GetImageOption(image_info,argv[i]);
561 if (define == (const char *) NULL)
562 ThrowCompareException(OptionError,"NoSuchOption",argv[i]);
563 break;
564 }
565 break;
566 }
567 if (LocaleCompare("delete",option+1) == 0)
568 {
569 if (*option == '+')
570 break;
571 i++;
572 if (i == (ssize_t) argc)
573 ThrowCompareException(OptionError,"MissingArgument",option);
574 if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
575 ThrowCompareInvalidArgumentException(option,argv[i]);
576 break;
577 }
578 if (LocaleCompare("density",option+1) == 0)
579 {
580 if (*option == '+')
581 break;
582 i++;
583 if (i == (ssize_t) argc)
584 ThrowCompareException(OptionError,"MissingArgument",option);
585 if (IsGeometry(argv[i]) == MagickFalse)
586 ThrowCompareInvalidArgumentException(option,argv[i]);
587 break;
588 }
589 if (LocaleCompare("depth",option+1) == 0)
590 {
591 if (*option == '+')
592 break;
593 i++;
594 if (i == (ssize_t) argc)
595 ThrowCompareException(OptionError,"MissingArgument",option);
596 if (IsGeometry(argv[i]) == MagickFalse)
597 ThrowCompareInvalidArgumentException(option,argv[i]);
598 break;
599 }
600 if (LocaleCompare("dissimilarity-threshold",option+1) == 0)
601 {
602 if (*option == '+')
603 break;
604 i++;
605 if (i == (ssize_t) argc)
606 ThrowCompareException(OptionError,"MissingArgument",option);
607 if (IsGeometry(argv[i]) == MagickFalse)
608 ThrowCompareInvalidArgumentException(option,argv[i]);
609 if (*option == '+')
610 dissimilarity_threshold=DefaultDissimilarityThreshold;
611 else
612 dissimilarity_threshold=StringToDouble(argv[i],(char **) NULL);
613 break;
614 }
615 if (LocaleCompare("distort",option+1) == 0)
616 {
617 ssize_t
618 op;
619
620 i++;
621 if (i == (ssize_t) argc)
622 ThrowCompareException(OptionError,"MissingArgument",option);
623 op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
624 if (op < 0)
625 ThrowCompareException(OptionError,"UnrecognizedDistortMethod",
626 argv[i]);
627 i++;
628 if (i == (ssize_t) argc)
629 ThrowCompareException(OptionError,"MissingArgument",option);
630 break;
631 }
632 if (LocaleCompare("duration",option+1) == 0)
633 {
634 if (*option == '+')
635 break;
636 i++;
637 if (i == (ssize_t) argc)
638 ThrowCompareException(OptionError,"MissingArgument",option);
639 if (IsGeometry(argv[i]) == MagickFalse)
640 ThrowCompareInvalidArgumentException(option,argv[i]);
641 break;
642 }
643 ThrowCompareException(OptionError,"UnrecognizedOption",option)
644 }
645 case 'e':
646 {
647 if (LocaleCompare("encipher",option+1) == 0)
648 {
649 if (*option == '+')
650 break;
651 i++;
652 if (i == (ssize_t) argc)
653 ThrowCompareException(OptionError,"MissingArgument",option);
654 break;
655 }
656 if (LocaleCompare("extract",option+1) == 0)
657 {
658 if (*option == '+')
659 break;
660 i++;
661 if (i == (ssize_t) argc)
662 ThrowCompareException(OptionError,"MissingArgument",option);
663 if (IsGeometry(argv[i]) == MagickFalse)
664 ThrowCompareInvalidArgumentException(option,argv[i]);
665 break;
666 }
667 ThrowCompareException(OptionError,"UnrecognizedOption",option)
668 }
669 case 'f':
670 {
671 if (LocaleCompare("format",option+1) == 0)
672 {
673 if (*option == '+')
674 break;
675 i++;
676 if (i == (ssize_t) argc)
677 ThrowCompareException(OptionError,"MissingArgument",option);
678 format=argv[i];
679 break;
680 }
681 if (LocaleCompare("fuzz",option+1) == 0)
682 {
683 if (*option == '+')
684 break;
685 i++;
686 if (i == (ssize_t) argc)
687 ThrowCompareException(OptionError,"MissingArgument",option);
688 if (IsGeometry(argv[i]) == MagickFalse)
689 ThrowCompareInvalidArgumentException(option,argv[i]);
690 break;
691 }
692 ThrowCompareException(OptionError,"UnrecognizedOption",option)
693 }
694 case 'g':
695 {
696 if (LocaleCompare("gravity",option+1) == 0)
697 {
698 ssize_t
699 gravity;
700
701 if (*option == '+')
702 break;
703 i++;
704 if (i == (ssize_t) argc)
705 ThrowCompareException(OptionError,"MissingArgument",option);
706 gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
707 argv[i]);
708 if (gravity < 0)
709 ThrowCompareException(OptionError,"UnrecognizedGravityType",
710 argv[i]);
711 break;
712 }
713 ThrowCompareException(OptionError,"UnrecognizedOption",option)
714 }
715 case 'h':
716 {
717 if ((LocaleCompare("help",option+1) == 0) ||
718 (LocaleCompare("-help",option+1) == 0))
719 {
720 DestroyCompare();
721 return(CompareUsage());
722 }
723 if (LocaleCompare("highlight-color",option+1) == 0)
724 {
725 if (*option == '+')
726 break;
727 i++;
728 if (i == (ssize_t) argc)
729 ThrowCompareException(OptionError,"MissingArgument",option);
730 break;
731 }
732 ThrowCompareException(OptionError,"UnrecognizedOption",option)
733 }
734 case 'i':
735 {
736 if (LocaleCompare("identify",option+1) == 0)
737 break;
738 if (LocaleCompare("interlace",option+1) == 0)
739 {
740 ssize_t
741 interlace;
742
743 if (*option == '+')
744 break;
745 i++;
746 if (i == (ssize_t) argc)
747 ThrowCompareException(OptionError,"MissingArgument",option);
748 interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
749 argv[i]);
750 if (interlace < 0)
751 ThrowCompareException(OptionError,"UnrecognizedInterlaceType",
752 argv[i]);
753 break;
754 }
755 ThrowCompareException(OptionError,"UnrecognizedOption",option)
756 }
757 case 'l':
758 {
759 if (LocaleCompare("level",option+1) == 0)
760 {
761 i++;
762 if (i == (ssize_t) argc)
763 ThrowCompareException(OptionError,"MissingArgument",option);
764 if (IsGeometry(argv[i]) == MagickFalse)
765 ThrowCompareInvalidArgumentException(option,argv[i]);
766 break;
767 }
768 if (LocaleCompare("limit",option+1) == 0)
769 {
770 char
771 *p;
772
773 double
774 value;
775
776 ssize_t
777 resource;
778
779 if (*option == '+')
780 break;
781 i++;
782 if (i == (ssize_t) argc)
783 ThrowCompareException(OptionError,"MissingArgument",option);
784 resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
785 argv[i]);
786 if (resource < 0)
787 ThrowCompareException(OptionError,"UnrecognizedResourceType",
788 argv[i]);
789 i++;
790 if (i == (ssize_t) argc)
791 ThrowCompareException(OptionError,"MissingArgument",option);
792 value=StringToDouble(argv[i],&p);
793 (void) value;
794 if ((p == argv[i]) && (LocaleCompare("unlimited",argv[i]) != 0))
795 ThrowCompareInvalidArgumentException(option,argv[i]);
796 break;
797 }
798 if (LocaleCompare("list",option+1) == 0)
799 {
800 ssize_t
801 list;
802
803 if (*option == '+')
804 break;
805 i++;
806 if (i == (ssize_t) argc)
807 ThrowCompareException(OptionError,"MissingArgument",option);
808 list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
809 if (list < 0)
810 ThrowCompareException(OptionError,"UnrecognizedListType",argv[i]);
811 status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
812 argv+j,exception);
813 DestroyCompare();
814 return(status == 0 ? MagickFalse : MagickTrue);
815 }
816 if (LocaleCompare("log",option+1) == 0)
817 {
818 if (*option == '+')
819 break;
820 i++;
821 if ((i == (ssize_t) argc) || (strchr(argv[i],'%') == (char *) NULL))
822 ThrowCompareException(OptionError,"MissingArgument",option);
823 break;
824 }
825 if (LocaleCompare("lowlight-color",option+1) == 0)
826 {
827 if (*option == '+')
828 break;
829 i++;
830 if (i == (ssize_t) argc)
831 ThrowCompareException(OptionError,"MissingArgument",option);
832 break;
833 }
834 ThrowCompareException(OptionError,"UnrecognizedOption",option)
835 }
836 case 'm':
837 {
838 if (LocaleCompare("matte",option+1) == 0)
839 break;
840 if (LocaleCompare("metric",option+1) == 0)
841 {
842 ssize_t
843 type;
844
845 if (*option == '+')
846 break;
847 i++;
848 if (i == (ssize_t) argc)
849 ThrowCompareException(OptionError,"MissingArgument",option);
850 type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
851 if (type < 0)
852 ThrowCompareException(OptionError,"UnrecognizedMetricType",
853 argv[i]);
854 metric=(MetricType) type;
855 break;
856 }
857 if (LocaleCompare("monitor",option+1) == 0)
858 break;
859 ThrowCompareException(OptionError,"UnrecognizedOption",option)
860 }
861 case 'n':
862 {
863 if (LocaleCompare("negate",option+1) == 0)
864 break;
865 ThrowCompareException(OptionError,"UnrecognizedOption",option)
866 }
867 case 'p':
868 {
869 if (LocaleCompare("passphrase",option+1) == 0)
870 {
871 if (*option == '+')
872 break;
873 i++;
874 if (i == (ssize_t) argc)
875 ThrowCompareException(OptionError,"MissingArgument",option);
876 break;
877 }
878 if (LocaleCompare("precision",option+1) == 0)
879 {
880 if (*option == '+')
881 break;
882 i++;
883 if (i == (ssize_t) argc)
884 ThrowCompareException(OptionError,"MissingArgument",option);
885 if (IsGeometry(argv[i]) == MagickFalse)
886 ThrowCompareInvalidArgumentException(option,argv[i]);
887 break;
888 }
889 if (LocaleCompare("profile",option+1) == 0)
890 {
891 i++;
892 if (i == (ssize_t) argc)
893 ThrowCompareException(OptionError,"MissingArgument",option);
894 break;
895 }
896 ThrowCompareException(OptionError,"UnrecognizedOption",option)
897 }
898 case 'q':
899 {
900 if (LocaleCompare("quality",option+1) == 0)
901 {
902 if (*option == '+')
903 break;
904 i++;
905 if (i == (ssize_t) argc)
906 ThrowCompareException(OptionError,"MissingArgument",option);
907 if (IsGeometry(argv[i]) == MagickFalse)
908 ThrowCompareInvalidArgumentException(option,argv[i]);
909 break;
910 }
911 if (LocaleCompare("quantize",option+1) == 0)
912 {
913 ssize_t
914 colorspace;
915
916 if (*option == '+')
917 break;
918 i++;
919 if (i == (ssize_t) argc)
920 ThrowCompareException(OptionError,"MissingArgument",option);
921 colorspace=ParseCommandOption(MagickColorspaceOptions,
922 MagickFalse,argv[i]);
923 if (colorspace < 0)
924 ThrowCompareException(OptionError,"UnrecognizedColorspace",
925 argv[i]);
926 break;
927 }
928 if (LocaleCompare("quiet",option+1) == 0)
929 break;
930 ThrowCompareException(OptionError,"UnrecognizedOption",option)
931 }
932 case 'r':
933 {
934 if (LocaleCompare("read-mask",option+1) == 0)
935 {
936 if (*option == '+')
937 break;
938 i++;
939 if (i == (ssize_t) argc)
940 ThrowCompareException(OptionError,"MissingArgument",option);
941 break;
942 }
943 if (LocaleCompare("regard-warnings",option+1) == 0)
944 break;
945 if (LocaleCompare("repage",option+1) == 0)
946 {
947 if (*option == '+')
948 break;
949 i++;
950 if (i == (ssize_t) argc)
951 ThrowCompareException(OptionError,"MissingArgument",option);
952 if (IsGeometry(argv[i]) == MagickFalse)
953 ThrowCompareInvalidArgumentException(option,argv[i]);
954 break;
955 }
956 if (LocaleCompare("resize",option+1) == 0)
957 {
958 if (*option == '+')
959 break;
960 i++;
961 if (i == (ssize_t) argc)
962 ThrowCompareException(OptionError,"MissingArgument",option);
963 if (IsGeometry(argv[i]) == MagickFalse)
964 ThrowCompareInvalidArgumentException(option,argv[i]);
965 break;
966 }
967 if (LocaleNCompare("respect-parentheses",option+1,17) == 0)
968 {
969 respect_parentheses=(*option == '-') ? MagickTrue : MagickFalse;
970 break;
971 }
972 if (LocaleCompare("rotate",option+1) == 0)
973 {
974 i++;
975 if (i == (ssize_t) argc)
976 ThrowCompareException(OptionError,"MissingArgument",option);
977 if (IsGeometry(argv[i]) == MagickFalse)
978 ThrowCompareInvalidArgumentException(option,argv[i]);
979 break;
980 }
981 ThrowCompareException(OptionError,"UnrecognizedOption",option)
982 }
983 case 's':
984 {
985 if (LocaleCompare("sampling-factor",option+1) == 0)
986 {
987 if (*option == '+')
988 break;
989 i++;
990 if (i == (ssize_t) argc)
991 ThrowCompareException(OptionError,"MissingArgument",option);
992 if (IsGeometry(argv[i]) == MagickFalse)
993 ThrowCompareInvalidArgumentException(option,argv[i]);
994 break;
995 }
996 if (LocaleCompare("seed",option+1) == 0)
997 {
998 if (*option == '+')
999 break;
1000 i++;
1001 if (i == (ssize_t) argc)
1002 ThrowCompareException(OptionError,"MissingArgument",option);
1003 if (IsGeometry(argv[i]) == MagickFalse)
1004 ThrowCompareInvalidArgumentException(option,argv[i]);
1005 break;
1006 }
1007 if (LocaleCompare("separate",option+1) == 0)
1008 break;
1009 if (LocaleCompare("set",option+1) == 0)
1010 {
1011 i++;
1012 if (i == (ssize_t) argc)
1013 ThrowCompareException(OptionError,"MissingArgument",option);
1014 if (*option == '+')
1015 break;
1016 i++;
1017 if (i == (ssize_t) argc)
1018 ThrowCompareException(OptionError,"MissingArgument",option);
1019 break;
1020 }
1021 if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
1022 {
1023 i++;
1024 if (i == (ssize_t) argc)
1025 ThrowCompareException(OptionError,"MissingArgument",option);
1026 if (IsGeometry(argv[i]) == MagickFalse)
1027 ThrowCompareInvalidArgumentException(option,argv[i]);
1028 break;
1029 }
1030 if (LocaleCompare("similarity-threshold",option+1) == 0)
1031 {
1032 if (*option == '+')
1033 break;
1034 i++;
1035 if (i == (ssize_t) argc)
1036 ThrowCompareException(OptionError,"MissingArgument",option);
1037 if (IsGeometry(argv[i]) == MagickFalse)
1038 ThrowCompareInvalidArgumentException(option,argv[i]);
1039 if (*option == '+')
1040 similarity_threshold=DefaultSimilarityThreshold;
1041 else
1042 similarity_threshold=StringToDouble(argv[i],(char **) NULL);
1043 break;
1044 }
1045 if (LocaleCompare("size",option+1) == 0)
1046 {
1047 if (*option == '+')
1048 break;
1049 i++;
1050 if (i == (ssize_t) argc)
1051 ThrowCompareException(OptionError,"MissingArgument",option);
1052 if (IsGeometry(argv[i]) == MagickFalse)
1053 ThrowCompareInvalidArgumentException(option,argv[i]);
1054 break;
1055 }
1056 if (LocaleCompare("subimage-search",option+1) == 0)
1057 {
1058 if (*option == '+')
1059 {
1060 subimage_search=MagickFalse;
1061 break;
1062 }
1063 subimage_search=MagickTrue;
1064 break;
1065 }
1066 if (LocaleCompare("synchronize",option+1) == 0)
1067 break;
1068 ThrowCompareException(OptionError,"UnrecognizedOption",option)
1069 }
1070 case 't':
1071 {
1072 if (LocaleCompare("taint",option+1) == 0)
1073 break;
1074 if (LocaleCompare("transparent-color",option+1) == 0)
1075 {
1076 if (*option == '+')
1077 break;
1078 i++;
1079 if (i == (ssize_t) argc)
1080 ThrowCompareException(OptionError,"MissingArgument",option);
1081 break;
1082 }
1083 if (LocaleCompare("trim",option+1) == 0)
1084 break;
1085 if (LocaleCompare("type",option+1) == 0)
1086 {
1087 ssize_t
1088 type;
1089
1090 if (*option == '+')
1091 break;
1092 i++;
1093 if (i == (ssize_t) argc)
1094 ThrowCompareException(OptionError,"MissingArgument",option);
1095 type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
1096 if (type < 0)
1097 ThrowCompareException(OptionError,"UnrecognizedImageType",
1098 argv[i]);
1099 break;
1100 }
1101 ThrowCompareException(OptionError,"UnrecognizedOption",option)
1102 }
1103 case 'v':
1104 {
1105 if (LocaleCompare("verbose",option+1) == 0)
1106 break;
1107 if ((LocaleCompare("version",option+1) == 0) ||
1108 (LocaleCompare("-version",option+1) == 0))
1109 {
1110 ListMagickVersion(stdout);
1111 break;
1112 }
1113 if (LocaleCompare("virtual-pixel",option+1) == 0)
1114 {
1115 ssize_t
1116 method;
1117
1118 if (*option == '+')
1119 break;
1120 i++;
1121 if (i == (ssize_t) argc)
1122 ThrowCompareException(OptionError,"MissingArgument",option);
1123 method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
1124 argv[i]);
1125 if (method < 0)
1126 ThrowCompareException(OptionError,
1127 "UnrecognizedVirtualPixelMethod",argv[i]);
1128 break;
1129 }
1130 ThrowCompareException(OptionError,"UnrecognizedOption",option)
1131 }
1132 case 'w':
1133 {
1134 if (LocaleCompare("write",option+1) == 0)
1135 {
1136 i++;
1137 if (i == (ssize_t) argc)
1138 ThrowCompareException(OptionError,"MissingArgument",option);
1139 break;
1140 }
1141 if (LocaleCompare("write-mask",option+1) == 0)
1142 {
1143 if (*option == '+')
1144 break;
1145 i++;
1146 if (i == (ssize_t) argc)
1147 ThrowCompareException(OptionError,"MissingArgument",option);
1148 break;
1149 }
1150 ThrowCompareException(OptionError,"UnrecognizedOption",option)
1151 }
1152 case '?':
1153 break;
1154 default:
1155 ThrowCompareException(OptionError,"UnrecognizedOption",option)
1156 }
1157 fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &
1158 FireOptionFlag) == 0 ? MagickFalse : MagickTrue;
1159 if (fire != MagickFalse)
1160 FireImageStack(MagickTrue,MagickTrue,MagickTrue);
1161 }
1162 if (k != 0)
1163 ThrowCompareException(OptionError,"UnbalancedParenthesis",argv[i]);
1164 if (i-- != ((ssize_t) argc-1))
1165 ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
1166 if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
1167 ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
1168 FinalizeImageSettings(image_info,image,MagickTrue);
1169 if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))
1170 ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);
1171 image=GetImageFromList(image,0);
1172 reconstruct_image=GetImageFromList(image,1);
1173 offset.x=0;
1174 offset.y=0;
1175 if (subimage_search != MagickFalse)
1176 {
1177 similarity_image=SimilarityImage(image,reconstruct_image,metric,
1178 similarity_threshold,&offset,&similarity_metric,exception);
1179 if (similarity_image == (Image *) NULL)
1180 return(MagickFalse);
1181 if (similarity_metric >= dissimilarity_threshold)
1182 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
1183 "ImagesTooDissimilar","`%s'",image->filename);
1184 }
1185 if (similarity_image == (Image *) NULL)
1186 difference_image=CompareImages(image,reconstruct_image,metric,&distortion,
1187 exception);
1188 else
1189 {
1190 Image
1191 *composite_image;
1192
1193 /*
1194 Determine if reconstructed image is a subimage of the image.
1195 */
1196 composite_image=CloneImage(image,0,0,MagickTrue,exception);
1197 if (composite_image == (Image *) NULL)
1198 difference_image=CompareImages(image,reconstruct_image,metric,
1199 &distortion,exception);
1200 else
1201 {
1202 Image
1203 *distort_image;
1204
1205 RectangleInfo
1206 page;
1207
1208 (void) CompositeImage(composite_image,reconstruct_image,
1209 CopyCompositeOp,MagickTrue,offset.x,offset.y,exception);
1210 difference_image=CompareImages(image,composite_image,metric,
1211 &distortion,exception);
1212 if (difference_image != (Image *) NULL)
1213 {
1214 difference_image->page.x=offset.x;
1215 difference_image->page.y=offset.y;
1216 }
1217 composite_image=DestroyImage(composite_image);
1218 page.width=reconstruct_image->columns;
1219 page.height=reconstruct_image->rows;
1220 page.x=offset.x;
1221 page.y=offset.y;
1222 distort_image=CropImage(image,&page,exception);
1223 if (distort_image != (Image *) NULL)
1224 {
1225 Image
1226 *sans_image;
1227
1228 (void) SetImageArtifact(distort_image,"compare:virtual-pixels",
1229 "false");
1230 sans_image=CompareImages(distort_image,reconstruct_image,metric,
1231 &distortion,exception);
1232 if (sans_image != (Image *) NULL)
1233 sans_image=DestroyImage(sans_image);
1234 distort_image=DestroyImage(distort_image);
1235 }
1236 }
1237 if (difference_image != (Image *) NULL)
1238 {
1239 AppendImageToList(&difference_image,similarity_image);
1240 similarity_image=(Image *) NULL;
1241 }
1242 }
1243 switch (metric)
1244 {
1245 case AbsoluteErrorMetric:
1246 case PixelDifferenceCountErrorMetric:
1247 {
1248 size_t
1249 columns,
1250 rows;
1251
1252 SetImageCompareBounds(image,reconstruct_image,&columns,&rows);
1253 scale=(double) columns*rows;
1254 break;
1255 }
1256 case DotProductCorrelationErrorMetric:
1257 case PhaseCorrelationErrorMetric:
1258 case NormalizedCrossCorrelationErrorMetric:
1259 {
1260 double
1261 maxima = 0.0,
1262 minima = 0.0;
1263
1264 (void) GetImageRange(reconstruct_image,&minima,&maxima,exception);
1265 if (fabs(maxima-minima) < MagickEpsilon)
1266 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
1267 CompareConstantColorException,"(%s)",CommandOptionToMnemonic(
1268 MagickMetricOptions,(ssize_t) metric));
1269 break;
1270 }
1271 case PeakAbsoluteErrorMetric:
1272 {
1273 if ((subimage_search != MagickFalse) &&
1274 (image->columns == reconstruct_image->columns) &&
1275 (image->rows == reconstruct_image->rows))
1276 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
1277 CompareEqualSizedException,"(%s)",CommandOptionToMnemonic(
1278 MagickMetricOptions,(ssize_t) metric));
1279 break;
1280 }
1281 case PerceptualHashErrorMetric:
1282 {
1283 if (subimage_search == MagickFalse)
1284 {
1285 double
1286 maxima = 0.0,
1287 minima = 0.0;
1288
1289 (void) GetImageRange(reconstruct_image,&minima,&maxima,exception);
1290 if (fabs(maxima-minima) < MagickEpsilon)
1291 (void) ThrowMagickException(exception,GetMagickModule(),
1292 ImageWarning,CompareConstantColorException,"(%s)",
1293 CommandOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
1294 }
1295 if ((subimage_search != MagickFalse) &&
1296 (image->columns == reconstruct_image->columns) &&
1297 (image->rows == reconstruct_image->rows))
1298 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
1299 CompareEqualSizedException,"(%s)",CommandOptionToMnemonic(
1300 MagickMetricOptions,(ssize_t) metric));
1301 break;
1302 }
1303 case PeakSignalToNoiseRatioErrorMetric:
1304 {
1305 scale=MagickSafePSNRRecipicol(10.0);
1306 break;
1307 }
1308 default:
1309 break;
1310 }
1311 if (fabs(distortion) > CompareEpsilon)
1312 similar=MagickFalse;
1313 if (difference_image == (Image *) NULL)
1314 status=0;
1315 else
1316 {
1317 if (image_info->verbose != MagickFalse)
1318 (void) SetImageColorMetric(image,reconstruct_image,exception);
1319 if (*difference_image->magick == '\0')
1320 (void) CopyMagickString(difference_image->magick,image->magick,
1321 MagickPathExtent);
1322 if (image_info->verbose == MagickFalse)
1323 {
1324 switch (metric)
1325 {
1326 case AbsoluteErrorMetric:
1327 case PixelDifferenceCountErrorMetric:
1328 {
1329 (void) FormatLocaleFile(stderr,"%.*g (%.*g)",GetMagickPrecision(),
1330 (scale*distortion),GetMagickPrecision(),distortion);
1331 break;
1332 }
1333 case MeanErrorPerPixelErrorMetric:
1334 {
1335 if (subimage_search == MagickFalse)
1336 {
1337 (void) FormatLocaleFile(stderr,"%.*g (%.*g, %.*g)",
1338 GetMagickPrecision(),scale*distortion,
1339 GetMagickPrecision(),distortion,GetMagickPrecision(),
1340 image->error.normalized_maximum_error);
1341 break;
1342 }
1343 magick_fallthrough;
1344 }
1345 default:
1346 {
1347 (void) FormatLocaleFile(stderr,"%.*g (%.*g)",GetMagickPrecision(),
1348 scale*distortion,GetMagickPrecision(),distortion);
1349 break;
1350 }
1351 }
1352 if (subimage_search != MagickFalse)
1353 (void) FormatLocaleFile(stderr," @ %.20g,%.20g [%.*g]",
1354 (double) offset.x,(double) offset.y,GetMagickPrecision(),
1355 similarity_metric);
1356 }
1357 else
1358 {
1359 double
1360 *channel_distortion;
1361
1362 channel_distortion=GetImageDistortions(image,reconstruct_image,
1363 metric,exception);
1364 (void) FormatLocaleFile(stderr,"Image: %s\n",image->filename);
1365 if ((reconstruct_image->columns != image->columns) ||
1366 (reconstruct_image->rows != image->rows))
1367 (void) FormatLocaleFile(stderr,"Offset: %.20g,%.20g\n",(double)
1368 difference_image->page.x,(double) difference_image->page.y);
1369 (void) FormatLocaleFile(stderr," Channel distortion: %s\n",
1370 CommandOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
1371 switch (metric)
1372 {
1373 case FuzzErrorMetric:
1374 case MeanAbsoluteErrorMetric:
1375 case MeanSquaredErrorMetric:
1376 case PeakAbsoluteErrorMetric:
1377 case RootMeanSquaredErrorMetric:
1378 {
1379 switch (image->colorspace)
1380 {
1381 case RGBColorspace:
1382 default:
1383 {
1384 (void) FormatLocaleFile(stderr," red: %.*g (%.*g)\n",
1385 GetMagickPrecision(),scale*
1386 channel_distortion[RedPixelChannel],GetMagickPrecision(),
1387 channel_distortion[RedPixelChannel]);
1388 (void) FormatLocaleFile(stderr," green: %.*g (%.*g)\n",
1389 GetMagickPrecision(),scale*
1390 channel_distortion[GreenPixelChannel],GetMagickPrecision(),
1391 channel_distortion[GreenPixelChannel]);
1392 (void) FormatLocaleFile(stderr," blue: %.*g (%.*g)\n",
1393 GetMagickPrecision(),scale*
1394 channel_distortion[BluePixelChannel],GetMagickPrecision(),
1395 channel_distortion[BluePixelChannel]);
1396 if (image->alpha_trait != UndefinedPixelTrait)
1397 (void) FormatLocaleFile(stderr," alpha: %.*g (%.*g)\n",
1398 GetMagickPrecision(),scale*
1399 channel_distortion[AlphaPixelChannel],
1400 GetMagickPrecision(),
1401 channel_distortion[AlphaPixelChannel]);
1402 break;
1403 }
1404 case CMYKColorspace:
1405 {
1406 (void) FormatLocaleFile(stderr," cyan: %.*g (%.*g)\n",
1407 GetMagickPrecision(),scale*
1408 channel_distortion[CyanPixelChannel],GetMagickPrecision(),
1409 channel_distortion[CyanPixelChannel]);
1410 (void) FormatLocaleFile(stderr," magenta: %.*g (%.*g)\n",
1411 GetMagickPrecision(),scale*
1412 channel_distortion[MagentaPixelChannel],
1413 GetMagickPrecision(),
1414 channel_distortion[MagentaPixelChannel]);
1415 (void) FormatLocaleFile(stderr," yellow: %.*g (%.*g)\n",
1416 GetMagickPrecision(),scale*
1417 channel_distortion[YellowPixelChannel],GetMagickPrecision(),
1418 channel_distortion[YellowPixelChannel]);
1419 (void) FormatLocaleFile(stderr," black: %.*g (%.*g)\n",
1420 GetMagickPrecision(),scale*
1421 channel_distortion[BlackPixelChannel],GetMagickPrecision(),
1422 channel_distortion[BlackPixelChannel]);
1423 if (image->alpha_trait != UndefinedPixelTrait)
1424 (void) FormatLocaleFile(stderr," alpha: %.*g (%.*g)\n",
1425 GetMagickPrecision(),scale*
1426 channel_distortion[AlphaPixelChannel],
1427 GetMagickPrecision(),
1428 channel_distortion[AlphaPixelChannel]);
1429 break;
1430 }
1431 case LinearGRAYColorspace:
1432 case GRAYColorspace:
1433 {
1434 (void) FormatLocaleFile(stderr," gray: %.*g (%.*g)\n",
1435 GetMagickPrecision(),scale*
1436 channel_distortion[GrayPixelChannel],GetMagickPrecision(),
1437 channel_distortion[GrayPixelChannel]);
1438 if (image->alpha_trait != UndefinedPixelTrait)
1439 (void) FormatLocaleFile(stderr," alpha: %.*g (%.*g)\n",
1440 GetMagickPrecision(),scale*
1441 channel_distortion[AlphaPixelChannel],
1442 GetMagickPrecision(),
1443 channel_distortion[AlphaPixelChannel]);
1444 break;
1445 }
1446 }
1447 (void) FormatLocaleFile(stderr," all: %.*g (%.*g)\n",
1448 GetMagickPrecision(),scale*channel_distortion[MaxPixelChannels],
1449 GetMagickPrecision(),channel_distortion[MaxPixelChannels]);
1450 break;
1451 }
1452 case AbsoluteErrorMetric:
1453 case DotProductCorrelationErrorMetric:
1454 case NormalizedCrossCorrelationErrorMetric:
1455 case PeakSignalToNoiseRatioErrorMetric:
1456 case PerceptualHashErrorMetric:
1457 case PhaseCorrelationErrorMetric:
1458 case StructuralSimilarityErrorMetric:
1459 case StructuralDissimilarityErrorMetric:
1460 {
1461 switch (image->colorspace)
1462 {
1463 case RGBColorspace:
1464 default:
1465 {
1466 (void) FormatLocaleFile(stderr," red: %.*g\n",
1467 GetMagickPrecision(),channel_distortion[RedPixelChannel]);
1468 (void) FormatLocaleFile(stderr," green: %.*g\n",
1469 GetMagickPrecision(),channel_distortion[GreenPixelChannel]);
1470 (void) FormatLocaleFile(stderr," blue: %.*g\n",
1471 GetMagickPrecision(),channel_distortion[BluePixelChannel]);
1472 if (image->alpha_trait != UndefinedPixelTrait)
1473 (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1474 GetMagickPrecision(),
1475 channel_distortion[AlphaPixelChannel]);
1476 break;
1477 }
1478 case CMYKColorspace:
1479 {
1480 (void) FormatLocaleFile(stderr," cyan: %.*g\n",
1481 GetMagickPrecision(),channel_distortion[CyanPixelChannel]);
1482 (void) FormatLocaleFile(stderr," magenta: %.*g\n",
1483 GetMagickPrecision(),
1484 channel_distortion[MagentaPixelChannel]);
1485 (void) FormatLocaleFile(stderr," yellow: %.*g\n",
1486 GetMagickPrecision(),
1487 channel_distortion[YellowPixelChannel]);
1488 (void) FormatLocaleFile(stderr," black: %.*g\n",
1489 GetMagickPrecision(),
1490 channel_distortion[BlackPixelChannel]);
1491 if (image->alpha_trait != UndefinedPixelTrait)
1492 (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1493 GetMagickPrecision(),
1494 channel_distortion[AlphaPixelChannel]);
1495 break;
1496 }
1497 case LinearGRAYColorspace:
1498 case GRAYColorspace:
1499 {
1500 (void) FormatLocaleFile(stderr," gray: %.*g\n",
1501 GetMagickPrecision(),channel_distortion[GrayPixelChannel]);
1502 if (image->alpha_trait != UndefinedPixelTrait)
1503 (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1504 GetMagickPrecision(),
1505 channel_distortion[AlphaPixelChannel]);
1506 break;
1507 }
1508 }
1509 (void) FormatLocaleFile(stderr," all: %.*g\n",
1510 GetMagickPrecision(),channel_distortion[MaxPixelChannels]);
1511 break;
1512 }
1513 case MeanErrorPerPixelErrorMetric:
1514 {
1515 (void) FormatLocaleFile(stderr," %.*g (%.*g, %.*g)\n",
1516 GetMagickPrecision(),channel_distortion[MaxPixelChannels],
1517 GetMagickPrecision(),channel_distortion[MaxPixelChannels],
1518 GetMagickPrecision(),image->error.normalized_maximum_error);
1519 break;
1520 }
1521 case PixelDifferenceCountErrorMetric:
1522 {
1523 switch (image->colorspace)
1524 {
1525 case RGBColorspace:
1526 default:
1527 {
1528 (void) FormatLocaleFile(stderr," red: %.*g\n",
1529 GetMagickPrecision(),scale*
1530 channel_distortion[RedPixelChannel]);
1531 (void) FormatLocaleFile(stderr," green: %.*g\n",
1532 GetMagickPrecision(),scale*
1533 channel_distortion[GreenPixelChannel]);
1534 (void) FormatLocaleFile(stderr," blue: %.*g\n",
1535 GetMagickPrecision(),scale*
1536 channel_distortion[BluePixelChannel]);
1537 if (image->alpha_trait != UndefinedPixelTrait)
1538 (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1539 GetMagickPrecision(),scale*
1540 channel_distortion[AlphaPixelChannel]);
1541 break;
1542 }
1543 case CMYKColorspace:
1544 {
1545 (void) FormatLocaleFile(stderr," cyan: %.*g\n",
1546 GetMagickPrecision(),channel_distortion[CyanPixelChannel]);
1547 (void) FormatLocaleFile(stderr," magenta: %.*g\n",
1548 GetMagickPrecision(),scale*
1549 channel_distortion[MagentaPixelChannel]);
1550 (void) FormatLocaleFile(stderr," yellow: %.*g\n",
1551 GetMagickPrecision(),scale*
1552 channel_distortion[YellowPixelChannel]);
1553 (void) FormatLocaleFile(stderr," black: %.*g\n",
1554 GetMagickPrecision(),scale*
1555 channel_distortion[BlackPixelChannel]);
1556 if (image->alpha_trait != UndefinedPixelTrait)
1557 (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1558 GetMagickPrecision(),scale*
1559 channel_distortion[AlphaPixelChannel]);
1560 break;
1561 }
1562 case LinearGRAYColorspace:
1563 case GRAYColorspace:
1564 {
1565 (void) FormatLocaleFile(stderr," gray: %.*g\n",
1566 GetMagickPrecision(),scale*
1567 channel_distortion[GrayPixelChannel]);
1568 if (image->alpha_trait != UndefinedPixelTrait)
1569 (void) FormatLocaleFile(stderr," alpha: %.*g\n",
1570 GetMagickPrecision(),scale*
1571 channel_distortion[AlphaPixelChannel]);
1572 break;
1573 }
1574 }
1575 (void) FormatLocaleFile(stderr," all: %.*g\n",
1576 GetMagickPrecision(),scale*
1577 channel_distortion[MaxPixelChannels]);
1578 break;
1579 }
1580 case UndefinedErrorMetric:
1581 break;
1582 }
1583 channel_distortion=(double *) RelinquishMagickMemory(
1584 channel_distortion);
1585 if (subimage_search != MagickFalse)
1586 {
1587 (void) FormatLocaleFile(stderr," Offset: %.20g,%.20g\n",
1588 (double) difference_image->page.x,(double)
1589 difference_image->page.y);
1590 (void) FormatLocaleFile(stderr," Similarity metric: %*g\n",
1591 GetMagickPrecision(),similarity_metric);
1592 (void) FormatLocaleFile(stderr," Similarity threshold: %*g\n",
1593 GetMagickPrecision(),similarity_threshold);
1594 (void) FormatLocaleFile(stderr,
1595 " Dissimilarity threshold: %*g\n",GetMagickPrecision(),
1596 dissimilarity_threshold);
1597 }
1598 }
1599 (void) ResetImagePage(difference_image,"0x0+0+0");
1600 if (difference_image->next != (Image *) NULL)
1601 (void) ResetImagePage(difference_image->next,"0x0+0+0");
1602 status&=(MagickStatusType) WriteImages(image_info,difference_image,
1603 argv[argc-1],exception);
1604 if ((metadata != (char **) NULL) && (format != (char *) NULL))
1605 {
1606 char
1607 *text;
1608
1609 text=InterpretImageProperties(image_info,difference_image,format,
1610 exception);
1611 if (text == (char *) NULL)
1612 ThrowCompareException(ResourceLimitError,"MemoryAllocationFailed",
1613 GetExceptionMessage(errno));
1614 (void) ConcatenateString(&(*metadata),text);
1615 text=DestroyString(text);
1616 }
1617 difference_image=DestroyImageList(difference_image);
1618 }
1619 DestroyCompare();
1620 if (similar == MagickFalse)
1621 (void) SetImageOption(image_info,"compare:dissimilar","true");
1622 return(status != 0 ? MagickTrue : MagickFalse);
1623}