Implemented FindZeroSegments with tests

Author: apdevelop

Src/ScreenGrid.Models.Tests/FlatImageTests.cs

@@ -1,8 +1,11 @@
 namespace ScreenGrid.Models.Tests
 {
-    using NUnit.Framework;
+    using System;
+    using System.Collections.Generic;
     using System.Drawing;
 
+    using NUnit.Framework;
+
     [TestFixture]
     public class FlatImageTests
     {
@@ -24,6 +27,112 @@ public void GetHorizontalStripeTest()
             Assert.AreEqual(width, stripeMiddle.Length);
         }
 
+        [Test]
+        public void GetDerivativeTest()
+        {
+            var flatImage = LoadFlatImageFromResource("ScreenGrid.Models.Tests.Resources.ImageSimple.png");
+            var stripeMiddle = flatImage.GetHorizontalStripe(flatImage.Height / 2);
+
+            var dMiddle = FlatImage.GetDerivative(stripeMiddle);
+            Assert.AreEqual(stripeMiddle.Length, dMiddle.Length);
+
+            // Border detection
+            Assert.AreEqual(0, dMiddle[11]);
+            Assert.Greater(dMiddle[12], 0);
+        }
+
+
+        [Test]
+        public void FindBordersTest()
+        {
+            var flatImage = LoadFlatImageFromResource("ScreenGrid.Models.Tests.Resources.ImageSimple.png");
+
+            const int minimalSegmentLength = 8;
+            var step = flatImage.Height / 8;
+
+            var list = new List<Tuple<int, int>>();
+            for (var iy = minimalSegmentLength + step; iy < flatImage.Height - (minimalSegmentLength + step); iy += step)
+            {
+                var stripe = flatImage.GetHorizontalStripe(iy);
+                var derivative = FlatImage.GetDerivative(stripe);
+                var segments = FlatImage.FindZeroSegments(derivative, minimalSegmentLength);
+
+                Assert.AreEqual(2, segments.Count, String.Format("iy={0}", iy));
+            }
+        }
+
+        [Test]
+        public void FindZeroSegmentsTest1()
+        {
+            var array = new UInt32[] { 1, 0, 0, 0, 0, 0, 1, 2, 1, 0, 3, 4, 0, 3, 5 };
+            var result = FlatImage.FindZeroSegments(array, 4);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(1, result[0].Item1);
+            Assert.AreEqual(5, result[0].Item2);
+        }
+
+        [Test]
+        public void FindZeroSegmentsTestThreeSegments()
+        {
+            var array = new UInt32[] { 1, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 3, 4, 0, 0, 3, 0, 5 };
+            var result = FlatImage.FindZeroSegments(array, 2);
+            Assert.AreEqual(3, result.Count);
+            Assert.AreEqual(1, result[0].Item1);
+            Assert.AreEqual(5, result[0].Item2);
+            Assert.AreEqual(9, result[1].Item1);
+            Assert.AreEqual(10, result[1].Item2);
+            Assert.AreEqual(13, result[2].Item1);
+            Assert.AreEqual(14, result[2].Item2);
+        }
+
+        [Test]
+        public void FindZeroSegmentsTestNoSegments()
+        {
+            var array = new UInt32[] { 1, 0, 0, 1, 2, 3 };
+            var result = FlatImage.FindZeroSegments(array, 3);
+            Assert.AreEqual(0, result.Count);
+        }
+
+        [Test]
+        public void FindZeroSegmentsTestShortAllZeroSegment()
+        {
+            var array = new UInt32[] { 0, 0, 0, 0, };
+            var result = FlatImage.FindZeroSegments(array, 4);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(0, result[0].Item1);
+            Assert.AreEqual(3, result[0].Item2);
+        }
+
+        [Test]
+        public void FindZeroSegmentsTestAllZeroSegment()
+        {
+            var array = new UInt32[] { 0, 0, 0, 0, 0, 0 };
+            var result = FlatImage.FindZeroSegments(array, 3);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(0, result[0].Item1);
+            Assert.AreEqual(5, result[0].Item2);
+        }
+
+        [Test]
+        public void FindZeroSegmentsTestSimpleSegment1()
+        {
+            var array = new UInt32[] { 1, 0, 0, 0, 0, 0 };
+            var result = FlatImage.FindZeroSegments(array, 3);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(1, result[0].Item1);
+            Assert.AreEqual(5, result[0].Item2);
+        }
+
+        [Test]
+        public void FindZeroSegmentsTestSimpleSegment2()
+        {
+            var array = new UInt32[] { 0, 0, 0, 0, 0, 1 };
+            var result = FlatImage.FindZeroSegments(array, 3);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(0, result[0].Item1);
+            Assert.AreEqual(4, result[0].Item2);
+        }
+
         private static FlatImage LoadFlatImageFromResource(string resourceName)
         {
             FlatImage flatImage;

Src/ScreenGrid.Models.Tests/Resources/ImageSimple.png

@@ -1,6 +1,7 @@
 namespace ScreenGrid.Models
 {
     using System;
+    using System.Collections.Generic;
 
     /// <summary>
     /// 'Flattened' image representation for fast processing
@@ -54,6 +55,75 @@ public UInt32[] GetHorizontalStripe(int iy)
             return result;
         }
 
+        public static UInt32[] GetDerivative(UInt32[] stripe)
+        {
+            var result = new UInt32[stripe.Length];
+
+            result[0] = stripe[0];
+            for (var i = 1; i < stripe.Length; i++)
+            {
+                result[i] = stripe[i] - stripe[i - 1];
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Search for all-zero segments of array with given minimal length
+        /// </summary>
+        /// <param name="array">Input array</param>
+        /// <param name="minimalSegmentLength">Minimal length of segment</param>
+        /// <returns>List of segments (startIndex, endIndex) which contains only zeros</returns>
+        public static IList<Tuple<int, int>> FindZeroSegments(UInt32[] array, int minimalSegmentLength)
+        {
+            var result = new List<Tuple<int, int>>();
+
+            if (array.Length < minimalSegmentLength)
+            {
+                return result;
+            }
+
+            int lastZero = -1;
+            for (var i = 0; i < array.Length; i++)
+            {
+                if (array[i] == 0)
+                {
+                    if (lastZero == -1)
+                    {
+                        lastZero = i;
+                    }
+
+                    if (i == (array.Length - 1))
+                    {
+                        var segment = new Tuple<int, int>(lastZero, i);
+                        if (CheckSegmentLength(segment, minimalSegmentLength))
+                        {
+                            result.Add(segment);
+                        }
+                    }
+                }
+                else
+                {
+                    if (lastZero != -1)
+                    {
+                        var segment = new Tuple<int, int>(lastZero, i - 1);
+                        lastZero = -1;
+                        if (CheckSegmentLength(segment, minimalSegmentLength))
+                        {
+                            result.Add(segment);
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        private static bool CheckSegmentLength(Tuple<int, int> segment, int minimalSegmentLength)
+        {
+            return ((segment.Item2 - segment.Item1 + 1) >= minimalSegmentLength);
+        }
+
         public bool CompareWithFragment(FlatImage fragment, int startX, int startY)
         {
             for (var x = 0; x < fragment.Width; x++)