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