�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2F'>ImageMagick-7.1.2-30</a>/<a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2FMagickWand%2F'>MagickWand</a>/</p><hr><h3>✏️ Editing: compare.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%               CCCC   OOO   M   M  PPPP    AAA   RRRR    EEEEE               %
%              C      O   O  MM MM  P   P  A   A  R   R   E                   %
%              C      O   O  M M M  PPPP   AAAAA  RRRR    EEE                 %
%              C      O   O  M   M  P      A   A  R R     E                   %
%               CCCC   OOO   M   M  P      A   A  R  R    EEEEE               %
%                                                                             %
%                                                                             %
%                         Image Comparison Methods                            %
%                                                                             %
%                              Software Design                                %
%                                   Cristy                                    %
%                               December 2003                                 %
%                                                                             %
%                                                                             %
%  Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization         %
%  dedicated to making software imaging solutions freely available.           %
%                                                                             %
%  You may not use this file except in compliance with the License.  You may  %
%  obtain a copy of the License at                                            %
%                                                                             %
%    https://imagemagick.org/license/                                         %
%                                                                             %
%  Unless required by applicable law or agreed to in writing, software        %
%  distributed under the License is distributed on an &quot;AS IS&quot; BASIS,          %
%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
%  See the License for the specific language governing permissions and        %
%  limitations under the License.                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  Use the compare program to mathematically and visually annotate the
%  difference between an image and its reconstruction.
%
*/

/*
  Include declarations.
*/
#include &quot;MagickWand/studio.h&quot;
#include &quot;MagickWand/MagickWand.h&quot;
#include &quot;MagickWand/mogrify-private.h&quot;
#include &quot;MagickCore/compare-private.h&quot;
#include &quot;MagickCore/image-private.h&quot;
#include &quot;MagickCore/string-private.h&quot;

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   C o m p a r e I m a g e C o m m a n d                                     %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  CompareImagesCommand() compares two images and returns the difference between
%  them as a distortion metric and as a new image visually annotating their
%  differences.
%
%  The format of the CompareImagesCommand method is:
%
%      MagickBooleanType CompareImagesCommand(ImageInfo *image_info,int argc,
%        char **argv,char **metadata,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o argc: the number of elements in the argument vector.
%
%    o argv: A text array containing the command line arguments.
%
%    o metadata: any metadata is returned here.
%
%    o exception: return any errors or warnings in this structure.
%
*/

static MagickBooleanType CompareUsage(void)
{
  static const char
    channel_operators[] =
      &quot;  -separate            separate an image channel into a grayscale image&quot;,
    miscellaneous[] =
      &quot;  -channel mask        set the image channel mask\n&quot;
      &quot;  -debug events        display copious debugging information\n&quot;
      &quot;  -help                print program options\n&quot;
      &quot;  -list type           print a list of supported option arguments\n&quot;
      &quot;  -log format          format of debugging information&quot;,
    operators[] =
      &quot;  -auto-orient         automagically orient (rotate) image\n&quot;
      &quot;  -brightness-contrast geometry\n&quot;
      &quot;                       improve brightness / contrast of the image\n&quot;
      &quot;  -distort method args\n&quot;
      &quot;                       distort images according to given method and args\n&quot;
      &quot;  -level value         adjust the level of image contrast\n&quot;
      &quot;  -resize geometry     resize the image\n&quot;
      &quot;  -rotate degrees      apply Paeth rotation to the image\n&quot;
      &quot;  -sigmoidal-contrast geometry\n&quot;
      &quot;                       increase the contrast without saturating highlights or\n&quot;
      &quot;  -trim                trim image edges\n&quot;
      &quot;  -write filename      write images to this file&quot;,
    sequence_operators[] =
      &quot;  -crop geometry       cut out a rectangular region of the image&quot;,
    settings[] =
      &quot;  -adjoin              join images into a single multi-image file\n&quot;
      &quot;  -alpha option        on, activate, off, deactivate, set, opaque, copy\n&quot;
      &quot;                       transparent, extract, background, or shape\n&quot;
      &quot;  -authenticate password\n&quot;
      &quot;                       decipher image with this password\n&quot;
      &quot;  -background color    background color\n&quot;
      &quot;  -colorspace type     alternate image colorspace\n&quot;
      &quot;  -compose operator    set image composite operator\n&quot;
      &quot;  -compress type       type of pixel compression when writing the image\n&quot;
      &quot;  -decipher filename   convert cipher pixels to plain pixels\n&quot;
      &quot;  -define format:option\n&quot;
      &quot;                       define one or more image format options\n&quot;
      &quot;  -density geometry    horizontal and vertical density of the image\n&quot;
      &quot;  -depth value         image depth\n&quot;
      &quot;  -dissimilarity-threshold value\n&quot;
      &quot;                       maximum distortion for (sub)image match\n&quot;
      &quot;  -encipher filename   convert plain pixels to cipher pixels\n&quot;
      &quot;  -extract geometry    extract area from image\n&quot;
      &quot;  -format \&quot;string\&quot;     output formatted image characteristics\n&quot;
      &quot;  -fuzz distance       colors within this distance are considered equal\n&quot;
      &quot;  -gravity type        horizontal and vertical text placement\n&quot;
      &quot;  -highlight-color color\n&quot;
      &quot;                       emphasize pixel differences with this color\n&quot;
      &quot;  -identify            identify the format and characteristics of the image\n&quot;
      &quot;  -interlace type      type of image interlacing scheme\n&quot;
      &quot;  -limit type value    pixel cache resource limit\n&quot;
      &quot;  -lowlight-color color\n&quot;
      &quot;                       de-emphasize pixel differences with this color\n&quot;
      &quot;  -metric type         measure differences between images with this metric\n&quot;
      &quot;  -monitor             monitor progress\n&quot;
      &quot;  -negate              replace every pixel with its complementary color \n&quot;
      &quot;  -passphrase filename get the passphrase from this file\n&quot;
      &quot;  -precision value     maximum number of significant digits to print\n&quot;
      &quot;  -profile filename    add, delete, or apply an image profile\n&quot;
      &quot;  -quality value       JPEG/MIFF/PNG compression level\n&quot;
      &quot;  -quiet               suppress all warning messages\n&quot;
      &quot;  -quantize colorspace reduce colors in this colorspace\n&quot;
      &quot;  -read-mask filename  associate a read mask with the image\n&quot;
      &quot;  -regard-warnings     pay attention to warning messages\n&quot;
      &quot;  -respect-parentheses settings remain in effect until parenthesis boundary\n&quot;
      &quot;  -sampling-factor geometry\n&quot;
      &quot;                       horizontal and vertical sampling factor\n&quot;
      &quot;  -seed value          seed a new sequence of pseudo-random numbers\n&quot;
      &quot;  -set attribute value set an image attribute\n&quot;
      &quot;  -quality value       JPEG/MIFF/PNG compression level\n&quot;
      &quot;  -repage geometry     size and location of an image canvas\n&quot;
      &quot;  -similarity-threshold value\n&quot;
      &quot;                       minimum distortion for (sub)image match\n&quot;
      &quot;  -size geometry       width and height of image\n&quot;
      &quot;  -subimage-search     search for subimage\n&quot;
      &quot;  -synchronize         synchronize image to storage device\n&quot;
      &quot;  -taint               declare the image as modified\n&quot;
      &quot;  -transparent-color color\n&quot;
      &quot;                       transparent color\n&quot;
      &quot;  -type type           image type\n&quot;
      &quot;  -verbose             print detailed information about the image\n&quot;
      &quot;  -version             print version information\n&quot;
      &quot;  -virtual-pixel method\n&quot;
      &quot;                       virtual pixel access method\n&quot;
      &quot;  -write-mask filename  associate a write mask with the image&quot;,
    stack_operators[] =
      &quot;  -delete indexes      delete the image from the image sequence&quot;;

  ListMagickVersion(stdout);
  (void) printf(&quot;Usage: %s [options ...] image reconstruct difference\n&quot;,
    GetClientName());
  (void) printf(&quot;\nImage Settings:\n&quot;);
  (void) puts(settings);
  (void) printf(&quot;\nImage Operators:\n&quot;);
  (void) puts(operators);
  (void) printf(&quot;\nImage Channel Operators:\n&quot;);
  (void) puts(channel_operators);
  (void) printf(&quot;\nImage Sequence Operators:\n&quot;);
  (void) puts(sequence_operators);
  (void) printf(&quot;\nImage Stack Operators:\n&quot;);
  (void) puts(stack_operators);
  (void) printf(&quot;\nMiscellaneous Options:\n&quot;);
  (void) puts(miscellaneous);
  (void) printf(
    &quot;\nBy default, the image format of &#039;file&#039; is determined by its magic\n&quot;);
  (void) printf(
    &quot;number.  To specify a particular image format, precede the filename\n&quot;);
  (void) printf(
    &quot;with an image format name and a colon (i.e. ps:image) or specify the\n&quot;);
  (void) printf(
    &quot;image type as the filename suffix (i.e. image.ps).  Specify &#039;file&#039; as\n&quot;);
  (void) printf(&quot;&#039;-&#039; for standard input or output.\n&quot;);
  return(MagickTrue);
}

WandExport MagickBooleanType CompareImagesCommand(ImageInfo *image_info,
  int argc,char **argv,char **metadata,ExceptionInfo *exception)
{
#define CompareEpsilon  (1.0e-06)
#define CompareConstantColorException \
  &quot;search metric is unreliable for constant-color images&quot;
#define CompareEqualSizedException \
  &quot;subimage search metric is unreliable for equal-sized images&quot;
#define DefaultDissimilarityThreshold  (1.0/MagickPI)
#define DestroyCompare() \
{ \
  if (similarity_image != (Image *) NULL) \
    similarity_image=DestroyImageList(similarity_image); \
  if (difference_image != (Image *) NULL) \
    difference_image=DestroyImageList(difference_image); \
  DestroyImageStack(); \
  for (i=0; i &lt; (ssize_t) argc; i++) \
    argv[i]=DestroyString(argv[i]); \
  argv=(char **) RelinquishMagickMemory(argv); \
}
#define ThrowCompareException(asperity,tag,option) \
{ \
  char *message = GetExceptionMessage(errno);     \
  (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag, \
    &quot;`%s&#039;&quot;,option == (char *) NULL ? message : option); \
  message=DestroyString(message); \
  DestroyCompare(); \
  return(MagickFalse); \
}
#define ThrowCompareInvalidArgumentException(option,argument) \
{ \
  (void) ThrowMagickException(exception,GetMagickModule(),OptionError, \
    &quot;InvalidArgument&quot;,&quot;&#039;%s&#039;: %s&quot;,option,argument); \
  DestroyCompare(); \
  return(MagickFalse); \
}

  char
    *filename,
    *option;

  const char
    *format;

  double
    dissimilarity_threshold = DefaultDissimilarityThreshold,
    distortion = 0.0,
    normal_scale = 1.0,
    scale = (double) QuantumRange,
    similarity_metric = 0.0,
    similarity_threshold = DefaultSimilarityThreshold;

  Image
    *difference_image,
    *image = (Image *) NULL,
    *reconstruct_image,
    *similarity_image;

  ImageStack
    image_stack[MaxImageStackDepth+1];

  MagickBooleanType
    fire,
    pend,
    respect_parentheses,
    similar = MagickTrue,
    subimage_search;

  MagickStatusType
    status;

  MetricType
    metric = UndefinedErrorMetric;

  RectangleInfo
    offset;

  ssize_t
    i;

  ssize_t
    j,
    k;

  /*
    Set defaults.
  */
  assert(image_info != (ImageInfo *) NULL);
  assert(image_info-&gt;signature == MagickCoreSignature);
  assert(exception != (ExceptionInfo *) NULL);
  if (IsEventLogging() != MagickFalse)
    (void) LogMagickEvent(TraceEvent,GetMagickModule(),&quot;...&quot;);
  if (argc == 2)
    {
      option=argv[1];
      if ((LocaleCompare(&quot;version&quot;,option+1) == 0) ||
          (LocaleCompare(&quot;-version&quot;,option+1) == 0))
        {
          ListMagickVersion(stdout);
          return(MagickTrue);
        }
    }
  if (argc &lt; 3)
    {
      (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
        &quot;MissingArgument&quot;,&quot;%s&quot;,&quot;&quot;);
      (void) CompareUsage();
      return(MagickFalse);
    }
  difference_image=NewImageList();
  similarity_image=NewImageList();
  format=(char *) NULL;
  j=1;
  k=0;
  NewImageStack();
  option=(char *) NULL;
  pend=MagickFalse;
  reconstruct_image=NewImageList();
  respect_parentheses=MagickFalse;
  status=MagickTrue;
  subimage_search=MagickFalse;
  /*
    Compare an image.
  */
  ReadCommandlLine(argc,&amp;argv);
  status=ExpandFilenames(&amp;argc,&amp;argv);
  if (status == MagickFalse)
    ThrowCompareException(ResourceLimitError,&quot;MemoryAllocationFailed&quot;,
      (char *) NULL);
  for (i=1; i &lt; ((ssize_t) argc-1); i++)
  {
    option=argv[i];
    if (LocaleCompare(option,&quot;(&quot;) == 0)
      {
        FireImageStack(MagickTrue,MagickTrue,pend);
        if (k == MaxImageStackDepth)
          ThrowCompareException(OptionError,&quot;ParenthesisNestedTooDeeply&quot;,
            option);
        PushImageStack();
        continue;
      }
    if (LocaleCompare(option,&quot;)&quot;) == 0)
      {
        FireImageStack(MagickTrue,MagickTrue,MagickTrue);
        if (k == 0)
          ThrowCompareException(OptionError,&quot;UnableToParseExpression&quot;,option);
        PopImageStack();
        continue;
      }
    if (IsCommandOption(option) == MagickFalse)
      {
        Image
          *images;

        /*
          Read input image.
        */
        FireImageStack(MagickFalse,MagickFalse,pend);
        filename=argv[i];
        if ((LocaleCompare(filename,&quot;--&quot;) == 0) &amp;&amp; (i &lt; ((ssize_t) argc-1)))
          filename=argv[++i];
        images=ReadImages(image_info,filename,exception);
        status&amp;=(MagickStatusType) ((images != (Image *) NULL) &amp;&amp;
          (exception-&gt;severity &lt; ErrorException));
        if (images == (Image *) NULL)
          continue;
        AppendImageStack(images);
        continue;
      }
    pend=image != (Image *) NULL ? MagickTrue : MagickFalse;
    switch (*(option+1))
    {
      case &#039;a&#039;:
      {
        if (LocaleCompare(&quot;adjoin&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;alpha&quot;,option+1) == 0)
          {
            ssize_t
              type;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            type=ParseCommandOption(MagickAlphaChannelOptions,MagickFalse,
              argv[i]);
            if (type &lt; 0)
              ThrowCompareException(OptionError,
                &quot;UnrecognizedAlphaChannelOption&quot;,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;auto-orient&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;authenticate&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option);
      }
      case &#039;b&#039;:
      {
        if (LocaleCompare(&quot;background&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;brightness-contrast&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option);
      }
      case &#039;c&#039;:
      {
        if (LocaleCompare(&quot;cache&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;channel&quot;,option+1) == 0)
          {
            ssize_t
              channel;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            channel=ParseChannelOption(argv[i]);
            if (channel &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedChannelType&quot;,
                argv[i]);
            break;
          }
        if (LocaleCompare(&quot;colorspace&quot;,option+1) == 0)
          {
            ssize_t
              colorspace;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
              argv[i]);
            if (colorspace &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedColorspace&quot;,
                argv[i]);
            break;
          }
        if (LocaleCompare(&quot;compose&quot;,option+1) == 0)
          {
            ssize_t
              compose;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            compose=ParseCommandOption(MagickComposeOptions,MagickFalse,
              argv[i]);
            if (compose &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedComposeOperator&quot;,
                argv[i]);
            break;
          }
        if (LocaleCompare(&quot;compress&quot;,option+1) == 0)
          {
            ssize_t
              compress;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            compress=ParseCommandOption(MagickCompressOptions,MagickFalse,
              argv[i]);
            if (compress &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedImageCompression&quot;,
                argv[i]);
            break;
          }
        if (LocaleCompare(&quot;concurrent&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;crop&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;d&#039;:
      {
        if (LocaleCompare(&quot;debug&quot;,option+1) == 0)
          {
            LogEventType
              event_mask;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            event_mask=SetLogEventMask(argv[i]);
            if (event_mask == UndefinedEvents)
              ThrowCompareException(OptionError,&quot;UnrecognizedEventType&quot;,
                argv[i]);
            break;
          }
        if (LocaleCompare(&quot;decipher&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;define&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (*option == &#039;+&#039;)
              {
                const char
                  *define;

                define=GetImageOption(image_info,argv[i]);
                if (define == (const char *) NULL)
                  ThrowCompareException(OptionError,&quot;NoSuchOption&quot;,argv[i]);
                break;
              }
            break;
          }
        if (LocaleCompare(&quot;delete&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;density&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;depth&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;dissimilarity-threshold&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            if (*option == &#039;+&#039;)
              dissimilarity_threshold=DefaultDissimilarityThreshold;
            else
              dissimilarity_threshold=StringToDouble(argv[i],(char **) NULL);
            break;
          }
        if (LocaleCompare(&quot;distort&quot;,option+1) == 0)
          {
            ssize_t
              op;

            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            op=ParseCommandOption(MagickDistortOptions,MagickFalse,argv[i]);
            if (op &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedDistortMethod&quot;,
                argv[i]);
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;duration&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;e&#039;:
      {
        if (LocaleCompare(&quot;encipher&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;extract&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;f&#039;:
      {
        if (LocaleCompare(&quot;format&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            format=argv[i];
            break;
          }
        if (LocaleCompare(&quot;fuzz&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;g&#039;:
      {
        if (LocaleCompare(&quot;gravity&quot;,option+1) == 0)
          {
            ssize_t
              gravity;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,
              argv[i]);
            if (gravity &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedGravityType&quot;,
                argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;h&#039;:
      {
        if ((LocaleCompare(&quot;help&quot;,option+1) == 0) ||
            (LocaleCompare(&quot;-help&quot;,option+1) == 0))
          {
            DestroyCompare();
            return(CompareUsage());
          }
        if (LocaleCompare(&quot;highlight-color&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;i&#039;:
      {
        if (LocaleCompare(&quot;identify&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;interlace&quot;,option+1) == 0)
          {
            ssize_t
              interlace;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            interlace=ParseCommandOption(MagickInterlaceOptions,MagickFalse,
              argv[i]);
            if (interlace &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedInterlaceType&quot;,
                argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;l&#039;:
      {
        if (LocaleCompare(&quot;level&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;limit&quot;,option+1) == 0)
          {
            char
              *p;

            double
              value;

            ssize_t
              resource;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            resource=ParseCommandOption(MagickResourceOptions,MagickFalse,
              argv[i]);
            if (resource &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedResourceType&quot;,
                argv[i]);
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            value=StringToDouble(argv[i],&amp;p);
            (void) value;
            if ((p == argv[i]) &amp;&amp; (LocaleCompare(&quot;unlimited&quot;,argv[i]) != 0))
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;list&quot;,option+1) == 0)
          {
            ssize_t
              list;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            list=ParseCommandOption(MagickListOptions,MagickFalse,argv[i]);
            if (list &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedListType&quot;,argv[i]);
            status=MogrifyImageInfo(image_info,(int) (i-j+1),(const char **)
              argv+j,exception);
            DestroyCompare();
            return(status == 0 ? MagickFalse : MagickTrue);
          }
        if (LocaleCompare(&quot;log&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if ((i == (ssize_t) argc) || (strchr(argv[i],&#039;%&#039;) == (char *) NULL))
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;lowlight-color&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;m&#039;:
      {
        if (LocaleCompare(&quot;matte&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;metric&quot;,option+1) == 0)
          {
            ssize_t
              type;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            type=ParseCommandOption(MagickMetricOptions,MagickTrue,argv[i]);
            if (type &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedMetricType&quot;,
                argv[i]);
            metric=(MetricType) type;
            break;
          }
        if (LocaleCompare(&quot;monitor&quot;,option+1) == 0)
          break;
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;n&#039;:
      {
        if (LocaleCompare(&quot;negate&quot;,option+1) == 0)
          break;
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;p&#039;:
      {
        if (LocaleCompare(&quot;passphrase&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;precision&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;profile&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;q&#039;:
      {
        if (LocaleCompare(&quot;quality&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;quantize&quot;,option+1) == 0)
          {
            ssize_t
              colorspace;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            colorspace=ParseCommandOption(MagickColorspaceOptions,
              MagickFalse,argv[i]);
            if (colorspace &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedColorspace&quot;,
                argv[i]);
            break;
          }
        if (LocaleCompare(&quot;quiet&quot;,option+1) == 0)
          break;
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;r&#039;:
      {
        if (LocaleCompare(&quot;read-mask&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;regard-warnings&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;repage&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;resize&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleNCompare(&quot;respect-parentheses&quot;,option+1,17) == 0)
          {
            respect_parentheses=(*option == &#039;-&#039;) ? MagickTrue : MagickFalse;
            break;
          }
        if (LocaleCompare(&quot;rotate&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;s&#039;:
      {
        if (LocaleCompare(&quot;sampling-factor&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;seed&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;separate&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;set&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;sigmoidal-contrast&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;similarity-threshold&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            if (*option == &#039;+&#039;)
              similarity_threshold=DefaultSimilarityThreshold;
            else
              similarity_threshold=StringToDouble(argv[i],(char **) NULL);
            break;
          }
        if (LocaleCompare(&quot;size&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            if (IsGeometry(argv[i]) == MagickFalse)
              ThrowCompareInvalidArgumentException(option,argv[i]);
            break;
          }
        if (LocaleCompare(&quot;subimage-search&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              {
                subimage_search=MagickFalse;
                break;
              }
            subimage_search=MagickTrue;
            break;
          }
        if (LocaleCompare(&quot;synchronize&quot;,option+1) == 0)
          break;
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;t&#039;:
      {
        if (LocaleCompare(&quot;taint&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;transparent-color&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;trim&quot;,option+1) == 0)
          break;
        if (LocaleCompare(&quot;type&quot;,option+1) == 0)
          {
            ssize_t
              type;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            type=ParseCommandOption(MagickTypeOptions,MagickFalse,argv[i]);
            if (type &lt; 0)
              ThrowCompareException(OptionError,&quot;UnrecognizedImageType&quot;,
                argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;v&#039;:
      {
        if (LocaleCompare(&quot;verbose&quot;,option+1) == 0)
          break;
        if ((LocaleCompare(&quot;version&quot;,option+1) == 0) ||
            (LocaleCompare(&quot;-version&quot;,option+1) == 0))
          {
            ListMagickVersion(stdout);
            break;
          }
        if (LocaleCompare(&quot;virtual-pixel&quot;,option+1) == 0)
          {
            ssize_t
              method;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            method=ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,
              argv[i]);
            if (method &lt; 0)
              ThrowCompareException(OptionError,
                &quot;UnrecognizedVirtualPixelMethod&quot;,argv[i]);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;w&#039;:
      {
        if (LocaleCompare(&quot;write&quot;,option+1) == 0)
          {
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        if (LocaleCompare(&quot;write-mask&quot;,option+1) == 0)
          {
            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i == (ssize_t) argc)
              ThrowCompareException(OptionError,&quot;MissingArgument&quot;,option);
            break;
          }
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;?&#039;:
        break;
      default:
        ThrowCompareException(OptionError,&quot;UnrecognizedOption&quot;,option)
    }
    fire=(GetCommandOptionFlags(MagickCommandOptions,MagickFalse,option) &amp;
      FireOptionFlag) == 0 ?  MagickFalse : MagickTrue;
    if (fire != MagickFalse)
      FireImageStack(MagickTrue,MagickTrue,MagickTrue);
  }
  if (k != 0)
    ThrowCompareException(OptionError,&quot;UnbalancedParenthesis&quot;,argv[i]);
  if (i-- != ((ssize_t) argc-1))
    ThrowCompareException(OptionError,&quot;MissingAnImageFilename&quot;,argv[i]);
  if ((image == (Image *) NULL) || (GetImageListLength(image) &lt; 2))
    ThrowCompareException(OptionError,&quot;MissingAnImageFilename&quot;,argv[i]);
  FinalizeImageSettings(image_info,image,MagickTrue);
  if ((image == (Image *) NULL) || (GetImageListLength(image) &lt; 2))
    ThrowCompareException(OptionError,&quot;MissingAnImageFilename&quot;,argv[i]);
  image=GetImageFromList(image,0);
  reconstruct_image=GetImageFromList(image,1);
  offset.x=0;
  offset.y=0;
  if (subimage_search != MagickFalse)
    {
      similarity_image=SimilarityImage(image,reconstruct_image,metric,
        similarity_threshold,&amp;offset,&amp;similarity_metric,exception);
      if (similarity_image == (Image *) NULL)
        return(MagickFalse);
      if (similarity_metric &gt;= dissimilarity_threshold)
        (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
          &quot;ImagesTooDissimilar&quot;,&quot;`%s&#039;&quot;,image-&gt;filename);
    }
  if (similarity_image == (Image *) NULL)
    difference_image=CompareImages(image,reconstruct_image,metric,&amp;distortion,
      exception);
  else
    {
      Image
        *composite_image;

      /*
        Determine if reconstructed image is a subimage of the image.
      */
      composite_image=CloneImage(image,0,0,MagickTrue,exception);
      if (composite_image == (Image *) NULL)
        difference_image=CompareImages(image,reconstruct_image,metric,
          &amp;distortion,exception);
      else
        {
          Image
            *distort_image;

          RectangleInfo
            page;

          (void) CompositeImage(composite_image,reconstruct_image,
            CopyCompositeOp,MagickTrue,offset.x,offset.y,exception);
          difference_image=CompareImages(image,composite_image,metric,
            &amp;distortion,exception);
          if (difference_image != (Image *) NULL)
            {
              difference_image-&gt;page.x=offset.x;
              difference_image-&gt;page.y=offset.y;
            }
          composite_image=DestroyImage(composite_image);
          page.width=reconstruct_image-&gt;columns;
          page.height=reconstruct_image-&gt;rows;
          page.x=offset.x;
          page.y=offset.y;
          distort_image=CropImage(image,&amp;page,exception);
          if (distort_image != (Image *) NULL)
            {
              Image
                *sans_image;

              (void) SetImageArtifact(distort_image,&quot;compare:virtual-pixels&quot;,
                &quot;false&quot;);
              sans_image=CompareImages(distort_image,reconstruct_image,metric,
                &amp;distortion,exception);
              if (sans_image != (Image *) NULL)
                sans_image=DestroyImage(sans_image);
              distort_image=DestroyImage(distort_image);
            }
        }
      if (difference_image != (Image *) NULL)
        {
          AppendImageToList(&amp;difference_image,similarity_image);
          similarity_image=(Image *) NULL;
        }
    }
  switch (metric)
  {
    case AbsoluteErrorMetric:
    {
      size_t
        columns,
        rows;

      SetImageCompareBounds(image,reconstruct_image,&amp;columns,&amp;rows);
      scale=(double) columns*rows;
      break;
    }
    case DotProductCorrelationErrorMetric:
    case PhaseCorrelationErrorMetric:
    case NormalizedCrossCorrelationErrorMetric:
    {
      double
        maxima = 0.0,
        minima = 0.0;

      (void) GetImageRange(reconstruct_image,&amp;minima,&amp;maxima,exception);
      if (fabs(maxima-minima) &lt; MagickEpsilon)
        (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
          CompareConstantColorException,&quot;(%s)&quot;,CommandOptionToMnemonic(
          MagickMetricOptions,(ssize_t) metric));
      break;
    } 
    case PeakAbsoluteErrorMetric:
    {
      if ((subimage_search != MagickFalse) &amp;&amp;
          (image-&gt;columns == reconstruct_image-&gt;columns) &amp;&amp;
          (image-&gt;rows == reconstruct_image-&gt;rows))
        (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
          CompareEqualSizedException,&quot;(%s)&quot;,CommandOptionToMnemonic(
          MagickMetricOptions,(ssize_t) metric));
      break;
    }
    case PerceptualHashErrorMetric:
    {
      scale=1.0;
      if (subimage_search == MagickFalse)
        {
          double
            maxima = 0.0,
            minima = 0.0;

          (void) GetImageRange(reconstruct_image,&amp;minima,&amp;maxima,exception);
          if (fabs(maxima-minima) &lt; MagickEpsilon)
            (void) ThrowMagickException(exception,GetMagickModule(),
              ImageWarning,CompareConstantColorException,&quot;(%s)&quot;,
              CommandOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
        }
      if ((subimage_search != MagickFalse) &amp;&amp;
          (image-&gt;columns == reconstruct_image-&gt;columns) &amp;&amp;
          (image-&gt;rows == reconstruct_image-&gt;rows))
        (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
          CompareEqualSizedException,&quot;(%s)&quot;,CommandOptionToMnemonic(
          MagickMetricOptions,(ssize_t) metric));
      break;
    }
    case PeakSignalToNoiseRatioErrorMetric:
    {
      scale=MagickSafePSNRRecipicol(10.0);
      break;
    }
    case PixelDifferenceCountErrorMetric:
    {
      scale=1.0;
      normal_scale=1.0/(double) image-&gt;columns/(double) image-&gt;rows;
      break;
    }
    default:
      break;
  }
  if (fabs(distortion) &gt; CompareEpsilon)
    similar=MagickFalse;
  if (difference_image == (Image *) NULL)
    status=0;
  else
    {
      if (image_info-&gt;verbose != MagickFalse)
        (void) SetImageColorMetric(image,reconstruct_image,exception);
      if (*difference_image-&gt;magick == &#039;\0&#039;)
        (void) CopyMagickString(difference_image-&gt;magick,image-&gt;magick,
          MagickPathExtent);
      if (image_info-&gt;verbose == MagickFalse)
        {
          switch (metric)
          {
            case MeanErrorPerPixelErrorMetric:
            {
              if (subimage_search == MagickFalse)
                {
                  (void) FormatLocaleFile(stderr,&quot;%.*g (%.*g, %.*g)&quot;,
                    GetMagickPrecision(),scale*distortion,
                    GetMagickPrecision(),distortion,GetMagickPrecision(),
                    image-&gt;error.normalized_maximum_error);
                  break;
                }
              magick_fallthrough;
            }
            default:
            {
              (void) FormatLocaleFile(stderr,&quot;%.*g (%.*g)&quot;,GetMagickPrecision(),
                scale*distortion,GetMagickPrecision(),normal_scale*distortion);
              break;
            }
          }
          if (subimage_search != MagickFalse)
            (void) FormatLocaleFile(stderr,&quot; @ %.17g,%.17g [%.*g]&quot;,
              (double) offset.x,(double) offset.y,GetMagickPrecision(),
              similarity_metric);
        }
      else
        {
          double
            *channel_distortion;

          channel_distortion=GetImageDistortions(image,reconstruct_image,
            metric,exception);
          (void) FormatLocaleFile(stderr,&quot;Image: %s\n&quot;,image-&gt;filename);
          if ((reconstruct_image-&gt;columns != image-&gt;columns) ||
              (reconstruct_image-&gt;rows != image-&gt;rows))
            (void) FormatLocaleFile(stderr,&quot;Offset: %.17g,%.17g\n&quot;,(double)
              difference_image-&gt;page.x,(double) difference_image-&gt;page.y);
          (void) FormatLocaleFile(stderr,&quot;  Channel distortion: %s\n&quot;,
            CommandOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
          switch (metric)
          {
            case FuzzErrorMetric:
            case MeanAbsoluteErrorMetric:
            case MeanSquaredErrorMetric:
            case PeakAbsoluteErrorMetric:
            case RootMeanSquaredErrorMetric:
            {
              switch (image-&gt;colorspace)
              {
                case RGBColorspace:
                default:
                {
                  (void) FormatLocaleFile(stderr,&quot;    red: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[RedPixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[RedPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    green: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[GreenPixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[GreenPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    blue: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[BluePixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[BluePixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g (%.*g)\n&quot;,
                      GetMagickPrecision(),scale*
                      channel_distortion[AlphaPixelChannel],GetMagickPrecision(),
                      normal_scale*channel_distortion[AlphaPixelChannel]);
                  break;
                }
                case CMYKColorspace:
                {
                  (void) FormatLocaleFile(stderr,&quot;    cyan: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[CyanPixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[CyanPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    magenta: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[MagentaPixelChannel],
                    GetMagickPrecision(),
                    normal_scale*channel_distortion[MagentaPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    yellow: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[YellowPixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[YellowPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    black: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[BlackPixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[BlackPixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g (%.*g)\n&quot;,
                      GetMagickPrecision(),scale*
                      channel_distortion[AlphaPixelChannel],
                      GetMagickPrecision(),
                      normal_scale*channel_distortion[AlphaPixelChannel]);
                  break;
                }
                case LinearGRAYColorspace:
                case GRAYColorspace:
                {
                  (void) FormatLocaleFile(stderr,&quot;    gray: %.*g (%.*g)\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[GrayPixelChannel],GetMagickPrecision(),
                    normal_scale*channel_distortion[GrayPixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g (%.*g)\n&quot;,
                      GetMagickPrecision(),scale*
                      channel_distortion[AlphaPixelChannel],
                      GetMagickPrecision(),
                      normal_scale*channel_distortion[AlphaPixelChannel]);
                  break;
                }
              }
              (void) FormatLocaleFile(stderr,&quot;    all: %.*g (%.*g)\n&quot;,
                GetMagickPrecision(),scale*channel_distortion[MaxPixelChannels],
                GetMagickPrecision(),normal_scale*channel_distortion[MaxPixelChannels]);
              break;
            }
            case DotProductCorrelationErrorMetric:
            case NormalizedCrossCorrelationErrorMetric:
            case PeakSignalToNoiseRatioErrorMetric:
            case PerceptualHashErrorMetric:
            case PhaseCorrelationErrorMetric:
            case StructuralSimilarityErrorMetric:
            case StructuralDissimilarityErrorMetric:
            {
              switch (image-&gt;colorspace)
              {
                case RGBColorspace:
                default:
                {
                  (void) FormatLocaleFile(stderr,&quot;    red: %.*g\n&quot;,
                    GetMagickPrecision(),channel_distortion[RedPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    green: %.*g\n&quot;,
                    GetMagickPrecision(),channel_distortion[GreenPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    blue: %.*g\n&quot;,
                    GetMagickPrecision(),channel_distortion[BluePixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g\n&quot;,
                      GetMagickPrecision(),
                      channel_distortion[AlphaPixelChannel]);
                  break;
                }
                case CMYKColorspace:
                {
                  (void) FormatLocaleFile(stderr,&quot;    cyan: %.*g\n&quot;,
                    GetMagickPrecision(),channel_distortion[CyanPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    magenta: %.*g\n&quot;,
                    GetMagickPrecision(),
                    channel_distortion[MagentaPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    yellow: %.*g\n&quot;,
                    GetMagickPrecision(),
                    channel_distortion[YellowPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    black: %.*g\n&quot;,
                    GetMagickPrecision(),
                    channel_distortion[BlackPixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g\n&quot;,
                      GetMagickPrecision(),
                      channel_distortion[AlphaPixelChannel]);
                  break;
                }
                case LinearGRAYColorspace:
                case GRAYColorspace:
                {
                  (void) FormatLocaleFile(stderr,&quot;    gray: %.*g\n&quot;,
                    GetMagickPrecision(),channel_distortion[GrayPixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g\n&quot;,
                      GetMagickPrecision(),
                      channel_distortion[AlphaPixelChannel]);
                  break;
                }
              }
              (void) FormatLocaleFile(stderr,&quot;    all: %.*g\n&quot;,
                GetMagickPrecision(),channel_distortion[MaxPixelChannels]);
              break;
            }
            case MeanErrorPerPixelErrorMetric:
            {
              (void) FormatLocaleFile(stderr,&quot;    %.*g (%.*g, %.*g)\n&quot;,
                GetMagickPrecision(),channel_distortion[MaxPixelChannels],
                GetMagickPrecision(),channel_distortion[MaxPixelChannels],
                GetMagickPrecision(),image-&gt;error.normalized_maximum_error);
              break;
            }
            case AbsoluteErrorMetric:
            case PixelDifferenceCountErrorMetric:
            {
              switch (image-&gt;colorspace)
              {
                case RGBColorspace:
                default:
                {
                  (void) FormatLocaleFile(stderr,&quot;    red: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[RedPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    green: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[GreenPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    blue: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[BluePixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g\n&quot;,
                      GetMagickPrecision(),scale*
                      channel_distortion[AlphaPixelChannel]);
                  break;
                }
                case CMYKColorspace:
                {
                  (void) FormatLocaleFile(stderr,&quot;    cyan: %.*g\n&quot;,
                    GetMagickPrecision(),channel_distortion[CyanPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    magenta: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[MagentaPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    yellow: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[YellowPixelChannel]);
                  (void) FormatLocaleFile(stderr,&quot;    black: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[BlackPixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g\n&quot;,
                      GetMagickPrecision(),scale*
                      channel_distortion[AlphaPixelChannel]);
                  break;
                }
                case LinearGRAYColorspace:
                case GRAYColorspace:
                {
                  (void) FormatLocaleFile(stderr,&quot;    gray: %.*g\n&quot;,
                    GetMagickPrecision(),scale*
                    channel_distortion[GrayPixelChannel]);
                  if (image-&gt;alpha_trait != UndefinedPixelTrait)
                    (void) FormatLocaleFile(stderr,&quot;    alpha: %.*g\n&quot;,
                      GetMagickPrecision(),scale*
                      channel_distortion[AlphaPixelChannel]);
                  break;
                }
              }
              (void) FormatLocaleFile(stderr,&quot;    all: %.*g\n&quot;,
                GetMagickPrecision(),scale*
                channel_distortion[MaxPixelChannels]);
              break;
            }
            case UndefinedErrorMetric:
              break;
          }
          channel_distortion=(double *) RelinquishMagickMemory(
            channel_distortion);
          if (subimage_search != MagickFalse)
            {
              (void) FormatLocaleFile(stderr,&quot;   Offset: %.17g,%.17g\n&quot;,
                (double) difference_image-&gt;page.x,(double)
                difference_image-&gt;page.y);
              (void) FormatLocaleFile(stderr,&quot;   Similarity metric: %*g\n&quot;,
                GetMagickPrecision(),similarity_metric);
              (void) FormatLocaleFile(stderr,&quot;   Similarity threshold: %*g\n&quot;,
                GetMagickPrecision(),similarity_threshold);
              (void) FormatLocaleFile(stderr,
                &quot;   Dissimilarity threshold: %*g\n&quot;,GetMagickPrecision(),
                dissimilarity_threshold);
            }
        }
      (void) ResetImagePage(difference_image,&quot;0x0+0+0&quot;);
      if (difference_image-&gt;next != (Image *) NULL)
        (void) ResetImagePage(difference_image-&gt;next,&quot;0x0+0+0&quot;);
      status&amp;=(MagickStatusType) WriteImages(image_info,difference_image,
        argv[argc-1],exception);
      if ((metadata != (char **) NULL) &amp;&amp; (format != (char *) NULL))
        {
          char
            *text;

          text=InterpretImageProperties(image_info,difference_image,format,
            exception);
          if (text == (char *) NULL)
            ThrowCompareException(ResourceLimitError,&quot;MemoryAllocationFailed&quot;,
              (char *) NULL);
          (void) ConcatenateString(&amp;(*metadata),text);
          text=DestroyString(text);
        }
      difference_image=DestroyImageList(difference_image);
    }
  DestroyCompare();
  if (similar == MagickFalse)
    (void) SetImageOption(image_info,&quot;compare:dissimilar&quot;,&quot;true&quot;);
  return(status != 0 ? MagickTrue : MagickFalse);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2FMagickWand'>🔙 Back</a></p>