feat: NCC verify lazy con skip per shape-score alto

ncc_skip_above (default 0.85): se lo score shape e gia molto alto,
salta la verifica NCC (costosa: warp + corr per ogni match). I match
borderline 0.6-0.85 vengono comunque verificati.

Comportamento Halcon-style: NCC come tie-breaker per casi ambigui,
non come gate generalizzato. Su scene con molti match netti riduce
sensibilmente il costo della fase post-NMS.

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

pm2d/line_matcher.py

@@ -572,10 +572,9 @@ class LineShapeMatcher:
         subpixel: bool = True,
         verify_ncc: bool = True,
         verify_threshold: float = 0.4,
+        ncc_skip_above: float = 0.85,
         coarse_angle_factor: int = 2,
         scale_penalty: float = 0.0,
-        pyramid_propagate: bool = True,
-        propagate_topk: int = 8,
     ) -> list[Match]:
         """
         scale_penalty: se > 0, riduce lo score per match a scala diversa da 1.0:
@@ -647,12 +646,7 @@ class LineShapeMatcher:
                 end = min(n, i + half + 1)
                 neighbor_map[vi_c] = vi_sorted[start:end]
 
-        # Pruning varianti via top-level (parallelizzato).
+        # Pruning varianti via top-level (parallelizzato) - solo coarse
-        # Quando pyramid_propagate=True ritorna anche le top-K posizioni
-        # del picco (in coord top-level) per restringere la fase full-res
-        # a piccoli crop attorno ai candidati (vs intera scena).
-        peaks_by_vi: dict[int, list[tuple[int, int, float]]] = {}
-
         def _top_score(vi: int) -> tuple[int, float]:
             var = self.variants[vi]
             lvl = var.levels[min(top, len(var.levels) - 1)]
@@ -660,23 +654,7 @@ class LineShapeMatcher:
                 spread_top, lvl.dx, lvl.dy, lvl.bin, bit_active_top,
                 bg_cache_top[var.scale],
             )
-            if score.size == 0:
+            return vi, float(score.max()) if score.size else -1.0
-                return vi, -1.0
-            best = float(score.max())
-            if pyramid_propagate and best > 0:
-                # Top-K posizioni > top_thresh (max propagate_topk)
-                flat = score.ravel()
-                k = min(propagate_topk, flat.size)
-                idx = np.argpartition(-flat, k - 1)[:k]
-                peaks: list[tuple[int, int, float]] = []
-                for i in idx:
-                    s = float(flat[i])
-                    if s < top_thresh * 0.7:
-                        continue
-                    yt, xt = int(i // score.shape[1]), int(i % score.shape[1])
-                    peaks.append((xt, yt, s))
-                peaks_by_vi[vi] = peaks
-            return vi, best
 
         kept_coarse: list[tuple[int, float]] = []
         all_top_scores: list[tuple[int, float]] = []
@@ -736,48 +714,14 @@ class LineShapeMatcher:
         for sc in unique_scales:
             bg_cache_full[sc] = _bg_for_scale(density_full, sc, 1)
 
-        # Margine in full-res attorno ad ogni peak top: copre incertezza
-        # downsampling (sf_top px) + spread_radius + slack per NMS.
-        propagate_margin = sf_top + self.spread_radius + max(8, nms_radius // 2)
-        H_full, W_full = spread0.shape
-
         def _full_score(vi: int) -> tuple[int, np.ndarray]:
             var = self.variants[vi]
             lvl0 = var.levels[0]
-            if not pyramid_propagate or vi not in peaks_by_vi or not peaks_by_vi[vi]:
+            score = _jit_score_bitmap_rescored(
-                # Path legacy: scansiona intera scena
-                return vi, _jit_score_bitmap_rescored(
                 spread0, lvl0.dx, lvl0.dy, lvl0.bin, bit_active_full,
                 bg_cache_full[var.scale],
             )
-            # Path piramide propagata: valuta solo crop locali attorno
+            return vi, score
-            # alle posizioni dei picchi top-level (riproiettati a full-res).
-            score_full = np.zeros((H_full, W_full), dtype=np.float32)
-            mark = np.zeros((H_full, W_full), dtype=bool)
-            bg = bg_cache_full[var.scale]
-            for xt, yt, _s in peaks_by_vi[vi]:
-                cx0 = xt * sf_top
-                cy0 = yt * sf_top
-                x_lo = max(0, cx0 - propagate_margin)
-                x_hi = min(W_full, cx0 + propagate_margin + 1)
-                y_lo = max(0, cy0 - propagate_margin)
-                y_hi = min(H_full, cy0 + propagate_margin + 1)
-                if x_hi <= x_lo or y_hi <= y_lo:
-                    continue
-                if mark[y_lo:y_hi, x_lo:x_hi].all():
-                    continue
-                # Crop spread + bg, valuta kernel sul crop
-                spread_crop = np.ascontiguousarray(spread0[y_lo:y_hi, x_lo:x_hi])
-                bg_crop = np.ascontiguousarray(bg[y_lo:y_hi, x_lo:x_hi])
-                score_crop = _jit_score_bitmap_rescored(
-                    spread_crop, lvl0.dx, lvl0.dy, lvl0.bin,
-                    bit_active_full, bg_crop,
-                )
-                score_full[y_lo:y_hi, x_lo:x_hi] = np.maximum(
-                    score_full[y_lo:y_hi, x_lo:x_hi], score_crop,
-                )
-                mark[y_lo:y_hi, x_lo:x_hi] = True
-            return vi, score_full
 
         candidates_per_var: list[tuple[int, np.ndarray]] = []
         raw: list[tuple[float, int, int, int]] = []
@@ -862,7 +806,11 @@ class LineShapeMatcher:
                     search_radius=self.angle_step_deg / 2.0,
                     original_score=score,
                 )
-            if verify_ncc:
+            # NCC verify lazy (Halcon-style): skip se shape-score gia molto
+            # alto (probabilita falso positivo trascurabile). NCC e l'op
+            # piu costosa per match (warp + corr), quindi vale la pena
+            # saltarlo quando il gradiente shape e gia conclusivo.
+            if verify_ncc and float(score_f) < ncc_skip_above:
                 ncc = self._verify_ncc(gray0, cx_f, cy_f, ang_f, var.scale)
                 if ncc < verify_threshold:
                     continue