Implemented additional checks in FlatImage.FindBoundingsOfInnerImage() function, added test

Author: apdevelop

Src/ScreenGrid.Models.Tests/FlatImageTests.cs

@@ -41,7 +41,6 @@ public void GetDerivativeTest()
             Assert.Greater(dMiddle[12], 0);
         }
 
-
         [Test]
         public void FindBordersTest()
         {
@@ -61,6 +60,19 @@ public void FindBordersTest()
             }
         }
 
+        [Test]
+        public void FindBoundingsOfInnerImage()
+        {
+            var flatImage = LoadFlatImageFromResource("ScreenGrid.Models.Tests.Resources.ImageSimple.png");
+
+            var result = flatImage.FindBoundingsOfInnerImage();
+
+            Assert.AreEqual(12, result.X);
+            Assert.AreEqual(10, result.Y);
+            Assert.AreEqual(40, result.Width);
+            Assert.AreEqual(28, result.Height);
+        }
+
         [Test]
         public void FindZeroSegmentsTest1()
         {

Src/ScreenGrid.Models/FlatImage.cs

@@ -161,7 +161,7 @@ public static IList<Tuple<int, int>> IntersectionOfSegments(IEnumerable<IList<Tu
                     sum.AddRange(line);
                 }
                 else
-                { 
+                {
                     // Perform intersection checks
                     var newSum = new List<Tuple<int, int>>();
                     foreach (var segmentA in sum)
@@ -211,25 +211,60 @@ public static Tuple<int, int> SegmentsWithMaxDistance(IList<Tuple<int, int>> seg
             return new Tuple<int, int>(i1, i2);
         }
 
+        private IList<Tuple<int, int>> FindHorizontalZeroSegments(int iy, int minimalSegmentLength)
+        {
+            return FlatImage.FindZeroSegments(FlatImage.GetDerivative(this.GetHorizontalStripe(iy)), minimalSegmentLength);
+        }
+
+        private IList<Tuple<int, int>> FindVerticalZeroSegments(int ix, int minimalSegmentLength)
+        {
+            return FlatImage.FindZeroSegments(FlatImage.GetDerivative(this.GetVerticalStripe(ix)), minimalSegmentLength);
+        }
+
         public Models.Geometry.Rectangle FindBoundingsOfInnerImage()
         {
             // TODO: add tests for this method
             const int minimalSegmentLength = 8;
 
-            // TODO: Very simple method, need to perform more checks and do more searches
             var stripeCH = FlatImage.FindZeroSegments(FlatImage.GetDerivative(this.GetHorizontalStripe(this.Height / 2)), minimalSegmentLength);
             var stripeCV = FlatImage.FindZeroSegments(FlatImage.GetDerivative(this.GetVerticalStripe(this.Width / 2)), minimalSegmentLength);
 
-            var maxH = FlatImage.SegmentsWithMaxDistance(stripeCH);
-            var maxV = FlatImage.SegmentsWithMaxDistance(stripeCV);
+            // TODO: optimize code
+            for (var iy = 1 * this.Height / 4; iy < 3 * this.Height / 4; iy += minimalSegmentLength)
+            {
+                stripeCH = FlatImage.IntersectionOfSegments(new[]
+                    { 
+                        stripeCH, 
+                        FindHorizontalZeroSegments(iy, minimalSegmentLength)
+                    });
+            }
+
+            for (var ix = 1 * this.Width / 4; ix < 3 * this.Width / 4; ix += minimalSegmentLength)
+            {
+                stripeCV = FlatImage.IntersectionOfSegments(new[]
+                    { 
+                        stripeCV, 
+                        FindVerticalZeroSegments(ix, minimalSegmentLength)
+                    });
+            }
 
-            return new Geometry.Rectangle
+            if ((stripeCH.Count > 1) && (stripeCV.Count > 1))
             {
-                X = maxH.Item1 + 1,
-                Y = maxV.Item1 + 1,
-                Width = maxH.Item2 - maxH.Item1 - 2,
-                Height = maxV.Item2 - maxV.Item1 - 2,
-            };
+                var maxH = FlatImage.SegmentsWithMaxDistance(stripeCH);
+                var maxV = FlatImage.SegmentsWithMaxDistance(stripeCV);
+
+                return new Geometry.Rectangle
+                {
+                    X = maxH.Item1 + 1,
+                    Y = maxV.Item1 + 1,
+                    Width = maxH.Item2 - maxH.Item1 - 2,
+                    Height = maxV.Item2 - maxV.Item1 - 2,
+                };
+            }
+            else
+            {
+                return new Geometry.Rectangle();
+            }
         }
 
         public bool CompareWithFragment(FlatImage fragment, int startX, int startY)
@@ -297,7 +332,7 @@ public bool CompareWithFragmentWithTolerance(FlatImage fragment, int startX, int
 
         public unsafe System.Drawing.Bitmap ToBitmap()
         {
-            var bitmap = new System.Drawing.Bitmap(this.Width, this.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); 
+            var bitmap = new System.Drawing.Bitmap(this.Width, this.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
 
             const int pixelSize = 3;
             var rect = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height);

Src/ScreenGrid.ViewModels/ScreenGridViewModel.cs

@@ -298,26 +298,29 @@ public void SnapToRenderView()
                         var bitmap = nativeWindow.GetShot();
                         var flatImage = new Models.FlatImage(bitmap);
 
-                        Models.Geometry.Rectangle rectRenderedImage;
+                        Models.Geometry.Rectangle imageBoundings;
                         if (Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses().Any(w => w.ClassName == nativeWindow.ClassName))
                         {
                             // TODO: remove this Octane Render specific code
-                            rectRenderedImage = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);
+                            imageBoundings = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);
                         }
                         else
                         {
-                            rectRenderedImage = flatImage.FindBoundingsOfInnerImage();
+                            imageBoundings = flatImage.FindBoundingsOfInnerImage();
                         }
 
                         var nativeWindowLocation = new Models.Geometry.Point(nativeWindow.Location.X, nativeWindow.Location.Y);
-                        return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(rectRenderedImage, nativeWindowLocation);
+                        return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(imageBoundings, nativeWindowLocation);
                     }).ContinueWith((t) =>
                     {
-                        var rectRenderedImage = t.Result.Item1;
+                        var imageBoundings = t.Result.Item1;
                         var windowLocation = t.Result.Item2;
-                        if (!rectRenderedImage.IsEmpty)
+                        if (!imageBoundings.IsEmpty)
                         {
-                            this.PositionWindow(t.Result.Item2, t.Result.Item1);
+                            if ((imageBoundings.Width > 150) && (imageBoundings.Height > 50))
+                            {
+                                this.PositionWindow(t.Result.Item2, t.Result.Item1);
+                            }
                         }
                     },
                     TaskScheduler.FromCurrentSynchronizationContext());