correct fuzz metric

Author: Cristy

magick/compare.c

@@ -443,8 +443,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
     *reconstruct_view;
 
   double
-    area,
-    fuzz;
+    area;
 
   MagickBooleanType
     status;
@@ -461,7 +460,6 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
     Compute the absolute difference in pixels between two images.
   */
   status=MagickTrue;
-  fuzz=GetFuzzyColorDistance(image,reconstruct_image);
   SetImageDistortionBounds(image,reconstruct_image,&columns,&rows);
   image_view=AcquireVirtualCacheView(image,exception);
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
@@ -516,7 +514,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
         {
           delta=Sa*(double) GetPixelRed(p)-Da*(double)
             GetPixelRed(q);
-          if ((delta*delta) > fuzz)
+          if ((delta*delta) >= MagickEpsilon)
             {
               channel_distortion[RedChannel]++;
               count++;
@@ -526,7 +524,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
         {
           delta=Sa*(double) GetPixelGreen(p)-Da*(double)
             GetPixelGreen(q);
-          if ((delta*delta) > fuzz)
+          if ((delta*delta) >= MagickEpsilon)
             {
               channel_distortion[GreenChannel]++;
               count++;
@@ -536,7 +534,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
         {
           delta=Sa*(double) GetPixelBlue(p)-Da*(double)
             GetPixelBlue(q);
-          if ((delta*delta) > fuzz)
+          if ((delta*delta) >= MagickEpsilon)
             {
               channel_distortion[BlueChannel]++;
               count++;
@@ -547,7 +545,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
         {
           delta=(double) GetPixelOpacity(p)-(double)
             GetPixelOpacity(q);
-          if ((delta*delta) > fuzz)
+          if ((delta*delta) >= MagickEpsilon)
             {
               channel_distortion[OpacityChannel]++;
               count++;
@@ -558,7 +556,7 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
         {
           delta=Sa*(double) indexes[x]-Da*(double)
             reconstruct_indexes[x];
-          if ((delta*delta) > fuzz)
+          if ((delta*delta) >= MagickEpsilon)
             {
               channel_distortion[IndexChannel]++;
               count++;
@@ -584,27 +582,33 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
 }
 
 static MagickBooleanType GetFuzzDistortion(const Image *image,
-  const Image *reconstruct_image,const ChannelType channel,
-  double *distortion,ExceptionInfo *exception)
+  const Image *reconstruct_image,const ChannelType channel,double *distortion,
+  ExceptionInfo *exception)
 {
   CacheView
     *image_view,
     *reconstruct_view;
 
+  double
+    area,
+    fuzz;
+
   MagickBooleanType
     status;
 
-  ssize_t
-    i;
-
   size_t
     columns,
     rows;
 
   ssize_t
+    j,
     y;
 
+  /*
+    Compute the absolute difference in pixels between two images.
+  */
   status=MagickTrue;
+  fuzz=GetFuzzyColorDistance(image,reconstruct_image);
   SetImageDistortionBounds(image,reconstruct_image,&columns,&rows);
   image_view=AcquireVirtualCacheView(image,exception);
   reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
@@ -614,9 +618,6 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
 #endif
   for (y=0; y < (ssize_t) rows; y++)
   {
-    double
-      channel_distortion[CompositeChannels+1];
-
     const IndexPacket
       *magick_restrict indexes,
       *magick_restrict reconstruct_indexes;
@@ -625,6 +626,9 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
       *magick_restrict p,
       *magick_restrict q;
 
+    double
+      channel_distortion[CompositeChannels+1] = { 0.0 };
+
     ssize_t
       i,
       x;
@@ -643,74 +647,91 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
     (void) memset(channel_distortion,0,sizeof(channel_distortion));
     for (x=0; x < (ssize_t) columns; x++)
     {
-      MagickRealType
-        distance,
+      double
         Da,
+        delta,
         Sa;
 
+      size_t
+        count = 0;
+
       Sa=QuantumScale*(image->matte != MagickFalse ? (double) GetPixelAlpha(p) :
         ((double) QuantumRange-(double) OpaqueOpacity));
-      Da=QuantumScale*(reconstruct_image->matte != MagickFalse ?
-        (double) GetPixelAlpha(q) : ((double) QuantumRange-(double)
-        OpaqueOpacity));
+      Da=QuantumScale*(image->matte != MagickFalse ? (double) GetPixelAlpha(q) :
+        ((double) QuantumRange-(double) OpaqueOpacity));
       if ((channel & RedChannel) != 0)
         {
-          distance=QuantumScale*(Sa*(double) GetPixelRed(p)-Da*(double)
-            GetPixelRed(q));
-          channel_distortion[RedChannel]+=distance*distance;
-          channel_distortion[CompositeChannels]+=distance*distance;
+          delta=Sa*(double) GetPixelRed(p)-Da*(double)
+            GetPixelRed(q);
+          if ((delta*delta) > fuzz)
+            {
+              channel_distortion[RedChannel]++;
+              count++;
+            }
         }
       if ((channel & GreenChannel) != 0)
         {
-          distance=QuantumScale*(Sa*(double) GetPixelGreen(p)-Da*(double)
-            GetPixelGreen(q));
-          channel_distortion[GreenChannel]+=distance*distance;
-          channel_distortion[CompositeChannels]+=distance*distance;
+          delta=Sa*(double) GetPixelGreen(p)-Da*(double)
+            GetPixelGreen(q);
+          if ((delta*delta) > fuzz)
+            {
+              channel_distortion[GreenChannel]++;
+              count++;
+            }
         }
       if ((channel & BlueChannel) != 0)
         {
-          distance=QuantumScale*(Sa*(double) GetPixelBlue(p)-Da*(double)
-            GetPixelBlue(q));
-          channel_distortion[BlueChannel]+=distance*distance;
-          channel_distortion[CompositeChannels]+=distance*distance;
+          delta=Sa*(double) GetPixelBlue(p)-Da*(double)
+            GetPixelBlue(q);
+          if ((delta*delta) > fuzz)
+            {
+              channel_distortion[BlueChannel]++;
+              count++;
+            }
         }
-      if (((channel & OpacityChannel) != 0) && ((image->matte != MagickFalse) ||
-          (reconstruct_image->matte != MagickFalse)))
+      if (((channel & OpacityChannel) != 0) &&
+          (image->matte != MagickFalse))
         {
-          distance=QuantumScale*((image->matte != MagickFalse ? (double)
-            GetPixelOpacity(p) : (double) OpaqueOpacity)-
-            (reconstruct_image->matte != MagickFalse ?
-            (double) GetPixelOpacity(q): (double) OpaqueOpacity));
-          channel_distortion[OpacityChannel]+=distance*distance;
-          channel_distortion[CompositeChannels]+=distance*distance;
+          delta=(double) GetPixelOpacity(p)-(double)
+            GetPixelOpacity(q);
+          if ((delta*delta) > fuzz)
+            {
+              channel_distortion[OpacityChannel]++;
+              count++;
+            }
         }
       if (((channel & IndexChannel) != 0) &&
-          (image->colorspace == CMYKColorspace) &&
-          (reconstruct_image->colorspace == CMYKColorspace))
+          (image->colorspace == CMYKColorspace))
         {
-          distance=QuantumScale*(Sa*(double) GetPixelIndex(indexes+x)-
-            Da*(double) GetPixelIndex(reconstruct_indexes+x));
-          channel_distortion[BlackChannel]+=distance*distance;
-          channel_distortion[CompositeChannels]+=distance*distance;
+          delta=Sa*(double) indexes[x]-Da*(double)
+            reconstruct_indexes[x];
+          if ((delta*delta) > fuzz)
+            {
+              channel_distortion[IndexChannel]++;
+              count++;
+            }
         }
+      if (count != 0)
+        channel_distortion[CompositeChannels]++;
       p++;
       q++;
     }
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
-    #pragma omp critical (MagickCore_GetFuzzDistortion)
+    #pragma omp critical (MagickCore_GetAbsoluteDistortion)
 #endif
     for (i=0; i <= (ssize_t) CompositeChannels; i++)
       distortion[i]+=channel_distortion[i];
   }
   reconstruct_view=DestroyCacheView(reconstruct_view);
   image_view=DestroyCacheView(image_view);
-  distortion[CompositeChannels]/=(double) GetNumberChannels(image,channel);
-  for (i=0; i <= (ssize_t) CompositeChannels; i++)
-    distortion[i]/=((double) columns*rows);
-  distortion[CompositeChannels]=sqrt(distortion[CompositeChannels]);
+  area=PerceptibleReciprocal((double) columns*rows);
+  for (j=0; j <= CompositeChannels; j++)
+    distortion[j]*=area;
   return(status);
 }
 
+
+
 static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
   const Image *reconstruct_image,const ChannelType channel,
   double *distortion,ExceptionInfo *exception)