feat: angle_step auto adattivo a dimensione template

Halcon-style: angle_step_deg=0 attiva derivazione automatica
step = atan(2/max_side) deg, clampato [0.5, 10]. Template grande
ottiene step fine, piccolo step grosso. auto_tune emette il valore
calcolato direttamente.

_refine_angle ora usa _effective_angle_step() per coerenza con
training quando la modalita auto e attiva.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

pm2d/_jit_kernels.py

@@ -110,63 +110,6 @@ if HAS_NUMBA:
                     acc[y, x] *= inv
         return acc
 
-    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
-    def _jit_score_bitmap_rescored_strided(
-        spread: np.ndarray,
-        dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
-        bit_active: np.uint8,
-        bg: np.ndarray,
-        stride: nb.int32,
-    ) -> np.ndarray:
-        """Variante con sub-sampling: valuta solo pixel su griglia stride×stride.
-        Score restituito ha stessa shape (H, W); celle non valutate = 0.
-
-        4× speed-up con stride=2 (NMS recupera precisione in full-res).
-        Numba prange richiede step costante: itero su indici griglia e
-        moltiplico per stride dentro il body.
-        """
-        H, W = spread.shape
-        N = dx.shape[0]
-        acc = np.zeros((H, W), dtype=np.float32)
-        ny = (H + stride - 1) // stride
-        nx = (W + stride - 1) // stride
-        for yi in nb.prange(ny):
-            y = yi * stride
-            for i in range(N):
-                b = bins[i]
-                mask = np.uint8(1) << b
-                if (bit_active & mask) == 0:
-                    continue
-                ddy = dy[i]
-                yy = y + ddy
-                if yy < 0 or yy >= H:
-                    continue
-                ddx = dx[i]
-                x_lo = 0 if ddx >= 0 else -ddx
-                x_hi = W if ddx <= 0 else W - ddx
-                rem = x_lo % stride
-                if rem != 0:
-                    x_lo += stride - rem
-                x = x_lo
-                while x < x_hi:
-                    if spread[yy, x + ddx] & mask:
-                        acc[y, x] += 1.0
-                    x += stride
-        if N > 0:
-            inv = 1.0 / N
-            for yi in nb.prange(ny):
-                y = yi * stride
-                for xi in range(nx):
-                    x = xi * stride
-                    v = acc[y, x] * inv
-                    bgv = bg[y, x]
-                    if bgv < 1.0:
-                        r = (v - bgv) / (1.0 - bgv + 1e-6)
-                        acc[y, x] = r if r > 0.0 else 0.0
-                    else:
-                        acc[y, x] = 0.0
-        return acc
-
     @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
     def _jit_score_bitmap_rescored(
         spread: np.ndarray,      # uint8 (H, W)
@@ -242,9 +185,6 @@ if HAS_NUMBA:
         _jit_score_bitmap(spread, dx, dy, b, np.uint8(0xFF))
         bg = np.zeros((32, 32), dtype=np.float32)
         _jit_score_bitmap_rescored(spread, dx, dy, b, np.uint8(0xFF), bg)
-        _jit_score_bitmap_rescored_strided(
-            spread, dx, dy, b, np.uint8(0xFF), bg, np.int32(2),
-        )
         _jit_popcount_density(spread)
 
 else:  # pragma: no cover
@@ -258,9 +198,6 @@ else:  # pragma: no cover
     def _jit_score_bitmap_rescored(spread, dx, dy, bins, bit_active, bg):
         raise RuntimeError("numba non disponibile")
 
-    def _jit_score_bitmap_rescored_strided(spread, dx, dy, bins, bit_active, bg, stride):
-        raise RuntimeError("numba non disponibile")
-
     def _jit_popcount_density(spread):
         raise RuntimeError("numba non disponibile")
 
@@ -291,29 +228,19 @@ def score_bitmap(
 
 def score_bitmap_rescored(
     spread: np.ndarray, dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
-    bit_active: int, bg: np.ndarray, stride: int = 1,
+    bit_active: int, bg: np.ndarray,
 ) -> np.ndarray:
-    """Score bitmap + rescore fusi in un solo pass (JIT).
+    """Score bitmap + rescore fusi in un solo pass (JIT)."""
-
-    stride > 1: valuta solo pixel su griglia stride×stride. Le celle non
-    valutate restano 0 nello score map. Pensato per coarse-pass al top
-    della piramide; il refinement full-res poi recupera precisione.
-    """
     if HAS_NUMBA and len(dx) > 0:
-        spread_c = np.ascontiguousarray(spread, dtype=np.uint8)
-        dx_c = np.ascontiguousarray(dx, dtype=np.int32)
-        dy_c = np.ascontiguousarray(dy, dtype=np.int32)
-        bins_c = np.ascontiguousarray(bins, dtype=np.int8)
-        bg_c = np.ascontiguousarray(bg, dtype=np.float32)
-        if stride > 1:
-            return _jit_score_bitmap_rescored_strided(
-                spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
-                np.int32(stride),
-            )
         return _jit_score_bitmap_rescored(
-            spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
+            np.ascontiguousarray(spread, dtype=np.uint8),
+            np.ascontiguousarray(dx, dtype=np.int32),
+            np.ascontiguousarray(dy, dtype=np.int32),
+            np.ascontiguousarray(bins, dtype=np.int8),
+            np.uint8(bit_active),
+            np.ascontiguousarray(bg, dtype=np.float32),
         )
-    # Fallback: chiamate separate (stride ignorato in fallback)
+    # Fallback: chiamate separate
     score = score_bitmap(spread, dx, dy, bins, bit_active)
     out = (score - bg) / (1.0 - bg + 1e-6)
     return np.maximum(0.0, out).astype(np.float32)

pm2d/auto_tune.py

@@ -220,8 +220,11 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     else:
         min_score = 0.45
 
-    # angle step: 5° default; se simmetria, mantengo step ma range ridotto
+    # angle step adattivo (Halcon-style): atan(2/max_side) deg, clampato.
-    angle_step = 5.0
+    # Template grande → step fine (rotazione minima visibile su perimetro).
+    # Template piccolo → step grosso (over-sampling = sprecato).
+    max_side = max(h, w)
+    angle_step = float(np.clip(np.degrees(np.arctan2(2.0, max_side)), 1.0, 8.0))
 
     result = {
         "backend": "line",

pm2d/line_matcher.py

@@ -197,12 +197,31 @@ class LineShapeMatcher:
         n = int(np.floor((s1 - s0) / self.scale_step)) + 1
         return [float(s0 + i * self.scale_step) for i in range(n)]
 
+    def _auto_angle_step(self) -> float:
+        """Step angolare derivato da dimensione template (Halcon-style).
+
+        Formula: step ≈ atan(2 / max_side) gradi. Garantisce che la
+        rotazione minima produca uno spostamento di ≥2 px sul perimetro
+        del template (sotto sample il matching coarse perde candidati).
+        Clampato in [0.5°, 10°].
+        """
+        max_side = max(self.template_size) if self.template_size != (0, 0) else 64
+        step = math.degrees(math.atan2(2.0, float(max_side)))
+        return float(np.clip(step, 0.5, 10.0))
+
+    def _effective_angle_step(self) -> float:
+        """Risolve angle_step_deg gestendo modalità auto (<=0)."""
+        if self.angle_step_deg <= 0:
+            return self._auto_angle_step()
+        return self.angle_step_deg
+
     def _angle_list(self) -> list[float]:
         a0, a1 = self.angle_range_deg
-        if self.angle_step_deg <= 0 or a0 >= a1:
+        step = self._effective_angle_step()
+        if step <= 0 or a0 >= a1:
             return [float(a0)]
-        n = int(np.floor((a1 - a0) / self.angle_step_deg))
+        n = int(np.floor((a1 - a0) / step))
-        return [float(a0 + i * self.angle_step_deg) for i in range(n)]
+        return [float(a0 + i * step) for i in range(n)]
 
     # --- Training ------------------------------------------------------
 
@@ -415,7 +434,7 @@ class LineShapeMatcher:
         if original_score is not None and original_score >= 0.99:
             return (angle_deg, original_score, cx, cy)
         if search_radius is None:
-            search_radius = self.angle_step_deg / 2.0
+            search_radius = self._effective_angle_step() / 2.0
 
         h, w = template_gray.shape
         sw = max(16, int(round(w * scale)))
@@ -573,7 +592,6 @@ class LineShapeMatcher:
         verify_ncc: bool = True,
         verify_threshold: float = 0.4,
         coarse_angle_factor: int = 2,
-        coarse_stride: int = 1,
         scale_penalty: float = 0.0,
     ) -> list[Match]:
         """
@@ -646,16 +664,13 @@ class LineShapeMatcher:
                 end = min(n, i + half + 1)
                 neighbor_map[vi_c] = vi_sorted[start:end]
 
-        # Pruning varianti via top-level (parallelizzato) - solo coarse.
+        # Pruning varianti via top-level (parallelizzato) - solo coarse
-        # coarse_stride > 1: valuta solo 1 pixel ogni stride, ~stride² speed-up.
-        cs = max(1, int(coarse_stride))
-
         def _top_score(vi: int) -> tuple[int, float]:
             var = self.variants[vi]
             lvl = var.levels[min(top, len(var.levels) - 1)]
             score = _jit_score_bitmap_rescored(
                 spread_top, lvl.dx, lvl.dy, lvl.bin, bit_active_top,
-                bg_cache_top[var.scale], stride=cs,
+                bg_cache_top[var.scale],
             )
             return vi, float(score.max()) if score.size else -1.0
 
@@ -806,7 +821,7 @@ class LineShapeMatcher:
                 ang_f, score_f, cx_f, cy_f = self._refine_angle(
                     spread0, bit_active_full, self.template_gray, cx_f, cy_f,
                     var.angle_deg, var.scale, mask_full,
-                    search_radius=self.angle_step_deg / 2.0,
+                    search_radius=self._effective_angle_step() / 2.0,
                     original_score=score,
                 )
             if verify_ncc: