Get single frames and tests

Author: ErikSchutte

.editorconfig

@@ -1,4 +1,3 @@
-# Keep comments human: explain the “why”, not just the “what”.
 root = true
 
 [*.{cs,csx}]
@@ -20,11 +19,18 @@ dotnet_analyzer_diagnostic.category-Design.severity = warning
 dotnet_analyzer_diagnostic.category-Reliability.severity = warning
 dotnet_analyzer_diagnostic.category-Security.severity = warning
 
-# Naming (basic, we’ll refine later)
+# Naming 
 dotnet_naming_rule.private_fields_underscore.symbols = private_fields
 dotnet_naming_rule.private_fields_underscore.style = underscore_prefix
 dotnet_naming_rule.private_fields_underscore.severity = suggestion
 dotnet_naming_symbols.private_fields.applicable_kinds = field
 dotnet_naming_symbols.private_fields.applicable_accessibilities = private
 dotnet_naming_style.underscore_prefix.required_prefix = _
 dotnet_naming_style.underscore_prefix.capitalization = camel_case
+
+# StyleCop rules (mostly disabled for initial simplicity)
+dotnet_diagnostic.SA1633.severity = none   # file header
+dotnet_diagnostic.SA1200.severity = none   # usings inside namespace
+dotnet_diagnostic.SA1518.severity = suggestion  # newline at EOF
+dotnet_diagnostic.SA1502.severity = suggestion  # one-line elements
+dotnet_diagnostic.SA1503.severity = suggestion  # omitted braces

Directory.Packages.props

@@ -11,9 +11,7 @@
     <!-- Test & tooling -->
     <PackageVersion Include="xunit" Version="2.9.0" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
-    <PackageVersion Include="FluentAssertions" Version="6.12.0" />
     <PackageVersion Include="coverlet.collector" Version="6.0.0" />
-    <PackageVersion Include="FsCheck.Xunit" Version="2.16.6" />
 
     <!-- App & Vision deps -->
     <PackageVersion Include="Serilog.Sinks.Console" Version="5.0.1" />

src/ScreenAutomation.Core/Abstractions/IDetectionPipeline.cs

@@ -1,6 +1,9 @@
-namespace ScreenAutomation.Core.Abstractions;
-
-public interface IDetectionPipeline
+namespace ScreenAutomation.Core.Abstractions
 {
-    IEnumerable<object> Run(ImageBuffer image);
+    using System.Collections.Generic;
+
+    public interface IDetectionPipeline<TAspect>
+    {
+        IReadOnlyList<Detection<TAspect>> Run(ImageBuffer image);
+    }
 }

src/ScreenAutomation.Core/Abstractions/IScreenCapture.cs

@@ -1,6 +1,10 @@
-namespace ScreenAutomation.Core.Abstractions;
-
-public interface IScreenCapture
+namespace ScreenAutomation.Core.Abstractions
 {
-    ImageBuffer Capture();
+    using System.Collections.Generic;
+
+    // Orchestrates one capture → run the detection pipeline → return detections.
+    public interface ICaptureRunner<TAspect>
+    {
+        IReadOnlyList<Detection<TAspect>> RunOnce();
+    }
 }

src/ScreenAutomation.Vision/Detectors/TemplateMatchDetector.cs

@@ -1,57 +1,50 @@
-using OpenCvSharp;
-using ScreenAutomation.Core;
-using ScreenAutomation.Core.Abstractions;
-using ScreenAutomation.Vision.Extensions;
-
-namespace ScreenAutomation.Vision.Detectors;
-
-
-// Extremely simple template matcher using OpenCV's MatchTemplate (CCoeffNormed).
-// This is a baseline to prove the pipeline & test rig; we will harden it over time.
-public sealed class TemplateMatchDetector : IAspectDetector<BoundingBox>, IDisposable
+namespace ScreenAutomation.Vision.Detectors
 {
-    private readonly Mat _template;     // CV_8UC1
-    private readonly int _tw;
-    private readonly int _th;
-
-    /// <param name="template">Grayscale template pixels (Width*Height == Pixels.Length).</param>
-    public TemplateMatchDetector(ImageBuffer template)
+    using System;
+    using OpenCvSharp;
+    using ScreenAutomation.Core;
+    using ScreenAutomation.Core.Abstractions;
+    using ScreenAutomation.Vision.Extensions;
+
+    // Minimal template matcher (CCoeffNormed). Baseline slice to exercise the pipeline.
+    public sealed class TemplateMatchDetector : IAspectDetector<BoundingBox>, IDisposable
     {
-        _template = template.ToGrayMat(); // wraps the array; we keep it alive in this class
-        _tw = template.Width;
-        _th = template.Height;
-    }
-
-
-    // Perform normalized template matching against the given scene (grayscale).
-    public Detection<BoundingBox> Detect(ImageBuffer image)
-    {
-        using var scene = image.ToGrayMat();
-
-        // result map size = (scene - template + 1)
-        var resW = scene.Cols - _tw + 1;
-        var resH = scene.Rows - _th + 1;
+        private readonly Mat templateMat;   // CV_8UC1
+        private readonly int tw;
+        private readonly int th;
 
-        if (resW <= 0 || resH <= 0)
+        public TemplateMatchDetector(ImageBuffer template)
         {
-            // Template can't fit → trivially "no match"
-            var degenerate = new BoundingBox(0, 0, _tw, _th);
-            return new Detection<BoundingBox>(degenerate, degenerate, 0f);
+            this.templateMat = template.ToGrayMat();
+            this.tw = template.Width;
+            this.th = template.Height;
         }
 
-        using var result = new Mat(resH, resW, MatType.CV_32FC1);
+        public Detection<BoundingBox> Detect(ImageBuffer image)
+        {
+            using var scene = image.ToGrayMat();
 
-        // Use CCoeffNormed which tends to be robust for simple luminance changes.
-        Cv2.MatchTemplate(scene, _template, result, TemplateMatchModes.CCoeffNormed);
+            var resW = scene.Cols - this.tw + 1;
+            var resH = scene.Rows - this.th + 1;
 
-        Cv2.MinMaxLoc(result, out _, out double maxVal, out _, out Point maxLoc);
+            if (resW <= 0 || resH <= 0)
+            {
+                var box = new BoundingBox(0, 0, this.tw, this.th);
+                return new Detection<BoundingBox>(box, box, 0f);
+            }
 
-        var box = new BoundingBox(maxLoc.X, maxLoc.Y, _tw, _th);
-        return new Detection<BoundingBox>(box, box, (float)maxVal);
-    }
+            using var result = new Mat(resH, resW, MatType.CV_32FC1);
 
-    public void Dispose()
-    {
-        _template?.Dispose();
+            Cv2.MatchTemplate(scene, this.templateMat, result, TemplateMatchModes.CCoeffNormed);
+            Cv2.MinMaxLoc(result, out _, out double maxVal, out _, out Point maxLoc);
+
+            var detected = new BoundingBox(maxLoc.X, maxLoc.Y, this.tw, this.th);
+            return new Detection<BoundingBox>(detected, detected, (float)maxVal);
+        }
+
+        public void Dispose()
+        {
+            this.templateMat?.Dispose();
+        }
     }
 }

src/ScreenAutomation.Vision/Extensions/ImageBufferExtensions.cs

@@ -1,38 +1,41 @@
-using OpenCvSharp;
-using ScreenAutomation.Core;
-
-namespace ScreenAutomation.Vision.Extensions;
-
-
-// Helpers to convert between Core's ImageBuffer (library-agnostic) and OpenCvSharp Mat.
-// We keep things grayscale-only for now to keep the minimal slice simple.
-public static class ImageBufferExtensions
+namespace ScreenAutomation.Vision.Extensions
 {
-    // Wrap an ImageBuffer (grayscale) in an OpenCV Mat (CV_8UC1). No deep copy is performed.
+    using System;
+    using System.Runtime.InteropServices;
+    using OpenCvSharp;
+    using ScreenAutomation.Core;
 
-    public static Mat ToGrayMat(this ImageBuffer buffer)
+    // Converts between Core's ImageBuffer and OpenCvSharp Mat (grayscale only for now).
+    public static class ImageBufferExtensions
     {
-        // Mat uses the provided memory; ensure the buffer stays alive for the Mat's lifetime.
-        return new Mat(buffer.Height, buffer.Width, MatType.CV_8UC1, buffer.Pixels);
-    }
+        // Copy ImageBuffer (8-bit grayscale) into a new Mat (CV_8UC1).
+        public static Mat ToGrayMat(this ImageBuffer buffer)
+        {
+            if (buffer.Pixels is null)
+                throw new ArgumentNullException(nameof(buffer.Pixels));
 
+            var mat = new Mat(buffer.Height, buffer.Width, MatType.CV_8UC1);
+            var length = buffer.Pixels.Length;
 
-    // Copy an OpenCV grayscale Mat (CV_8UC1) into an ImageBuffer (managed).
-    public static ImageBuffer FromGrayMat(Mat mat)
-    {
-        if (mat.Type() != MatType.CV_8UC1)
-        {
-            throw new ArgumentException($"Expected CV_8UC1 mat, got {mat.Type()}");
+            // Copy managed bytes -> unmanaged Mat buffer
+            Marshal.Copy(buffer.Pixels, 0, mat.Data, length);
+            return mat;
         }
 
-        var w = mat.Cols;
-        var h = mat.Rows;
-        var total = w * h;
-        var pixels = new byte[total];
+        // Copy an OpenCV grayscale Mat (CV_8UC1) into an ImageBuffer (managed).
+        public static ImageBuffer FromGrayMat(Mat mat)
+        {
+            if (mat.Type() != MatType.CV_8UC1)
+                throw new ArgumentException($"Expected CV_8UC1 mat, got {mat.Type()}");
 
-        // GetArray performs a copy from Mat into managed memory.
-        mat.GetArray(0, 0, pixels);
+            var width = mat.Cols;
+            var height = mat.Rows;
+            var pixels = new byte[width * height];
 
-        return new ImageBuffer(w, h, pixels);
+            // Copy unmanaged Mat buffer -> managed bytes
+            Marshal.Copy(mat.Data, pixels, 0, pixels.Length);
+
+            return new ImageBuffer(width, height, pixels);
+        }
     }
 }

src/ScreenAutomation.Vision/Pipeline/DetectionPipeline.cs

@@ -0,0 +1,29 @@
+namespace ScreenAutomation.Vision.Pipeline
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using ScreenAutomation.Core;
+    using ScreenAutomation.Core.Abstractions;
+
+    // Simple pipeline: runs each detector and returns all detections.
+    public sealed class DetectionPipeline<TAspect> : IDetectionPipeline<TAspect>
+    {
+        private readonly IReadOnlyList<IAspectDetector<TAspect>> detectors;
+
+        public DetectionPipeline(IEnumerable<IAspectDetector<TAspect>> detectors)
+        {
+            this.detectors = detectors?.ToList() ?? new List<IAspectDetector<TAspect>>();
+        }
+
+        public IReadOnlyList<Detection<TAspect>> Run(ImageBuffer image)
+        {
+            var results = new List<Detection<TAspect>>(this.detectors.Count);
+            foreach (var d in this.detectors)
+            {
+                results.Add(d.Detect(image));
+            }
+
+            return results;
+        }
+    }
+}

src/ScreenAutomation.Vision/Placeholder.cs

@@ -0,0 +1 @@
+namespace ScreenAutomation.Vision { internal static class Placeholder { } }

src/ScreenAutomation.Vision/Runtime/CaptureRunner.cs

@@ -0,0 +1,25 @@
+namespace ScreenAutomation.Vision.Runtime
+{
+    using System.Collections.Generic;
+    using ScreenAutomation.Core;
+    using ScreenAutomation.Core.Abstractions;
+
+    // Single-responsibility: grab one frame from IScreenCapture and pass it to the pipeline.
+    public sealed class CaptureRunner<TAspect> : ICaptureRunner<TAspect>
+    {
+        private readonly IScreenCapture capture;
+        private readonly IDetectionPipeline<TAspect> pipeline;
+
+        public CaptureRunner(IScreenCapture capture, IDetectionPipeline<TAspect> pipeline)
+        {
+            this.capture = capture;
+            this.pipeline = pipeline;
+        }
+
+        public IReadOnlyList<Detection<TAspect>> RunOnce()
+        {
+            var frame = this.capture.Capture();
+            return this.pipeline.Run(frame);
+        }
+    }
+}