Add Matrix property to IntegralImage, revert InternalData for backward compartibility.

Author: Volgunin

Sources/Accord.Imaging/AForge.Imaging/IntegralImage.cs

@@ -53,12 +53,20 @@ namespace Accord.Imaging
     public class IntegralImage : ICloneable
     {
         /// <summary>
-        /// Intergral image's array.
+        /// Integral image's array.
+        /// </summary>
+        /// 
+        /// <remarks>See remarks to <see cref="Matrix"/> property.</remarks>
+        /// 
+        protected readonly uint[][] matrix = null;
+
+        /// <summary>
+        /// Integral image's array.
         /// </summary>
         /// 
         /// <remarks>See remarks to <see cref="InternalData"/> property.</remarks>
         /// 
-        protected readonly uint[][] integralImage = null;
+        protected uint[,] integralImage = null;
 
         // image's width and height
         private readonly int width;
@@ -80,6 +88,23 @@ public int Height
             get { return height; }
         }
 
+        /// <summary>
+        /// Provides access to internal array keeping integral image data.
+        /// </summary>
+        /// 
+        /// <remarks>
+        /// <para><note>The array should be accessed by [y][x] indexing.</note></para>
+        /// 
+        /// <para><note>The array's size is [<see cref="Height"/>+1, <see cref="Width"/>+1]. The first
+        /// row and column are filled with zeros, what is done for more efficient calculation of
+        /// rectangles' sums.</note></para>
+        /// </remarks>
+        /// 
+        public uint[][] Matrix
+        {
+            get { return matrix; }
+        }
+
         /// <summary>
         /// Provides access to internal array keeping integral image data.
         /// </summary>
@@ -92,9 +117,25 @@ public int Height
         /// rectangles' sums.</note></para>
         /// </remarks>
         /// 
-        public uint[][] InternalData
+        [Obsolete("Please use Matrix property instead.")]
+        public uint[,] InternalData
         {
-            get { return integralImage; }
+            get
+            {
+                if (integralImage == null)
+                {
+                    integralImage = new uint[height + 1, width + 1];
+                    for (int y = 0; y <= height; y++)
+                    {
+                        for (int x = 0; x <= width; x++)
+                        {
+                            integralImage[y, x] = matrix[y][x];
+                        }
+                    }
+                }
+
+                return integralImage;
+            }
         }
 
         /// <summary>
@@ -104,15 +145,15 @@ public uint[][] InternalData
         /// <param name="width">Image width.</param>
         /// <param name="height">Image height.</param>
         /// 
-        /// <remarks>The constractor is protected, what makes it imposible to instantiate this
+        /// <remarks>The constructor is protected, what makes it impossible to instantiate this
         /// class directly. To create an instance of this class <see cref="FromBitmap(Bitmap)"/> or
         /// <see cref="FromBitmap(BitmapData)"/> method should be used.</remarks>
         ///
         protected IntegralImage(int width, int height)
         {
             this.width = width;
             this.height = height;
-            integralImage = Jagged.Zeros<uint>(height + 1, width + 1);
+            this.matrix = Jagged.Zeros<uint>(height + 1, width + 1);
         }
 
         /// <summary>
@@ -185,7 +226,7 @@ public static IntegralImage FromBitmap(UnmanagedImage image)
 
             // create integral image
             var im = new IntegralImage(width, height);
-            uint[][] integralImage = im.integralImage;
+            uint[][] matrix = im.matrix;
 
             // do the job
             unsafe
@@ -204,7 +245,7 @@ public static IntegralImage FromBitmap(UnmanagedImage image)
 
                         rowSum += *src;
 
-                        integralImage[y][x] = rowSum + integralImage[y - 1][x];
+                        matrix[y][x] = rowSum + matrix[y - 1][x];
                     }
                     src += offset;
                 }
@@ -241,7 +282,7 @@ public uint GetRectangleSum(int x1, int y1, int x2, int y2)
             if (x2 > width) x2 = width;
             if (y2 > height) y2 = height;
 
-            return integralImage[y2][x2] + integralImage[y1][x1] - integralImage[y2][x1] - integralImage[y1][x2];
+            return matrix[y2][x2] + matrix[y1][x1] - matrix[y2][x1] - matrix[y1][x2];
         }
 
         /// <summary>
@@ -257,7 +298,7 @@ public uint GetRectangleSum(int x1, int y1, int x2, int y2)
         /// <remarks><para>The method calculates horizontal wavelet, which is a difference
         /// of two horizontally adjacent boxes' sums, i.e. <b>A-B</b>. A is the sum of rectangle with coordinates
         /// (x, y-radius, x+radius-1, y+radius-1). B is the sum of rectangle with coordinates
-        /// (x-radius, y-radius, x-1, y+radiys-1).</para></remarks>
+        /// (x-radius, y-radius, x-1, y+radius-1).</para></remarks>
         ///
         public int GetHaarXWavelet(int x, int y, int radius)
         {
@@ -314,7 +355,7 @@ public uint GetRectangleSumUnsafe(int x1, int y1, int x2, int y2)
             x2++;
             y2++;
 
-            return integralImage[y2][x2] + integralImage[y1][x1] - integralImage[y2][x1] - integralImage[y1][x2];
+            return matrix[y2][x2] + matrix[y1][x1] - matrix[y2][x1] - matrix[y1][x2];
         }
 
         /// <summary>
@@ -386,7 +427,7 @@ public float GetRectangleMean(int x1, int y1, int x2, int y2)
             if (y2 > height) y2 = height;
 
             // return sum divided by actual rectangles size
-            return (float)((double)(integralImage[y2][x2] + integralImage[y1][x1] - integralImage[y2][x1] - integralImage[y1][x2]) /
+            return (float)((double)(matrix[y2][x2] + matrix[y1][x1] - matrix[y2][x1] - matrix[y1][x2]) /
                 (double)((x2 - x1) * (y2 - y1)));
         }
 
@@ -409,7 +450,7 @@ public float GetRectangleMeanUnsafe(int x1, int y1, int x2, int y2)
             y2++;
 
             // return sum divided by actual rectangles size
-            return (float)((double)(integralImage[y2][x2] + integralImage[y1][x1] - integralImage[y2][x1] - integralImage[y1][x2]) /
+            return (float)((double)(matrix[y2][x2] + matrix[y1][x1] - matrix[y2][x1] - matrix[y1][x2]) /
                 (double)((x2 - x1) * (y2 - y1)));
         }
 

Sources/Accord.Imaging/Interest Points/FREAK/FastRetinaKeypointDescriptor.cs

@@ -345,10 +345,10 @@ private unsafe int mean(double kx, double ky, int scale, int orientation, int po
             int x_right = (int)(xf + radius + 1.5);  // integral image is 1px wider
             int y_bottom = (int)(yf + radius + 1.5); // integral image is 1px higher
 
-            ret_val = (int)Integral.InternalData[y_bottom][x_right]; // bottom right corner
-            ret_val -= (int)Integral.InternalData[y_bottom][x_left];
-            ret_val += (int)Integral.InternalData[y_top][x_left];
-            ret_val -= (int)Integral.InternalData[y_top][x_right];
+            ret_val = (int)Integral.Matrix[y_bottom][x_right]; // bottom right corner
+            ret_val -= (int)Integral.Matrix[y_bottom][x_left];
+            ret_val += (int)Integral.Matrix[y_top][x_left];
+            ret_val -= (int)Integral.Matrix[y_top][x_right];
             ret_val = ret_val / ((x_right - x_left) * (y_bottom - y_top));
             return ret_val;
         }