add ignore edge function in pdiff.

files/source/Metric.cpp

 /*
 Metric
 Copyright (C) 2006 Yangli Hector Yee
 
 This program is free software; you can redistribute it and/or modify it under the terms of the
 GNU General Public License as published by the Free Software Foundation; either version 2 of the License,
 or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
@@ skipping 105 matching lines @@
                 } else {
                         f[i] = (kappa * r[i] + 16.0f) / 116.0f;
                 }
         }
         L = 116.0f * f[1] - 16.0f;
         A = 500.0f * (f[0] - f[1]);
         B = 200.0f * (f[1] - f[2]);
 }
 
 
-// simple convolution based edge detection.

[vangelis, 2009/07/01 18:35:31]

It would be helpful to expand a bit on the comment here.  For example say that
you do convolution with a 3x3 kernel and resulting image values are either 0 or
255 depending of whether the pixel value falls above or below the threshold. 

+// simple convolution based edge detection with a 3-by-3 size kernel.
+// edgeImg is the result, pixel is either 255 which means an edge point
+// or 0 means it is not edge, based on whether the result
+// of convolution is larger than pre-defiend threshold or not.
 void DetectEdge(RGBAImage* diffImg, int* edgeImg, unsigned int w,
-                 unsigned int h, float edgeDetectDegree) {

[vangelis, 2009/07/01 18:35:31]

move second line back by 1 space to align under the first.

-    // define the kernel for convolution.
-    int kernelLength = 3;
-    int kernel[9] = {-1, -1, -1, -1, 8, -1, -1, -1, -1};
-    unsigned int x = 0, y = 0;
-    int cx = 0, cy = 0;
-    for (y = 0; y < h; y++) {
-        for (x = 0; x < w; x++) {

[vangelis, 2009/07/01 18:35:31]

best to use the same number of spaces for indenting lines that the rest of the
code uses.  

-            int index = y * w + x;
-            edgeImg[index] = 0;
-            for (cx = -1; cx <=1; cx++) {
-                for (cy = -1; cy <= 1; cy++) {
-                    int nx = x + cx;
-                    int ny = y + cy;
-                    if (nx < 0) nx = -nx;

[vangelis, 2009/07/01 18:35:31]

I mentioned this in the last review as well but I think the proper thing to do
here is clamp (to zero or to the full size) rather than mirror.

-                    if (ny < 0) ny = -ny;
-                    if (nx >= w) nx = 2 * w - nx - 1;
-                    if (ny >= h) ny= 2 * h - ny - 1;
-                    edgeImg[index] += diffImg->Get_Red(ny * w + nx) * 
-                    kernel[(cy + 1) * kernelLength + cx + 1];

[vangelis, 2009/07/01 18:35:31]

indent the line in to make it clear that it's continuing from above.

-                }
-            }
-            // make it binary based on edgeDetectDegree.
-            // if edgeDetectDegree is 1, threshold is 0
-            // all edges would be ignored.

[vangelis, 2009/07/01 18:35:31]

That's not quite true, right?  If threshold is 0 zero you mark as edge pixels
any pixel that has 7 neighbors or less, which is almost (except for 1 pixel) a
solid 3x3 block. I think that true edges are when you have about 2 to 4
neighbors so the values are close to (8-2)*255 or (8-4)*255

-            // if edgeDetectDegree is a small value near 0
-            // threshold is near 8X255, only scattered
-            // points would be ignored.
-            int threshold = static_cast<int>((1.0f - edgeDetectDegree) *

[vangelis, 2009/07/01 18:35:31]

the threshold calculation should move outside the loop.

-                                             (8 * 255));
-            if (edgeImg[index] > threshold)
-               edgeImg[index] = 255;

[vangelis, 2009/07/01 18:35:31]

Use 4 space indent to stay consistent.

-            else
-               edgeImg[index] = 0;
-        }
-    }
+                unsigned int h, int edgeNeighborNum) {
+        // define the kernel for convolution.
+        int kernelLength = 3;
+        int kernel[9] = {-1, -1, -1, -1, 8, -1, -1, -1, -1};
+        unsigned int x = 0, y = 0;
+        int cx = 0, cy = 0;
+        
+        // threshold based on edgeNeighborNum
+        // edgeNeighborNum is the max number of neighbors
+        // a pixel could have to be considered as
+        // edges.
+        int threshold = (8 - edgeNeighborNum) * 255;
+
+        // shrink the image by 1 pixel to avoid checking boundaries.
+        for (y = 1; y < h - 1; y++) {
+                for (x = 1; x < w - 1; x++) {
+                        int index = y * w + x;
+                        edgeImg[index] = 0;
+                for (cx = -1; cx <=1; cx++) {
+                        for (cy = -1; cy <= 1; cy++) {
+                                int nx = x + cx;
+                                int ny = y + cy;
+                                edgeImg[index] += 
+                                diffImg->Get_Red(ny * w + nx) * 
+                                kernel[(cy + 1) * kernelLength + cx + 1];
+                        }
+                }
+
+                if (edgeImg[index] >= threshold)
+                        edgeImg[index] = 255;
+                else
+                        edgeImg[index] = 0;
+                }
+        }
 }
 
 bool Yee_Compare(CompareArgs &args)
 {
         if ((args.ImgA->Get_Width() != args.ImgB->Get_Width()) ||
                 (args.ImgA->Get_Height() != args.ImgB->Get_Height())) {
                 args.ErrorStr = "Image dimensions do not match\n";
                 return false;
         }
         
@@ skipping 150 matching lines @@
         if (bZ) delete[] bZ;
         if (aLum) delete[] aLum;
         if (bLum) delete[] bLum;
         if (la) delete la;
         if (lb) delete lb;
         if (aA) delete aA;
         if (bA) delete bA;
         if (aB) delete aB;
         if (bB) delete bB;
 
-        if (args.EdgeDetectDegree > 0.0f)
+        if (args.IgnoreEdge)
         {
-        int* edgeImg = new int[w * h];

[vangelis, 2009/07/01 18:35:31]

code block needs to be indented

-      
-        // run convolution based edge detection algorithm.
-        DetectEdge(args.ImgDiff, edgeImg, w, h, args.EdgeDetectDegree);
-
-        // delete edge pixels from the result image.
-        for (y = 0; y < h; y++) {
-            for (x = 0; x < w; x++) {
-                unsigned int index = y * w + x;
-                if (args.ImgDiff->Get_Red(index) == 255 &&
-                    edgeImg[index] == 255)
-                {
-                    args.ImgDiff->Set(0, 0, 0, 255, index);
-                    pixels_failed--;
-                }
-            }
-        }
+                int* edgeImg = new int[w * h];
+
+                // run convolution based edge detection algorithm.
+                DetectEdge(args.ImgDiff, edgeImg, w, h, args.EdgeNeighborNum);
+
+                // delete edge pixels from the result image.
+                for (y = 1; y < h - 1; y++) {
+                        for (x = 1; x < w - 1; x++) {
+                                unsigned int index = y * w + x;
+                                if (args.ImgDiff->Get_Red(index) == 255 &&
+                                        edgeImg[index] == 255) {
+                                        args.ImgDiff->Set(0, 0, 0, 255, index);
+                                        pixels_failed--;
+                                }
+                        }
+                }
 
                 delete[] edgeImg;
         }
     
         char different[100];
         sprintf(different, "%d pixels are different\n", pixels_failed);
 
         // Always output image difference if requested.
-    if (args.ImgDiff)

[vangelis, 2009/07/01 18:35:31]

watch indentation

-    {
-        if (args.ImgDiff->Get_Name().size() > 0) {
-            if (args.ImgDiff->WriteToFile(args.ImgDiff->Get_Name().c_str())) {
-                args.ErrorStr += "Wrote difference image to ";
-                args.ErrorStr+= args.ImgDiff->Get_Name();
-                args.ErrorStr += "\n";
-            } else {
-                args.ErrorStr += "Could not write difference image to ";
-                args.ErrorStr+= args.ImgDiff->Get_Name();
-                args.ErrorStr += "\n";
-            }
-        }
-    }
+        if (args.ImgDiff)
+        {

[vangelis, 2009/07/09 02:43:29]

seems to be some extra whitespace after the { . Please remove.

+                if (args.ImgDiff->Get_Name().size() > 0) {
+                        if (args.ImgDiff->WriteToFile(
+                                          args.ImgDiff->Get_Name().c_str())) {
+                                args.ErrorStr += "Wrote difference image to ";
+                                args.ErrorStr+= args.ImgDiff->Get_Name();
+                                args.ErrorStr += "\n";
+                        } else {
+                                args.ErrorStr += 
+                                        "Could not write difference image to ";
+                                args.ErrorStr+= args.ImgDiff->Get_Name();
+                                args.ErrorStr += "\n";
+                        }
+                }
+        }
         if (pixels_failed < args.ThresholdPixels) {
                 args.ErrorStr = "Images are perceptually indistinguishable\n";
                 args.ErrorStr += different;
                 return true;
         }
         
         args.ErrorStr = "Images are visibly different\n";
         args.ErrorStr += different;
         
         return false;
 }