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.
-void detect_edge(RGBAImage* diff_image, int* edge_image, unsigned int w, unsigned int h) {

[vangelis, 2009/06/30 02:35:05]

best to stick with the 80 column limit and break long lines.

-    // define the kernel for convolution.
-    int kernel_length = 3;

[vangelis, 2009/06/30 02:35:05]

Seems that the current convention for pdiff is to use camelCase for variable
names.  Best to match that.  
kernel_length -> kernelLength

and there's a few spots below as well. 

-    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++)
-        {
-            int index = y * w + x;
-                        edge_image[index] = 0;

[vangelis, 2009/06/30 02:35:05]

watch indentation.

-            for (cx = -1; cx <=1; cx++)

[vangelis, 2009/06/30 02:35:05]

it's good practice to always use curly braces { } for the body of for loops.  It
makes code easier to read and modify and it's less error prone.

-                for (cy = -1; cy <= 1; cy++)
-                {
-                    int nx = x + cx;
-                    int ny = y + cy;
-                    if (nx < 0) nx = -nx;

[vangelis, 2009/06/30 02:35:05]

it seems that instead of wrapping we should clamp to the image borders.

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

[vangelis, 2009/06/30 02:35:05]

80 col limit

-                }
-            // make it binary.
-            if (edge_image[index] > 50)

[vangelis, 2009/06/30 02:35:05]

since 50 is an arbitrary value, it should be exposed as a command line argument 
associated with the edge flag. 

-                edge_image[index] = 255;
-            else
-                edge_image[index] = 0;
-        }
+// 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, 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;
 
-        //*******************************************************************
-        //detect edges here, and protect them to be checked as inconsistece.*

[vangelis, 2009/06/30 02:35:05]

Not sure I understand the comment here.  

-        //*******************************************************************
-        if (args.EdgeDetect)
+        if (args.IgnoreEdge)
         {
-                int* edge_image = new int[w * h];
-    
-                // then run convolution based edge detection algorithm.
-                detect_edge(args.ImgDiff, edge_image, w, h);
-
-                for (y = 0; y < h; y++) {
-                        for (x = 0; x < w; x++) {
+                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 &&
-                                                        edge_image[index] == 255)

[vangelis, 2009/06/30 02:35:05]

watch indentation

-                                {
+                                        edgeImg[index] == 255) {
                                         args.ImgDiff->Set(0, 0, 0, 255, index);
                                         pixels_failed--;
                                 }
                         }
                 }
 
-                // output edge image.
-                // generate the file name of the edge image.
-                /*std::string ref_name = args.ImgA->Get_Name();

[vangelis, 2009/06/30 02:35:05]

If this code is not used, please remove it.

-                std::string edgeImgName = ref_name.substr(0, ref_name.find(".", 0));
-                edgeImgName.append("_result_edge");
-                edgeImgName.append(ref_name.substr(ref_name.find(".", 0), ref_name.size() - ref_name.find(".", 0)));
-        
-                RGBAImage edgeImg(w, h, edgeImgName.c_str());
-                for (y = 0; y < h; y++) {
-                  for (x = 0; x < w; x++) {
-                          int index = y * w + x;
-                          if (edge_image[index] == 255)
-                                  edgeImg.Set(255, 0, 0, 255, index);
-                         else
-                                edgeImg.Set(0, 0, 0, 255, index);
-                  }
-                }
-                edgeImg.WriteToFile(edgeImg.Get_Name().c_str());*/
-
-                delete[] edge_image;
-        }
-    //*******************************************************************

[vangelis, 2009/06/30 02:35:05]

Do we need this comment here? 

-        //detect edges above, and protect them to be checked as inconsistece.
-        //*******************************************************************
+                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/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())) {
+                        if (args.ImgDiff->WriteToFile(
+                                          args.ImgDiff->Get_Name().c_str())) {
                                 args.ErrorStr += "Wrote difference image to ";
                                 args.ErrorStr+= args.ImgDiff->Get_Name();

[vangelis, 2009/06/30 02:35:05]

Looks like there's tabs in there.  Please remove..  Here and below.

                                 args.ErrorStr += "\n";
                         } else {
-                                args.ErrorStr += "Could not write difference image to ";
+                                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;
 }