feat: add_template_view - multi-template ensemble (Halcon-style)

Aggiunge una view extra al matcher gia addestrato. Le varianti
della nuova view vengono APPENDATE a self.variants col tag view_idx
e partecipano al pruning/matching come le altre.

NCC verify usa il template della view che ha matchato (via
_get_view_template + parametro view_idx propagato a _verify_ncc).

Halcon-equivalent: create_aniso_shape_model con fusione N viste.
Use case: pezzo che cambia aspetto (chiaro/scuro, prima/dopo
trattamento, illuminazioni diverse) → un solo matcher robusto
invece di N matcher distinti.

API:
    m.train(template_chiaro)
    m.add_template_view(template_scuro)
    m.find(scene)  # match su entrambi gli aspetti

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

pm2d/_jit_kernels.py

@@ -328,6 +328,65 @@ if HAS_NUMBA:
             out[vi] = best if best > 0.0 else 0.0
         return out
 
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored_u16(
+        spread: np.ndarray,      # uint16 (H, W) - 16 bit di polarity-aware
+        dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+        bit_active: np.uint16,
+        bg: np.ndarray,
+    ) -> np.ndarray:
+        """Versione uint16 di _jit_score_bitmap_rescored per polarity 16-bin.
+
+        Identica logica ma mask = uint16(1) << b dove b in [0..15]
+        (orientamento mod 2π invece di mod π).
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint16(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
+                for x in range(x_lo, x_hi):
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+        if N > 0:
+            inv = 1.0 / N
+            for y in nb.prange(H):
+                for x in range(W):
+                    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_popcount_density_u16(spread: np.ndarray) -> np.ndarray:
+        """Popcount per uint16 (16 bin polarity)."""
+        H, W = spread.shape
+        out = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for x in range(W):
+                v = spread[y, x]
+                cnt = 0
+                for b in range(16):
+                    if v & (np.uint16(1) << b):
+                        cnt += 1
+                out[y, x] = float(cnt)
+        return out
+
     @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
     def _jit_popcount_density(spread: np.ndarray) -> np.ndarray:
         """Conta bit set per pixel: ritorna (H, W) float32 in [0..8]."""
@@ -368,6 +427,11 @@ if HAS_NUMBA:
             spread, dx, dy, b, offsets, np.uint8(0xFF), bg_pv, scale_idx,
         )
         _jit_popcount_density(spread)
+        spread16 = np.zeros((32, 32), dtype=np.uint16)
+        _jit_score_bitmap_rescored_u16(
+            spread16, dx, dy, b, np.uint16(0xFFFF), bg,
+        )
+        _jit_popcount_density_u16(spread16)
 
 else:  # pragma: no cover
 
@@ -392,6 +456,12 @@ else:  # pragma: no cover
     ):
         raise RuntimeError("numba non disponibile")
 
+    def _jit_score_bitmap_rescored_u16(spread, dx, dy, bins, bit_active, bg):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_popcount_density_u16(spread):
+        raise RuntimeError("numba non disponibile")
+
     def _jit_popcount_density(spread):
         raise RuntimeError("numba non disponibile")
 
@@ -426,16 +496,20 @@ def score_bitmap_rescored(
 ) -> np.ndarray:
     """Score bitmap + rescore fusi in un solo pass (JIT).
 
-    stride > 1: valuta solo pixel su griglia stride×stride. Le celle non
+    Dispatch per dtype: uint16 → kernel polarity 16-bin, uint8 → kernel
-    valutate restano 0 nello score map. Pensato per coarse-pass al top
+    standard 8-bin (con eventuale stride > 1 per coarse top-level).
-    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 spread.dtype == np.uint16:
+            spread_c = np.ascontiguousarray(spread, dtype=np.uint16)
+            return _jit_score_bitmap_rescored_u16(
+                spread_c, dx_c, dy_c, bins_c, np.uint16(bit_active), bg_c,
+            )
+        spread_c = np.ascontiguousarray(spread, dtype=np.uint8)
         if stride > 1:
             return _jit_score_bitmap_rescored_strided(
                 spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
@@ -528,6 +602,17 @@ def popcount_density(spread: np.ndarray) -> np.ndarray:
     2) numpy.bitwise_count (NumPy 2.0+, SIMD ma single-thread)
     3) Fallback numpy bit-shift puro
     """
+    if spread.dtype == np.uint16:
+        spread_c = np.ascontiguousarray(spread, dtype=np.uint16)
+        if HAS_NUMBA:
+            return _jit_popcount_density_u16(spread_c)
+        if _HAS_NP_BITCOUNT:
+            return np.bitwise_count(spread_c).astype(np.float32, copy=False)
+        H, W = spread_c.shape
+        out = np.zeros((H, W), dtype=np.float32)
+        for b in range(16):
+            out += ((spread_c >> b) & 1).astype(np.float32)
+        return out
     spread_c = np.ascontiguousarray(spread, dtype=np.uint8)
     if HAS_NUMBA:
         return _jit_popcount_density(spread_c)

pm2d/auto_tune.py

@@ -152,14 +152,27 @@ def _cache_key(template_bgr: np.ndarray, mask: np.ndarray | None) -> str:
     return h.hexdigest()
 
 
-def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
+def auto_tune(
+    template_bgr: np.ndarray,
+    mask: np.ndarray | None = None,
+    angle_tolerance_deg: float | None = None,
+    angle_center_deg: float = 0.0,
+) -> dict:
     """Analizza template e ritorna dict parametri suggeriti.
 
     Chiavi compatibili con edit_params PARAM_SCHEMA.
 
+    angle_tolerance_deg: se != None, restringe angle_range a
+    (center - tol, center + tol). Usare quando l'orientamento del
+    pezzo e' noto a priori (feeder con guida, posizionamento
+    meccanico): training molto piu rapido (24x meno varianti per
+    tol=15° vs 360° pieno).
+
     Risultato cachato in-memory (LRU): ri-chiamare con stessa ROI è O(1).
     """
     ck = _cache_key(template_bgr, mask)
+    if angle_tolerance_deg is not None:
+        ck = f"{ck}|tol={angle_tolerance_deg}|c={angle_center_deg}"
     cached = _TUNE_CACHE.get(ck)
     if cached is not None:
         _TUNE_CACHE.move_to_end(ck)
@@ -208,8 +221,13 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     # spread_radius proporzionale a risoluzione + pyramid (tolleranza ~1% dim)
     spread_radius = int(np.clip(max(3, min_side * 0.02), 3, 8))
 
-    # angle range ridotto se simmetria rotazionale
+    # angle range: priorita' a tolerance hint utente, poi simmetria rotazionale.
-    angle_max = 360.0 / sym["order"] if sym["order"] > 1 else 360.0
+    if angle_tolerance_deg is not None:
+        angle_min = float(angle_center_deg - angle_tolerance_deg)
+        angle_max = float(angle_center_deg + angle_tolerance_deg)
+    else:
+        angle_min = 0.0
+        angle_max = 360.0 / sym["order"] if sym["order"] > 1 else 360.0
 
     # min_score: se entropia orient alta → template distintivo → soglia alta ok
     # se entropia bassa → template ambiguo → soglia più permissiva
@@ -228,7 +246,7 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
 
     result = {
         "backend": "line",
-        "angle_min": 0.0,
+        "angle_min": angle_min,
         "angle_max": angle_max,
         "angle_step": angle_step,
         "scale_min": 1.0,

pm2d/line_matcher.py

@@ -46,7 +46,8 @@ from pm2d._jit_kernels import (
     HAS_NUMBA,
 )
 
-N_BINS = 8  # orientamenti quantizzati modulo π
+N_BINS = 8       # default: orientamento mod π (no polarity)
+N_BINS_POL = 16  # use_polarity=True: orientamento mod 2π (con polarity)
 
 
 def _poly_iou(p1: np.ndarray, p2: np.ndarray) -> float:
@@ -124,6 +125,11 @@ class _Variant:
     kw: int
     cx_local: float   # centro-modello dentro al bbox kernel
     cy_local: float
+    # Indice template view (X feature - multi-template ensemble).
+    # 0 = template principale del train(); 1+ = view aggiunte via
+    # add_template_view(). Usato in _verify_ncc/_compute_recall per
+    # scegliere il template gray corretto per match.
+    view_idx: int = 0
 
 
 class LineShapeMatcher:
@@ -143,6 +149,7 @@ class LineShapeMatcher:
         pyramid_levels: int = 2,
         top_score_factor: float = 0.5,
         n_threads: int | None = None,
+        use_polarity: bool = False,
     ) -> None:
         self.num_features = num_features
         self.weak_grad = weak_grad
@@ -156,12 +163,23 @@ class LineShapeMatcher:
         self.pyramid_levels = max(1, pyramid_levels)
         self.top_score_factor = top_score_factor
         self.n_threads = n_threads or max(1, (os.cpu_count() or 2) - 1)
+        # Polarity-aware: 16 bin (orientamento mod 2π) usando bitmap uint16.
+        # Distingue edge "chiaro→scuro" da "scuro→chiaro" → 2x selettività.
+        # Usare quando background di scena varia (chiaro/scuro) e orientamento
+        # template e' direzionale.
+        self.use_polarity = use_polarity
+        self._n_bins = N_BINS_POL if use_polarity else N_BINS
 
         self.variants: list[_Variant] = []
         self.template_size: tuple[int, int] = (0, 0)
         self.template_gray: np.ndarray | None = None
         # Maschera usata in training (propagata al refine per coerenza).
         self._train_mask: np.ndarray | None = None
+        # Multi-template ensemble (X feature): N view dello stesso pezzo
+        # (chiari/scuri, condizioni diverse). Template principale e' [0],
+        # view aggiunte via add_template_view() sono [1+]. Match restituisce
+        # la view che ha matchato meglio.
+        self._view_templates: list[tuple[np.ndarray, np.ndarray | None]] = []
 
     # --- Helpers -------------------------------------------------------
 
@@ -171,15 +189,20 @@ class LineShapeMatcher:
             return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
         return img
 
-    @staticmethod
+    def _gradient(self, gray: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-    def _gradient(gray: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         gx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
         gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
         mag = cv2.magnitude(gx, gy)
-        ang = np.arctan2(gy, gx)
+        ang = np.arctan2(gy, gx)  # [-π, π]
-        ang_mod = np.where(ang < 0, ang + np.pi, ang)
+        if self.use_polarity:
-        bins = np.floor(ang_mod / np.pi * N_BINS).astype(np.int16)
+            # Mod 2π: bin 0..15 codifica direzione + polarity edge.
-        bins = np.clip(bins, 0, N_BINS - 1)
+            ang_full = np.where(ang < 0, ang + 2.0 * np.pi, ang)
+            bins = np.floor(ang_full / (2.0 * np.pi) * N_BINS_POL).astype(np.int16)
+            bins = np.clip(bins, 0, N_BINS_POL - 1)
+        else:
+            ang_mod = np.where(ang < 0, ang + np.pi, ang)
+            bins = np.floor(ang_mod / np.pi * N_BINS).astype(np.int16)
+            bins = np.clip(bins, 0, N_BINS - 1)
         return mag, bins
 
     def _extract_features(
@@ -213,6 +236,26 @@ class LineShapeMatcher:
                 np.array(picked_y, np.int32),
                 np.array(picked_b, np.int8))
 
+    def set_angle_range_around(
+        self, center_deg: float, tolerance_deg: float,
+    ) -> None:
+        """Restringe angle_range a (center - tol, center + tol).
+
+        Comodo helper per scenari in cui l'orientamento del pezzo e'
+        noto a priori entro ±tolerance_deg (es. feeder vibrante con
+        guida meccanica). Riduce drasticamente le varianti generate
+        in train(): es. ±15° vs 360° = 24x meno varianti, training
+        e matching molto piu veloci.
+
+        Esempio:
+            m.set_angle_range_around(0, 20)   # cerca solo in [-20, +20]
+            m.train(template)
+        """
+        self.angle_range_deg = (
+            float(center_deg - tolerance_deg),
+            float(center_deg + tolerance_deg),
+        )
+
     def _scale_list(self) -> list[float]:
         s0, s1 = self.scale_range
         if s0 >= s1 or self.scale_step <= 0:
@@ -281,8 +324,60 @@ class LineShapeMatcher:
         self._train_mask = mask_full.copy()
 
         self.variants.clear()
+        # Reset view list: template principale = view 0
+        self._view_templates = [(gray.copy(), mask_full.copy())]
         # Invalida cache feature di refine: il template e cambiato.
         self._refine_feat_cache = {}
+        self._build_variants_for_view(gray, mask_full, view_idx=0)
+        self._dedup_variants()
+        return len(self.variants)
+
+    def add_template_view(
+        self, template_bgr: np.ndarray, mask: np.ndarray | None = None,
+    ) -> int:
+        """Aggiunge una view template extra all'ensemble (Halcon-style
+        create_aniso_shape_model con fusione N viste).
+
+        Genera varianti del nuovo template con stessi parametri (range
+        angle/scale) e le APPENDE a self.variants. NCC/recall usano
+        automaticamente il template della view che ha matchato.
+
+        Use case: pezzo che cambia aspetto (chiaro/scuro, prima/dopo
+        trattamento, illuminazioni diverse) → un solo matcher resistente.
+
+        Ritorna numero TOTALE varianti dopo l'aggiunta. Le view sono
+        indicizzate da 1 in poi (0 e' il template del train).
+        """
+        if not self.variants:
+            raise RuntimeError(
+                "Chiamare train(template_principale) prima di add_template_view")
+        gray = self._to_gray(template_bgr)
+        h, w = gray.shape
+        if (w, h) != self.template_size:
+            # Resize per coerenza con bbox/poly
+            gray = cv2.resize(gray, self.template_size, interpolation=cv2.INTER_LINEAR)
+            if mask is not None:
+                mask = cv2.resize(mask, self.template_size, interpolation=cv2.INTER_NEAREST)
+        if mask is None:
+            mask_full = np.full(gray.shape, 255, dtype=np.uint8)
+        else:
+            mask_full = (mask > 0).astype(np.uint8) * 255
+        view_idx = len(self._view_templates)
+        self._view_templates.append((gray.copy(), mask_full.copy()))
+        n_before = len(self.variants)
+        self._build_variants_for_view(gray, mask_full, view_idx=view_idx)
+        self._dedup_variants()
+        return len(self.variants) - n_before
+
+    def _build_variants_for_view(
+        self, gray: np.ndarray, mask_full: np.ndarray, view_idx: int,
+    ) -> None:
+        """Estrae varianti rotate+scalate per UNA view template.
+
+        Estrazione algorithm identica al train() originale, separato per
+        riuso da add_template_view (multi-template ensemble).
+        """
+        h, w = gray.shape
         for s in self._scale_list():
             sw = max(16, int(round(w * s)))
             sh = max(16, int(round(h * s)))
@@ -336,9 +431,8 @@ class LineShapeMatcher:
                     levels=levels,
                     kh=kh, kw=kw,
                     cx_local=float(cx_local), cy_local=float(cy_local),
+                    view_idx=view_idx,
                 ))
-        self._dedup_variants()
-        return len(self.variants)
 
     def _dedup_variants(self) -> int:
         """Rimuove varianti con feature-set identico (post-quantizzazione).
@@ -390,20 +484,22 @@ class LineShapeMatcher:
         return raw
 
     def _spread_bitmap(self, gray: np.ndarray) -> np.ndarray:
-        """Spread bitmap uint8: bit b acceso dove bin b è presente nel raggio.
+        """Spread bitmap: bit b acceso dove bin b è presente nel raggio.
 
-        Formato compatto 32× più denso della response map (N_BINS, H, W) float32.
+        dtype: uint8 per N_BINS=8, uint16 per N_BINS_POL=16 (use_polarity).
         """
         mag, bins = self._gradient(gray)
         valid = mag >= self.weak_grad
         k = 2 * self.spread_radius + 1
         kernel = np.ones((k, k), dtype=np.uint8)
         H, W = gray.shape
-        spread = np.zeros((H, W), dtype=np.uint8)
+        nb = self._n_bins
-        for b in range(N_BINS):
+        dtype = np.uint16 if nb > 8 else np.uint8
+        spread = np.zeros((H, W), dtype=dtype)
+        for b in range(nb):
             mask_b = ((bins == b) & valid).astype(np.uint8)
             d = cv2.dilate(mask_b, kernel)
-            spread |= (d << b)
+            spread |= (d.astype(dtype) << b)
         return spread
 
     @staticmethod
@@ -653,9 +749,10 @@ class LineShapeMatcher:
             x_lo = int(cx) - margin; x_hi = int(cx) + margin + 1
             sh_w = y_hi - y_lo; sw_w = x_hi - x_lo
             acc = np.zeros((sh_w, sw_w), dtype=np.float32)
+            spread_dtype = spread0.dtype.type
             for i in range(len(dx)):
                 ddx = int(dx[i]); ddy = int(dy[i]); b = int(fb[i])
-                bit = np.uint8(1 << b)
+                bit = spread_dtype(1 << b)
                 sy0 = y_lo + ddy; sy1 = y_hi + ddy
                 sx0 = x_lo + ddx; sx1 = x_hi + ddx
                 a_y0 = max(0, -sy0); a_y1 = sh_w - max(0, sy1 - H)
@@ -704,9 +801,23 @@ class LineShapeMatcher:
                 s2, cx2, cy2 = _score_at_angle(x2)
         return best
 
+    def _get_view_template(
+        self, view_idx: int,
+    ) -> tuple[np.ndarray | None, np.ndarray | None]:
+        """Ritorna (template_gray, mask) per la view specificata.
+
+        view_idx 0 = template principale (train), 1+ = view extra
+        aggiunte via add_template_view. Usato per scegliere il template
+        corretto in NCC/recall verification quando il matcher e'
+        ensemble multi-template.
+        """
+        if 0 <= view_idx < len(self._view_templates):
+            return self._view_templates[view_idx]
+        return self.template_gray, self._train_mask
+
     def _verify_ncc(
         self, scene_gray: np.ndarray, cx: float, cy: float,
-        angle_deg: float, scale: float,
+        angle_deg: float, scale: float, view_idx: int = 0,
     ) -> float:
         """NCC tra template warpato alla pose e scena sottostante.
 
@@ -718,9 +829,9 @@ class LineShapeMatcher:
         il matcher linemod può dare score alto su texture generiche ma
         sovrapponendo il template gray i pixel non corrispondono.
         """
-        if self.template_gray is None:
+        t, train_mask = self._get_view_template(view_idx)
+        if t is None:
             return 1.0
-        t = self.template_gray
         h, w = t.shape
         cx_t = (w - 1) / 2.0
         cy_t = (h - 1) / 2.0
@@ -745,8 +856,8 @@ class LineShapeMatcher:
             t, M, (cw, ch),
             flags=cv2.INTER_LINEAR, borderValue=0,
         )
-        if self._train_mask is not None:
+        if train_mask is not None:
-            mask_src = self._train_mask
+            mask_src = train_mask
         else:
             mask_src = np.full_like(t, 255)
         mask_w = cv2.warpAffine(
@@ -760,7 +871,15 @@ class LineShapeMatcher:
         scn = scn_crop[valid].astype(np.float32)
         tm = tpl - tpl.mean()
         sm = scn - scn.mean()
-        denom = np.sqrt((tm * tm).sum() * (sm * sm).sum()) + 1e-9
+        # Std minimo: se template o scena patch sono quasi uniformi
+        # (es. zona di sfondo bianco/nero), NCC e instabile e da false
+        # high-correlation. Halcon-style: scarta match.
+        tpl_var = float((tm * tm).sum())
+        scn_var = float((sm * sm).sum())
+        n_pix = float(valid.sum())
+        if tpl_var < 1e-3 * n_pix or scn_var < 1e-3 * n_pix:
+            return 0.0
+        denom = np.sqrt(tpl_var * scn_var) + 1e-9
         return float((tm * sm).sum() / denom)
 
     def find(
@@ -824,12 +943,25 @@ class LineShapeMatcher:
         # map float32 → MOLTO più cache-friendly per _score_by_shift.
         spread_top = self._spread_bitmap(grays[top])
         bit_active_top = int(
-            sum(1 << b for b in range(N_BINS)
+            sum(1 << b for b in range(self._n_bins)
-                if (spread_top & np.uint8(1 << b)).any())
+                if (spread_top & (spread_top.dtype.type(1) << b)).any())
         )
         if nms_radius is None:
             nms_radius = max(8, min(self.template_size) // 2)
-        top_thresh = min_score * self.top_score_factor
+        # Pruning adattivo allo step angolare: con step piccolo (<= 3 deg)
+        # ci sono molte varianti vicine, gli score top-level sono ravvicinati
+        # e top_thresh*0.5 e' troppo aggressivo: scarta varianti valide che
+        # sarebbero state riprese al full-res. Stessa cosa per
+        # coarse_angle_factor (skip 1 ogni 2): con step fine non e' utile.
+        # Risultato osservato: precisione "veloce" 10° dava risultati
+        # migliori di "preciso" 2° proprio perche evitava il pruning.
+        eff_step = self._effective_angle_step()
+        top_factor = self.top_score_factor
+        cf_eff = max(1, coarse_angle_factor)
+        if eff_step <= 3.0:
+            top_factor = max(top_factor, 0.7)
+            cf_eff = 1
+        top_thresh = min_score * top_factor
 
         tw, th = self.template_size
         density_top = _jit_popcount(spread_top)
@@ -861,7 +993,7 @@ class LineShapeMatcher:
 
         coarse_idx_list: list[int] = []  # varianti da valutare al top
         neighbor_map: dict[int, list[int]] = {}  # vi_coarse -> indici vicini
-        cf = max(1, coarse_angle_factor)
+        cf = cf_eff
         for scale_key, vi_list in variants_by_scale.items():
             vi_sorted = sorted(vi_list, key=lambda i: self.variants[i].angle_deg)
             n = len(vi_sorted)
@@ -982,8 +1114,8 @@ class LineShapeMatcher:
         # Full-res (parallelizzato) con bitmap
         spread0 = self._spread_bitmap(gray0)
         bit_active_full = int(
-            sum(1 << b for b in range(N_BINS)
+            sum(1 << b for b in range(self._n_bins)
-                if (spread0 & np.uint8(1 << b)).any())
+                if (spread0 & (spread0.dtype.type(1) << b)).any())
         )
         density_full = _jit_popcount(spread0)
         for sc in unique_scales:
@@ -1128,10 +1260,18 @@ class LineShapeMatcher:
             # ranking/visualizzazione (uno score 1.0 vero richiede sia
             # match shape sia template gray identici).
             if verify_ncc and float(score_f) < ncc_skip_above:
-                ncc = self._verify_ncc(gray0, cx_f, cy_f, ang_f, var.scale)
+                ncc = self._verify_ncc(
+                    gray0, cx_f, cy_f, ang_f, var.scale,
+                    view_idx=getattr(var, "view_idx", 0),
+                )
                 if ncc < verify_threshold:
                     continue
                 score_f = (float(score_f) + max(0.0, ncc)) * 0.5
+            # Re-check min_score sullo score finale: NCC averaging puo
+            # abbattere lo shape-score sotto la soglia user. Senza questo
+            # check apparivano match con score < min_score (UI confusing).
+            if float(score_f) < min_score:
+                continue
 
             # Ri-traslo coord da spazio crop ROI a spazio scena originale.
             cx_out = cx_f + roi_offset[0]
@@ -1139,6 +1279,22 @@ class LineShapeMatcher:
             poly = _oriented_bbox_polygon(
                 cx_out, cy_out, tw * var.scale, th * var.scale, ang_f,
             )
+            # Reject match con bbox che sfora pesantemente la scena:
+            # spesso indica match spurio (centro derivato male o scala
+            # incoerente). Tollera 25% out-of-bounds, sopra rigetta.
+            H_scn, W_scn = gray_full.shape
+            poly_area = float(cv2.contourArea(poly))
+            if poly_area > 0:
+                # Clip poly alla scena: intersezione con rettangolo (0,0,W,H)
+                scene_rect = np.array([
+                    [0, 0], [W_scn, 0], [W_scn, H_scn], [0, H_scn],
+                ], dtype=np.float32)
+                inter, _ = cv2.intersectConvexConvex(
+                    poly.astype(np.float32), scene_rect,
+                )
+                inside_ratio = float(inter) / poly_area
+                if inside_ratio < 0.75:
+                    continue
             # Penalità scala opzionale: score degrada con distanza da 1.0
             if scale_penalty > 0.0 and var.scale != 1.0:
                 score_f = float(score_f) * max(

pm2d/web/server.py

@@ -249,9 +249,9 @@ PRECISION_ANGLE_STEP = {
 # Un operatore sceglie il livello di rigore, non un numero astratto.
 FILTRO_FP_MAP = {
     "off":      0.0,   # disabilitato: mantieni tutti i match shape-based
-    "leggero":  0.20,  # tollera variazioni intensità/illuminazione forti
+    "leggero":  0.30,  # tollera variazioni intensità/illuminazione forti
-    "medio":    0.35,  # default bilanciato (consigliato)
+    "medio":    0.50,  # default bilanciato (consigliato)
-    "forte":    0.50,  # scarta match con intensità molto diversa dal template
+    "forte":    0.70,  # scarta match con intensità molto diversa dal template
 }
 
 

pm2d/web/static/app.js

@@ -294,12 +294,17 @@ async function doMatch() {
     const SCALE_MAP = {fissa:[1,1,0.1], mini:[0.9,1.1,0.05],
                        medio:[0.75,1.25,0.05], max:[0.5,1.5,0.05]};
     const PREC_MAP = {veloce:10, normale:5, preciso:2};
-    const FP_MAP = {off:0, leggero:0.20, medio:0.35, forte:0.50};
+    // Allineato a FILTRO_FP_MAP server-side (server.py)
+    const FP_MAP = {off:0, leggero:0.30, medio:0.50, forte:0.70};
     const [smin, smax, sstep] = SCALE_MAP[user.scala];
+    // NB: SYM_MAP[invariante]=0 e' valido (zero rotazioni). Uso ?? per
+    // distinguere "chiave mancante" da "valore zero": altrimenti 0 || 360
+    // collassa invariante a 360 = bug "simmetria non ha effetto".
+    const angMax = SYM_MAP[user.simmetria] ?? 360;
     body = {
       model_id: state.model.id, scene_id: state.scene.id, roi: state.roi,
-      angle_min: 0, angle_max: SYM_MAP[user.simmetria] || 360,
+      angle_min: 0, angle_max: angMax,
-      angle_step: PREC_MAP[user.precisione] || 5,
+      angle_step: PREC_MAP[user.precisione] ?? 5,
       scale_min: smin, scale_max: smax, scale_step: sstep,
       min_score: user.min_score, max_matches: user.max_matches,
       num_features: adv.num_features ?? 96,
@@ -307,7 +312,7 @@ async function doMatch() {
       strong_grad: adv.strong_grad ?? 60,
       spread_radius: adv.spread_radius ?? 5,
       pyramid_levels: adv.pyramid_levels ?? 3,
-      verify_threshold: adv.verify_threshold ?? (FP_MAP[user.filtro_fp] ?? 0.35),
+      verify_threshold: adv.verify_threshold ?? (FP_MAP[user.filtro_fp] ?? 0.50),
       nms_radius: adv.nms_radius ?? 0,
     };
   } else {