switched to new way

src/Poe2Trade.Screen/DetectGridHandler.cs

@@ -0,0 +1,157 @@
+namespace Poe2Trade.Screen;
+
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
+using Serilog;
+using Region = Poe2Trade.Core.Region;
+
+class DetectGridHandler
+{
+    public DetectGridResult Detect(Region region, int minCellSize = 20, int maxCellSize = 70,
+        string? file = null, bool debug = false)
+    {
+        Bitmap bitmap = ScreenCapture.CaptureOrLoad(file, region);
+        int w = bitmap.Width;
+        int h = bitmap.Height;
+
+        var bmpData = bitmap.LockBits(
+            new Rectangle(0, 0, w, h),
+            ImageLockMode.ReadOnly,
+            PixelFormat.Format32bppArgb
+        );
+        byte[] pixels = new byte[bmpData.Stride * h];
+        Marshal.Copy(bmpData.Scan0, pixels, 0, pixels.Length);
+        bitmap.UnlockBits(bmpData);
+        int stride = bmpData.Stride;
+
+        byte[] gray = new byte[w * h];
+        for (int y = 0; y < h; y++)
+            for (int x = 0; x < w; x++)
+            {
+                int i = y * stride + x * 4;
+                gray[y * w + x] = (byte)((pixels[i] + pixels[i + 1] + pixels[i + 2]) / 3);
+            }
+
+        bitmap.Dispose();
+
+        int bandH = 200;
+        int bandStep = 40;
+        const int veryDarkPixelThresh = 12;
+        const double gridSegThresh = 0.25;
+
+        var candidates = new List<(int bandY, int cellW, double hAc, int hLeft, int hRight)>();
+
+        for (int by = 0; by + bandH <= h; by += bandStep)
+        {
+            double[] darkDensity = new double[w];
+            for (int x = 0; x < w; x++)
+            {
+                int count = 0;
+                for (int y = by; y < by + bandH; y++)
+                {
+                    if (gray[y * w + x] < veryDarkPixelThresh) count++;
+                }
+                darkDensity[x] = (double)count / bandH;
+            }
+
+            var gridSegs = SignalProcessing.FindDarkDensitySegments(darkDensity, gridSegThresh, 200);
+
+            foreach (var (segLeft, segRight) in gridSegs)
+            {
+                int segLen = segRight - segLeft;
+                double[] segment = new double[segLen];
+                Array.Copy(darkDensity, segLeft, segment, 0, segLen);
+
+                var (period, acScore) = SignalProcessing.FindPeriodWithScore(segment, minCellSize, maxCellSize);
+                if (period <= 0) continue;
+
+                var (extLeft, extRight) = SignalProcessing.FindGridExtent(segment, period);
+                if (extLeft < 0) continue;
+
+                int absLeft = segLeft + extLeft;
+                int absRight = segLeft + extRight;
+                int extent = absRight - absLeft;
+
+                if (extent < period * 8 || extent < 200) continue;
+
+                candidates.Add((by, period, acScore, absLeft, absRight));
+            }
+        }
+
+        candidates.Sort((a, b) =>
+        {
+            double sa = a.hAc * (a.hRight - a.hLeft);
+            double sb = b.hAc * (b.hRight - b.hLeft);
+            return sb.CompareTo(sa);
+        });
+
+        // Pass 2: Verify vertical periodicity
+        foreach (var cand in candidates.Take(10))
+        {
+            int colSpan = cand.hRight - cand.hLeft;
+            if (colSpan < cand.cellW * 3) continue;
+
+            double[] rowDensity = new double[h];
+            for (int y = 0; y < h; y++)
+            {
+                int count = 0;
+                for (int x = cand.hLeft; x < cand.hRight; x++)
+                {
+                    if (gray[y * w + x] < veryDarkPixelThresh) count++;
+                }
+                rowDensity[y] = (double)count / colSpan;
+            }
+
+            var vGridSegs = SignalProcessing.FindDarkDensitySegments(rowDensity, gridSegThresh, 100);
+            if (vGridSegs.Count == 0) continue;
+
+            var (vSegTop, vSegBottom) = vGridSegs.OrderByDescending(s => s.end - s.start).First();
+            int vSegLen = vSegBottom - vSegTop;
+            double[] vSegment = new double[vSegLen];
+            Array.Copy(rowDensity, vSegTop, vSegment, 0, vSegLen);
+
+            var (cellH, vAc) = SignalProcessing.FindPeriodWithScore(vSegment, minCellSize, maxCellSize);
+            if (cellH <= 0) continue;
+
+            var (extTop, extBottom) = SignalProcessing.FindGridExtent(vSegment, cellH);
+            if (extTop < 0) continue;
+
+            int top = vSegTop + extTop;
+            int bottom = vSegTop + extBottom;
+            int vExtent = bottom - top;
+
+            if (vExtent < cellH * 3 || vExtent < 100) continue;
+
+            int gridW = cand.hRight - cand.hLeft;
+            int gridH = bottom - top;
+            int cols = Math.Max(2, (int)Math.Round((double)gridW / cand.cellW));
+            int rows = Math.Max(2, (int)Math.Round((double)gridH / cellH));
+
+            gridW = cols * cand.cellW;
+            gridH = rows * cellH;
+
+            return new DetectGridResult
+            {
+                Detected = true,
+                Region = new Region(region.X + cand.hLeft, region.Y + top, gridW, gridH),
+                Cols = cols,
+                Rows = rows,
+                CellWidth = Math.Round((double)gridW / cols, 1),
+                CellHeight = Math.Round((double)gridH / rows, 1),
+            };
+        }
+
+        return new DetectGridResult { Detected = false };
+    }
+}
+
+public class DetectGridResult
+{
+    public bool Detected { get; set; }
+    public Region? Region { get; set; }
+    public int Cols { get; set; }
+    public int Rows { get; set; }
+    public double CellWidth { get; set; }
+    public double CellHeight { get; set; }
+}