Merge pull request #501 from dlemstra/Convolution2DFilter

Use jagged instead of multidimensional array

Former-commit-id: 7d19a23161b8d00d111f09c7d1a7db0ed2b00489
Former-commit-id: ebbf751a3c568ee41ff17c941a21df44060441a2
Former-commit-id: d3c9b2f302a528ec10f58889000792c894e3cf88

src/ImageProcessorCore/Samplers/Processors/Convolution/Convolution2DFilter.cs

@@ -23,7 +23,7 @@ namespace ImageProcessorCore.Processors
         /// </summary>
         /// <param name="kernelX">The horizontal gradient operator.</param>
         /// <param name="kernelY">The vertical gradient operator.</param>
-        public Convolution2DFilter(float[,] kernelX, float[,] kernelY)
+        public Convolution2DFilter(float[][] kernelX, float[][] kernelY)
         {
             this.KernelX = kernelX;
             this.KernelY = kernelY;
@@ -32,22 +32,20 @@ namespace ImageProcessorCore.Processors
         /// <summary>
         /// Gets the horizontal gradient operator.
         /// </summary>
-        public float[,] KernelX { get; }
+        public float[][] KernelX { get; }
 
         /// <summary>
         /// Gets the vertical gradient operator.
         /// </summary>
-        public float[,] KernelY { get; }
+        public float[][] KernelY { get; }
 
         /// <inheritdoc/>
         public override void Apply(ImageBase<TColor, TPacked> target, ImageBase<TColor, TPacked> source, Rectangle targetRectangle, Rectangle sourceRectangle, int startY, int endY)
         {
-            float[,] kernelX = this.KernelX;
+            int kernelYHeight = KernelY.Length;
-            float[,] kernelY = this.KernelY;
+            int kernelYWidth = KernelY[0].Length;
-            int kernelYHeight = kernelY.GetLength(0);
+            int kernelXHeight = KernelX.Length;
-            int kernelYWidth = kernelY.GetLength(1);
+            int kernelXWidth = KernelX[0].Length;
-            int kernelXHeight = kernelX.GetLength(0);
-            int kernelXWidth = kernelX.GetLength(1);
             int radiusY = kernelYHeight >> 1;
             int radiusX = kernelXWidth >> 1;
 
@@ -100,16 +98,16 @@ namespace ImageProcessorCore.Processors
 
                                     if (fy < kernelXHeight)
                                     {
-                                        rX += kernelX[fy, fx] * r;
+                                        rX += KernelX[fy][fx] * r;
-                                        gX += kernelX[fy, fx] * g;
+                                        gX += KernelX[fy][fx] * g;
-                                        bX += kernelX[fy, fx] * b;
+                                        bX += KernelX[fy][fx] * b;
                                     }
 
                                     if (fx < kernelYWidth)
                                     {
-                                        rY += kernelY[fy, fx] * r;
+                                        rY += KernelY[fy][fx] * r;
-                                        gY += kernelY[fy, fx] * g;
+                                        gY += KernelY[fy][fx] * g;
-                                        bY += kernelY[fy, fx] * b;
+                                        bY += KernelY[fy][fx] * b;
                                     }
                                 }
                             }

src/ImageProcessorCore/Samplers/Processors/Convolution/EdgeDetection/EdgeDetector2DFilter.cs

@@ -18,12 +18,12 @@ namespace ImageProcessorCore.Processors
         /// <summary>
         /// Gets the horizontal gradient operator.
         /// </summary>
-        public abstract float[,] KernelX { get; }
+        public abstract float[][] KernelX { get; }
 
         /// <summary>
         /// Gets the vertical gradient operator.
         /// </summary>
-        public abstract float[,] KernelY { get; }
+        public abstract float[][] KernelY { get; }
 
         /// <inheritdoc/>
         public bool Grayscale { get; set; }

src/ImageProcessorCore/Samplers/Processors/Convolution/EdgeDetection/KayyaliProcessor.cs

@@ -15,20 +15,24 @@ namespace ImageProcessorCore.Processors
         where TColor : IPackedVector<TPacked>
         where TPacked : struct
     {
-        /// <inheritdoc/>
+        private static readonly float[][] kernelX = new float[3][]
-        public override float[,] KernelX => new float[,]
         {
-            { 6, 0, -6 },
+            new float[] { 6, 0, -6 },
-            { 0, 0, 0 },
+            new float[] { 0, 0, 0 },
-            { -6, 0, 6 }
+            new float[] { -6, 0, 6 }
         };
 
-        /// <inheritdoc/>
+        private static readonly float[][] kernelY = new float[3][]
-        public override float[,] KernelY => new float[,]
         {
-            { -6, 0, 6 },
+            new float[] { -6, 0, 6 },
-            { 0, 0, 0 },
+            new float[] { 0, 0, 0 },
-            { 6, 0, -6 }
+            new float[] { 6, 0, -6 }
         };
+
+        /// <inheritdoc/>
+        public override float[][] KernelX => kernelX;
+
+        /// <inheritdoc/>
+        public override float[][] KernelY => kernelY;
     }
 }

src/ImageProcessorCore/Samplers/Processors/Convolution/EdgeDetection/PrewittProcessor.cs

@@ -15,20 +15,24 @@ namespace ImageProcessorCore.Processors
         where TColor : IPackedVector<TPacked>
         where TPacked : struct
     {
-        /// <inheritdoc/>
+        private static readonly float[][] kernelX = new float[3][]
-        public override float[,] KernelX => new float[,]
         {
-            { -1, 0, 1 },
+            new float[] { -1, 0, 1 },
-            { -1, 0, 1 },
+            new float[] { -1, 0, 1 },
-            { -1, 0, 1 }
+            new float[] { -1, 0, 1 }
         };
 
-        /// <inheritdoc/>
+        private static readonly float[][] kernelY = new float[3][]
-        public override float[,] KernelY => new float[,]
         {
-            { 1, 1, 1 },
+            new float[] { 1, 1, 1 },
-            { 0, 0, 0 },
+            new float[] { 0, 0, 0 },
-            { -1, -1, -1 }
+            new float[] { -1, -1, -1 }
         };
+
+        /// <inheritdoc/>
+        public override float[][] KernelX => kernelX;
+
+        /// <inheritdoc/>
+        public override float[][] KernelY => kernelY;
     }
 }

src/ImageProcessorCore/Samplers/Processors/Convolution/EdgeDetection/RobertsCrossProcessor.cs

@@ -15,18 +15,22 @@ namespace ImageProcessorCore.Processors
         where TColor : IPackedVector<TPacked>
         where TPacked : struct
     {
-        /// <inheritdoc/>
+        private static readonly float[][] kernelX = new float[2][]
-        public override float[,] KernelX => new float[,]
         {
-            { 1, 0 },
+            new float[] { 1, 0 },
-            { 0, -1 }
+            new float[] { 0, -1 }
         };
 
-        /// <inheritdoc/>
+        private static readonly float[][] kernelY = new float[2][]
-        public override float[,] KernelY => new float[,]
         {
-            { 0, 1 },
+            new float[] { 0, 1 },
-            { -1, 0 }
+            new float[] { -1, 0 }
         };
+
+        /// <inheritdoc/>
+        public override float[][] KernelX => kernelX;
+
+        /// <inheritdoc/>
+        public override float[][] KernelY => kernelY;
     }
 }

src/ImageProcessorCore/Samplers/Processors/Convolution/EdgeDetection/ScharrProcessor.cs

@@ -15,20 +15,24 @@ namespace ImageProcessorCore.Processors
         where TColor : IPackedVector<TPacked>
         where TPacked : struct
     {
-        /// <inheritdoc/>
+        private static readonly float[][] kernelX = new float[3][]
-        public override float[,] KernelX => new float[,]
         {
-            { -3, 0, 3 },
+            new float[] { -3, 0, 3 },
-            { -10, 0, 10 },
+            new float[] { -10, 0, 10 },
-            { -3, 0, 3 }
+            new float[] { -3, 0, 3 }
         };
 
-        /// <inheritdoc/>
+        private static readonly float[][] kernelY = new float[3][]
-        public override float[,] KernelY => new float[,]
         {
-            { 3, 10, 3 },
+            new float[] { 3, 10, 3 },
-            { 0, 0, 0 },
+            new float[] { 0, 0, 0 },
-            { -3, -10, -3 }
+            new float[] { -3, -10, -3 }
         };
+
+        /// <inheritdoc/>
+        public override float[][] KernelX => kernelX;
+
+        /// <inheritdoc/>
+        public override float[][] KernelY => kernelY;
     }
 }

src/ImageProcessorCore/Samplers/Processors/Convolution/EdgeDetection/SobelProcessor.cs

@@ -15,20 +15,24 @@ namespace ImageProcessorCore.Processors
         where TColor : IPackedVector<TPacked>
         where TPacked : struct
     {
-        /// <inheritdoc/>
+        private static readonly float[][] kernelX = new float[3][]
-        public override float[,] KernelX => new float[,]
         {
-            { -1, 0, 1 },
+            new float[] { -1, 0, 1 },
-            { -2, 0, 2 },
+            new float[] { -2, 0, 2 },
-            { -1, 0, 1 }
+            new float[] { -1, 0, 1 }
         };
 
-        /// <inheritdoc/>
+        private static readonly float[][] kernelY = new float[3][]
-        public override float[,] KernelY => new float[,]
         {
-            { -1, -2, -1 },
+            new float[] { -1, -2, -1 },
-            { 0, 0, 0 },
+            new float[] { 0, 0, 0 },
-            { 1, 2, 1 }
+            new float[] { 1, 2, 1 }
         };
+
+        /// <inheritdoc/>
+        public override float[][] KernelX => kernelX;
+
+        /// <inheritdoc/>
+        public override float[][] KernelY => kernelY;
     }
 }

tests/ImageProcessorCore.Benchmarks/Samplers/DetectEdges.cs

@@ -0,0 +1,47 @@
+// <copyright file="DetectEdges.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+
+namespace ImageProcessorCore.Benchmarks
+{
+    using System.IO;
+
+    using BenchmarkDotNet.Attributes;
+
+    using CoreImage = ImageProcessorCore.Image;
+
+    public class DetectEdges
+    {
+        private CoreImage image;
+
+        [Setup]
+        public void ReadImage()
+        {
+            if (image == null)
+            {
+                using(FileStream stream = File.OpenRead("../ImageProcessorCore.Tests/TestImages/Formats/Bmp/Car.bmp"))
+                {
+                    image = new CoreImage(stream);
+                }
+            }
+        }
+
+        [Benchmark(Description = "ImageProcessorCore DetectEdges")]
+        public void ImageProcessorCoreDetectEdges()
+        {
+            image.DetectEdges(EdgeDetection.Kayyali);
+            image.DetectEdges(EdgeDetection.Kayyali);
+            image.DetectEdges(EdgeDetection.Kirsch);
+            image.DetectEdges(EdgeDetection.Lapacian3X3);
+            image.DetectEdges(EdgeDetection.Lapacian5X5);
+            image.DetectEdges(EdgeDetection.LaplacianOfGaussian);
+            image.DetectEdges(EdgeDetection.Prewitt);
+            image.DetectEdges(EdgeDetection.RobertsCross);
+            image.DetectEdges(EdgeDetection.Robinson);
+            image.DetectEdges(EdgeDetection.Scharr);
+            image.DetectEdges(EdgeDetection.Sobel);
+        }
+    }
+}