work on color tracker

src/Poe2Trade.Navigation/WallColorTracker.cs

@@ -0,0 +1,148 @@
+using OpenCvSharp;
+using Serilog;
+
+namespace Poe2Trade.Navigation;
+
+/// <summary>
+/// Tracks HSV distribution of confirmed wall pixels and computes an adaptive
+/// detection range that narrows per-map from the broad default.
+/// </summary>
+internal class WallColorTracker
+{
+    private readonly Scalar _defaultLo;
+    private readonly Scalar _defaultHi;
+
+    // Cumulative histograms (committed samples only)
+    private readonly long[] _hHist = new long[180];
+    private readonly long[] _sHist = new long[256];
+    private readonly long[] _vHist = new long[256];
+    private long _totalSamples;
+
+    // Pending samples from the latest frame (not yet committed)
+    private readonly int[] _pendH = new int[180];
+    private readonly int[] _pendS = new int[256];
+    private readonly int[] _pendV = new int[256];
+    private int _pendCount;
+
+    private const int MinSamples = 3000;
+    private const double LoPercentile = 0.05;
+    private const double HiPercentile = 0.95;
+    private const int HPad = 5;
+    private const int SPad = 15;
+    private const int VPad = 10;
+
+    public Scalar? AdaptedLo { get; private set; }
+    public Scalar? AdaptedHi { get; private set; }
+
+    public WallColorTracker(Scalar defaultLo, Scalar defaultHi)
+    {
+        _defaultLo = defaultLo;
+        _defaultHi = defaultHi;
+    }
+
+    /// <summary>
+    /// Sample wall pixel HSV values from the current frame into pending buffers.
+    /// Must be called with the pre-dilation wall mask (only pure color-selected pixels).
+    /// Does NOT commit — call <see cref="Commit"/> only after WorldMap confirms the match.
+    /// </summary>
+    public void SampleFrame(Mat hsv, Mat preDilationMask)
+    {
+        Array.Clear(_pendH);
+        Array.Clear(_pendS);
+        Array.Clear(_pendV);
+        _pendCount = 0;
+
+        // Downsample: every 4th pixel in each direction (~10K samples for 400x400)
+        for (var r = 0; r < hsv.Rows; r += 4)
+        for (var c = 0; c < hsv.Cols; c += 4)
+        {
+            if (preDilationMask.At<byte>(r, c) == 0) continue;
+            var px = hsv.At<Vec3b>(r, c);
+            _pendH[px.Item0]++;
+            _pendS[px.Item1]++;
+            _pendV[px.Item2]++;
+            _pendCount++;
+        }
+    }
+
+    /// <summary>
+    /// Commit pending samples into the cumulative histogram.
+    /// Call only after WorldMap confirms a successful template match.
+    /// </summary>
+    public void Commit()
+    {
+        if (_pendCount == 0) return;
+
+        for (var i = 0; i < 180; i++) _hHist[i] += _pendH[i];
+        for (var i = 0; i < 256; i++) _sHist[i] += _pendS[i];
+        for (var i = 0; i < 256; i++) _vHist[i] += _pendV[i];
+        _totalSamples += _pendCount;
+
+        if (_totalSamples >= MinSamples)
+            Recompute();
+    }
+
+    private void Recompute()
+    {
+        var hLo = Percentile(_hHist, 180, LoPercentile);
+        var hHi = Percentile(_hHist, 180, HiPercentile);
+        var sLo = Percentile(_sHist, 256, LoPercentile);
+        var sHi = Percentile(_sHist, 256, HiPercentile);
+        var vLo = Percentile(_vHist, 256, LoPercentile);
+        var vHi = Percentile(_vHist, 256, HiPercentile);
+
+        // Clamp to default bounds — adaptation can only narrow, never broaden
+        var newLo = new Scalar(
+            Math.Max(_defaultLo.Val0, hLo - HPad),
+            Math.Max(_defaultLo.Val1, sLo - SPad),
+            Math.Max(_defaultLo.Val2, vLo - VPad));
+        var newHi = new Scalar(
+            Math.Min(_defaultHi.Val0, hHi + HPad),
+            Math.Min(_defaultHi.Val1, sHi + SPad),
+            Math.Min(_defaultHi.Val2, vHi + VPad));
+
+        // Safety: if any channel inverted (lo > hi), fall back to default for that channel
+        if (newLo.Val0 > newHi.Val0) { newLo.Val0 = _defaultLo.Val0; newHi.Val0 = _defaultHi.Val0; }
+        if (newLo.Val1 > newHi.Val1) { newLo.Val1 = _defaultLo.Val1; newHi.Val1 = _defaultHi.Val1; }
+        if (newLo.Val2 > newHi.Val2) { newLo.Val2 = _defaultLo.Val2; newHi.Val2 = _defaultHi.Val2; }
+
+        // Only log when the range actually changes
+        if (AdaptedLo == null || AdaptedHi == null ||
+            AdaptedLo.Value.Val0 != newLo.Val0 || AdaptedLo.Value.Val1 != newLo.Val1 ||
+            AdaptedHi.Value.Val0 != newHi.Val0 || AdaptedHi.Value.Val1 != newHi.Val1)
+        {
+            Log.Information(
+                "Wall color adapted: H({HLo}-{HHi}) S({SLo}-{SHi}) V({VLo}-{VHi}) from {Samples} samples",
+                newLo.Val0, newHi.Val0, newLo.Val1, newHi.Val1, newLo.Val2, newHi.Val2, _totalSamples);
+        }
+
+        AdaptedLo = newLo;
+        AdaptedHi = newHi;
+    }
+
+    private int Percentile(long[] hist, int size, double p)
+    {
+        var target = (long)(_totalSamples * p);
+        long cum = 0;
+        for (var i = 0; i < size; i++)
+        {
+            cum += hist[i];
+            if (cum >= target) return i;
+        }
+        return size - 1;
+    }
+
+    public void Reset()
+    {
+        Array.Clear(_hHist);
+        Array.Clear(_sHist);
+        Array.Clear(_vHist);
+        _totalSamples = 0;
+        Array.Clear(_pendH);
+        Array.Clear(_pendS);
+        Array.Clear(_pendV);
+        _pendCount = 0;
+        AdaptedLo = null;
+        AdaptedHi = null;
+    }
+}