Implemented automatic window snap to image displayed in Firefox application

Author: apdevelop

Src/ScreenGrid.Models/FlatImage.cs

@@ -55,6 +55,17 @@ public UInt32[] GetHorizontalStripe(int iy)
             return result;
         }
 
+        public UInt32[] GetVerticalStripe(int ix)
+        {
+            var result = new UInt32[this.Height];
+            for (var iy = 0; iy < this.Height; iy++)
+            {
+                result[iy] = this.pixels[ix, iy];
+            }
+
+            return result;
+        }
+
         // TODO: move to separate class
 
         public static UInt32[] GetDerivative(UInt32[] stripe)
@@ -176,6 +187,51 @@ public static IList<Tuple<int, int>> IntersectionOfSegments(IEnumerable<IList<Tu
             return sum;
         }
 
+        public static Tuple<int, int> SegmentsWithMaxDistance(IList<Tuple<int, int>> segments)
+        {
+            if (segments.Count < 2)
+            {
+                throw new ArgumentException();
+            }
+
+            var i1 = 0;
+            var i2 = 0;
+            var maxDistance = 0;
+            for (var i = 0; i < segments.Count - 1; i++)
+            {
+                var distance = segments[i + 1].Item1 - segments[i].Item2;
+                if (distance > maxDistance)
+                {
+                    i1 = segments[i].Item2;
+                    i2 = segments[i + 1].Item1;
+                    maxDistance = distance;
+                }
+            }
+
+            return new Tuple<int, int>(i1, i2);
+        }
+
+        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);
+
+            return new Geometry.Rectangle
+            {
+                X = maxH.Item1 + 1,
+                Y = maxV.Item1 + 1,
+                Width = maxH.Item2 - maxH.Item1 - 2,
+                Height = maxV.Item2 - maxV.Item1 - 2,
+            };
+        }
+
         public bool CompareWithFragment(FlatImage fragment, int startX, int startY)
         {
             for (var x = 0; x < fragment.Width; x++)
@@ -238,5 +294,30 @@ public bool CompareWithFragmentWithTolerance(FlatImage fragment, int startX, int
 
             return res;
         }
+
+        public unsafe System.Drawing.Bitmap ToBitmap()
+        {
+            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);
+            var bitmapData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.WriteOnly, bitmap.PixelFormat);
+
+            for (var y = 0; y < bitmapData.Height; y++)
+            {
+                var row = (byte*)bitmapData.Scan0 + (y * bitmapData.Stride);
+                for (var x = 0; x < bitmapData.Width; x++)
+                {
+                    var pix = BitConverter.GetBytes(this.pixels[x, y]);
+                    row[x * pixelSize + 0] = pix[1];
+                    row[x * pixelSize + 1] = pix[2];
+                    row[x * pixelSize + 2] = pix[3];
+                }
+            }
+
+            bitmap.UnlockBits(bitmapData);
+
+            return bitmap;
+        }
     }
 }

Src/ScreenGrid.ViewModels/ScreenGridViewModel.cs

@@ -253,14 +253,14 @@ public string CaptionText
         {
             get
             {
-                return String.Format(CultureInfo.InvariantCulture, 
-                    "{0}\u00D7{1}", 
+                return String.Format(CultureInfo.InvariantCulture,
+                    "{0}\u00D7{1}",
                     (int)(this.WindowWidth - 2 * OuterBorderWidth),
                     (int)(this.WindowHeight - 2 * OuterBorderWidth - HeaderHeight));
             }
         }
 
-        public void SnapToRenderView()
+        private IList<string> GetWindowClassNames()
         {
             var classNames = new List<string>();
 
@@ -269,61 +269,66 @@ public void SnapToRenderView()
             var orw = Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses();
             classNames.AddRange(orw.Select(w => w.ClassName));
 
+            classNames.Add("MozillaWindowClass"); // TODO: do not use window class names, check any applications with topmost windows
+
+            return classNames;
+        }
+
+        public void SnapToRenderView()
+        {
             // select foreground window from several processes of supported applications
-            var window = Models.AppsInterop.NativeWindow.GetTopMostWindow(classNames);
+            var nativeWindow = Models.AppsInterop.NativeWindow.GetTopMostWindow(this.GetWindowClassNames());
 
-            if (window != null)
+            if (nativeWindow != null)
             {
-                switch (window.ClassName)
+                if (nativeWindow.ClassName == Models.AppsInterop.PhotoViewerWindow.MainWindowClassName)
                 {
-                    case Models.AppsInterop.PhotoViewerWindow.MainWindowClassName:
-                        {
-                            var photoViewerWindow = new Models.AppsInterop.PhotoViewerWindow(window.Handle);
+                    var photoViewerWindow = new Models.AppsInterop.PhotoViewerWindow(nativeWindow.Handle);
 
-                            var rectViewedImage = photoViewerWindow.PhotoCanvasRect();
-                            if (!rectViewedImage.IsEmpty)
-                            {
-                                this.PositionWindow(Models.Geometry.Point.Zero, rectViewedImage);
-                            }
+                    var rectViewedImage = photoViewerWindow.PhotoCanvasRect();
+                    if (!rectViewedImage.IsEmpty)
+                    {
+                        this.PositionWindow(Models.Geometry.Point.Zero, rectViewedImage);
+                    }
+                }
+                else
+                {
+                    Task.Factory.StartNew<Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>>(() =>
+                    {
+                        var bitmap = nativeWindow.GetShot();
+                        var flatImage = new Models.FlatImage(bitmap);
 
-                            break;
+                        Models.Geometry.Rectangle rectRenderedImage;
+                        if (Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses().Any(w => w.ClassName == nativeWindow.ClassName))
+                        {
+                            // TODO: remove this Octane Render specific code
+                            rectRenderedImage = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);
                         }
-                    default: // TODO: check is Octane Render!
-                        //case Models.AppInterop.OctaneRender.OctaneRenderWindow.MainWindowClassName:
+                        else
+                        {
+                            rectRenderedImage = 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);
+                    }).ContinueWith((t) =>
+                    {
+                        var rectRenderedImage = t.Result.Item1;
+                        var windowLocation = t.Result.Item2;
+                        if (!rectRenderedImage.IsEmpty)
                         {
-                            Task.Factory.StartNew<Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>>(() =>
-                            {
-                                var octaneWindow = new Models.AppsInterop.OctaneRenderWindow(window.Handle);
-                                var bitmap = octaneWindow.GetShot();
-                                var flatImage = new Models.FlatImage(bitmap);
-                                var rectRenderedImage = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);
-                                var octaneWindowLocation = new Models.Geometry.Point(octaneWindow.Location.X, octaneWindow.Location.Y);
-                                return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(rectRenderedImage, octaneWindowLocation);
-                            }).ContinueWith((t) =>
-                            {
-                                var rectRenderedImage = t.Result.Item1;
-                                var octaneWindowLocation = t.Result.Item2;
-                                if (!rectRenderedImage.IsEmpty)
-                                {
-                                    this.PositionWindow(t.Result.Item2, t.Result.Item1);
-                                }
-                            },
-                            TaskScheduler.FromCurrentSynchronizationContext());
-
-                            break;
+                            this.PositionWindow(t.Result.Item2, t.Result.Item1);
                         }
-                    //default:
-                    //{
-                    //    throw new NotSupportedException(window.ClassName);
-                    //}
+                    },
+                    TaskScheduler.FromCurrentSynchronizationContext());
                 }
             }
         }
 
         private void PositionWindow(Models.Geometry.Point parentLocation, Models.Geometry.Rectangle rectRenderedImage)
         {
             var diffX = 0.0;
-            var diffY = HeaderHeight; 
+            var diffY = HeaderHeight;
             // TODO: remove magiс numbers
             this.WindowLeft = rectRenderedImage.Left + parentLocation.X - diffX - 1;
             this.WindowTop = rectRenderedImage.Top + parentLocation.Y - diffY - 1;