fix: rimuove edge spuri sui bordi template warpato (apparivano come ROI)

Bug: per ogni match l'overlay edge del modello includeva anche il
PERIMETRO del template warpato (transizione bordo nero borderValue=0
→ scena = forte gradient artefatto). Con N match si vedevano N
rettangoli verdi attorno ai pezzi, simili a "ROI ripetute".

Fix:
- Warpa anche _train_mask alla pose
- Erode di (2*spread_radius+1) per scartare la fascia di transizione
  bordo che produce gradient spurio
- Maschera edge_mask con warped_mask: solo edge interni al pezzo
  vengono visualizzati

Risultato: overlay edge pulito che mostra solo i veri edge del
modello allineati al pezzo trovato, niente cornici fasulle.

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

pm2d/line_matcher.py

@@ -127,6 +127,7 @@ class Match:
     scale: float
     score: float
     bbox_poly: np.ndarray  # (4, 2) float32 - 4 vertici ordinati (ruotato)
+    variant_idx: int = -1  # indice variante usata (per overlay coerente)
 
 
 @dataclass
@@ -1863,6 +1864,7 @@ class LineShapeMatcher:
                 scale=var.scale,
                 score=score_f,
                 bbox_poly=poly,
+                variant_idx=int(vi),
             ))
             if len(kept) >= max_matches:
                 break

pm2d/web/server.py

@@ -78,6 +78,7 @@ def _matcher_cache_key(roi: np.ndarray, tech: dict) -> str:
     h.update(roi.tobytes())
     # Solo parametri che influenzano il training
     relevant = ("num_features", "weak_grad", "strong_grad",
+                "min_feature_spacing",
                 "angle_min", "angle_max", "angle_step",
                 "scale_min", "scale_max", "scale_step",
                 "spread_radius", "pyramid_levels")
@@ -131,45 +132,87 @@ def _encode_png(img: np.ndarray) -> bytes:
 
 
 def _draw_matches(scene: np.ndarray, matches: list[Match],
-                   template_gray: np.ndarray | None) -> np.ndarray:
+                   template_gray: np.ndarray | None,
+                   matcher: "LineShapeMatcher | None" = None) -> np.ndarray:
+    """Disegna SOLO UCS (richiesta utente) per ogni match trovato.
+
+    UCS = sistema di coordinate (X rosso, Y verde) posizionato sul
+    baricentro feature del modello, ruotato secondo l'angolo del match.
+    Niente edge, niente cerchietti feature, niente bbox: i match sulla
+    scena reale devono essere puliti, gli edge filtrati si vedono solo
+    nell'anteprima modello.
+    """
     out = scene.copy()
-    H, W = scene.shape[:2]
-    palette = [
-        (0, 255, 0), (0, 200, 255), (255, 100, 100), (255, 200, 0),
-        (200, 0, 255), (100, 255, 200), (255, 0, 0), (0, 255, 255),
-    ]
+    # Lunghezza assi UCS: stessa formula dell'anteprima modello
+    # (0.15 * max lato template) scalata per m.scale → coerenza dimensionale.
+    if matcher is not None and matcher.template_size != (0, 0):
+        L_base = int(0.15 * max(matcher.template_size))
+    else:
+        L_base = 30
+    H_scene, W_scene = scene.shape[:2]
+
     for i, m in enumerate(matches):
-        color = palette[i % len(palette)]
-        if template_gray is not None:
+        # UCS posizionato esattamente sul CENTRO POSE del match (m.cx, m.cy):
+        # equivale al centro template traslato alla scena, ruotato con
+        # m.angle_deg. Coerente con UCS dell'anteprima modello che ora
+        # e' anche sul centro ROI (vedi preview_edges).
+        ax = np.deg2rad(m.angle_deg)
+        ca, sa = np.cos(ax), np.sin(ax)
+        cx, cy = int(round(m.cx)), int(round(m.cy))
+        # Overlay edge del modello orientato (richiesta utente):
+        # warpa template alla pose, applica hysteresis identica al matcher,
+        # disegna pixel edge come overlay verde tenue. Maschera col
+        # _train_mask warpato + erode per rimuovere edge sui BORDI del
+        # rettangolo template (transizione bordo nero → scena = falso edge
+        # che appariva come "ROI" attorno a ogni match).
+        if template_gray is not None and matcher is not None:
             t = template_gray
             th, tw = t.shape
-            edge = cv2.Canny(t, 50, 150)
             cx_t = (tw - 1) / 2.0; cy_t = (th - 1) / 2.0
             M = cv2.getRotationMatrix2D((cx_t, cy_t), m.angle_deg, m.scale)
             M[0, 2] += m.cx - cx_t
             M[1, 2] += m.cy - cy_t
-            warped = cv2.warpAffine(edge, M, (W, H),
+            warped_gray = cv2.warpAffine(
+                t, M, (W_scene, H_scene),
+                flags=cv2.INTER_LINEAR, borderValue=0)
+            # Maschera: train_mask se disponibile, altrimenti rettangolo pieno
+            mask_src = (matcher._train_mask if matcher._train_mask is not None
+                        else np.full((th, tw), 255, dtype=np.uint8))
+            warped_mask = cv2.warpAffine(
+                mask_src, M, (W_scene, H_scene),
                 flags=cv2.INTER_NEAREST, borderValue=0)
-            mask = warped > 0
-            if mask.any():
-                overlay = np.zeros_like(out)
-                overlay[mask] = color
-                out[mask] = (0.3 * out[mask] + 0.7 * overlay[mask]).astype(np.uint8)
-        poly = m.bbox_poly.astype(np.int32).reshape(-1, 1, 2)
-        cv2.polylines(out, [poly], True, color, 2, cv2.LINE_AA)
-        p0 = tuple(m.bbox_poly[0].astype(int))
-        p1 = tuple(m.bbox_poly[1].astype(int))
-        cv2.line(out, p0, p1, color, 4, cv2.LINE_AA)
-        cx, cy = int(round(m.cx)), int(round(m.cy))
-        cv2.drawMarker(out, (cx, cy), color, cv2.MARKER_CROSS, 22, 2, cv2.LINE_AA)
-        L = int(np.linalg.norm(m.bbox_poly[1] - m.bbox_poly[0])) // 2
-        a = np.deg2rad(m.angle_deg)
-        cv2.arrowedLine(out, (cx, cy),
-                        (int(cx + L * np.cos(a)), int(cy - L * np.sin(a))),
-                        color, 2, cv2.LINE_AA, tipLength=0.2)
-        label = f"#{i+1} {m.angle_deg:.0f}d s={m.scale:.2f} {m.score:.2f}"
-        cv2.putText(out, label, (cx + 8, cy - 8),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2, cv2.LINE_AA)
+            # Erode di spread_radius per scartare la fascia di transizione
+            # bordo che produce gradient spurio
+            er_k = max(3, 2 * matcher.spread_radius + 1)
+            kernel_er = np.ones((er_k, er_k), np.uint8)
+            warped_mask = cv2.erode(warped_mask, kernel_er)
+            mag, _ = matcher._gradient(warped_gray)
+            if matcher.weak_grad < matcher.strong_grad:
+                edge_mask = matcher._hysteresis_mask(mag)
+            else:
+                edge_mask = mag >= matcher.strong_grad
+            edge_mask = edge_mask & (warped_mask > 0)
+            if edge_mask.any():
+                edge_overlay = np.zeros_like(out)
+                edge_overlay[edge_mask] = (0, 220, 0)  # verde brillante
+                out = cv2.addWeighted(out, 1.0, edge_overlay, 0.6, 0)
+        L = max(20, int(L_base * m.scale))
+        # X axis = rotazione di (1, 0) con cv2 matrix → (cos, -sin)
+        x_end = (int(cx + L * ca), int(cy - L * sa))
+        # Y axis = rotazione di (0, 1) con cv2 matrix → (sin, cos)
+        # A m.angle_deg=0 deve puntare GIU' (image y-down convenzione modello)
+        y_end = (int(cx + L * sa), int(cy + L * ca))
+        cv2.arrowedLine(out, (cx, cy), x_end,
+                        (0, 0, 255), 2, cv2.LINE_AA, tipLength=0.2)
+        cv2.putText(out, "X", (x_end[0] + 4, x_end[1] + 5),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
+        cv2.arrowedLine(out, (cx, cy), y_end,
+                        (0, 255, 0), 2, cv2.LINE_AA, tipLength=0.2)
+        cv2.putText(out, "Y", (y_end[0] + 4, y_end[1] + 12),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA)
+        # Origine UCS: cerchio bianco con bordo nero
+        cv2.circle(out, (cx, cy), 4, (0, 0, 0), -1, cv2.LINE_AA)
+        cv2.circle(out, (cx, cy), 3, (255, 255, 255), -1, cv2.LINE_AA)
     return out
 
 
@@ -272,6 +315,15 @@ class SimpleMatchParams(BaseModel):
     penalita_scala: float = 0.0       # 0 = score shape invariante, >0 = penalizza scala != 1
     min_score: float = 0.65
     max_matches: int = 25
+    # --- Override edge da pannello "Anteprima edge" (None = auto_tune) ---
+    # Quando settati, sovrascrivono i valori derivati da auto_tune e
+    # vengono usati identici sia nel training del matcher sia nel find.
+    # Salvati nella ricetta cosi' la stessa pulizia rumore e' replicata
+    # quando la ricetta viene caricata.
+    edge_weak_grad: float | None = None
+    edge_strong_grad: float | None = None
+    edge_num_features: int | None = None
+    edge_min_feature_spacing: int | None = None
     # --- Halcon-mode flags (default off = backward compat) ---
     # Init-time (richiede ri-train se cambiato)
     use_polarity: bool = False        # F: 16 bin orientation mod 2pi
@@ -320,10 +372,24 @@ def _simple_to_technical(
     smin, smax, sstep = SCALE_PRESETS.get(p.scala, (1.0, 1.0, 0.1))
     ang_step = PRECISION_ANGLE_STEP.get(p.precisione, 5.0)
 
+    # Override edge dal pannello "Anteprima edge" se utente li ha settati.
+    # Questi sostituiscono i valori auto_tune nel training del matcher,
+    # garantendo che la selezione edge identica a quella del preview
+    # venga usata sia in training sia in find.
+    weak_g = (p.edge_weak_grad if p.edge_weak_grad is not None
+              else tune["weak_grad"])
+    strong_g = (p.edge_strong_grad if p.edge_strong_grad is not None
+                else tune["strong_grad"])
+    n_feat = (p.edge_num_features if p.edge_num_features is not None
+              else nf)
+    min_sp = (p.edge_min_feature_spacing if p.edge_min_feature_spacing is not None
+              else 3)
+
     return {
-        "num_features": nf,
-        "weak_grad": tune["weak_grad"],
-        "strong_grad": tune["strong_grad"],
+        "num_features": n_feat,
+        "weak_grad": weak_g,
+        "strong_grad": strong_g,
+        "min_feature_spacing": min_sp,
         "spread_radius": spread,
         "pyramid_levels": pyr,
         "angle_min": 0.0,
@@ -511,7 +577,7 @@ def match(p: MatchParams):
 
     # Render annotated image
     tg = cv2.cvtColor(roi_img, cv2.COLOR_BGR2GRAY)
-    annotated = _draw_matches(scene, matches, tg)
+    annotated = _draw_matches(scene, matches, tg, matcher=m)
     ann_id = _store_image(annotated)
 
     return MatchResp(
@@ -559,6 +625,7 @@ def match_simple(p: SimpleMatchParams):
             scale_range=(tech["scale_min"], tech["scale_max"]),
             scale_step=tech["scale_step"],
             spread_radius=tech["spread_radius"],
+            min_feature_spacing=tech.get("min_feature_spacing", 3),
             pyramid_levels=tech["pyramid_levels"],
             use_polarity=p.use_polarity,
             use_gpu=p.use_gpu,
@@ -588,7 +655,7 @@ def match_simple(p: SimpleMatchParams):
     t_find = time.time() - t0
 
     tg = cv2.cvtColor(roi_img, cv2.COLOR_BGR2GRAY)
-    annotated = _draw_matches(scene, matches, tg)
+    annotated = _draw_matches(scene, matches, tg, matcher=m)
     ann_id = _store_image(annotated)
 
     return MatchResp(
@@ -628,6 +695,11 @@ class SaveRecipeParams(BaseModel):
     precisione: str = "normale"
     use_polarity: bool = False
     use_gpu: bool = False
+    # Override edge dal pannello "Anteprima edge" (None = auto_tune)
+    edge_weak_grad: float | None = None
+    edge_strong_grad: float | None = None
+    edge_num_features: int | None = None
+    edge_min_feature_spacing: int | None = None
     name: str  # nome file ricetta (no path)
 
 
@@ -694,26 +766,23 @@ def preview_edges(p: EdgePreviewParams):
         b = int(fb[i])
         col = bin_colors[b % len(bin_colors)]
         cv2.circle(out, (int(fx[i]), int(fy[i])), 2, col, -1, cv2.LINE_AA)
-    # UCS sul baricentro feature (richiesta utente): assi X rosso, Y verde
-    bary_cx = bary_cy = None
-    if len(fx) > 0:
-        bary_cx = float(np.mean(fx))
-        bary_cy = float(np.mean(fy))
-        bx, by = int(round(bary_cx)), int(round(bary_cy))
-        axis_len = max(20, int(0.15 * max(out.shape[:2])))
-        # X axis (rosso, verso destra)
+    # UCS sul CENTRO ROI (coerente con _draw_matches che usa centro pose).
+    # In questo modo l'UCS visualizzato nel modello = UCS del match (modulo
+    # rotazione/traslazione data dalla pose del pezzo trovato).
+    rh, rw = roi_img.shape[:2]
+    bx, by = (rw - 1) // 2, (rh - 1) // 2
+    axis_len = max(20, int(0.15 * max(rw, rh)))
     cv2.arrowedLine(out, (bx, by), (bx + axis_len, by),
                     (0, 0, 255), 2, cv2.LINE_AA, tipLength=0.2)
     cv2.putText(out, "X", (bx + axis_len + 4, by + 5),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1, cv2.LINE_AA)
-        # Y axis (verde, verso il basso = convenzione image y-down)
     cv2.arrowedLine(out, (bx, by), (bx, by + axis_len),
                     (0, 255, 0), 2, cv2.LINE_AA, tipLength=0.2)
     cv2.putText(out, "Y", (bx + 4, by + axis_len + 12),
                 cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1, cv2.LINE_AA)
-        # Origine: cerchio bianco con bordo nero
     cv2.circle(out, (bx, by), 4, (0, 0, 0), -1, cv2.LINE_AA)
     cv2.circle(out, (bx, by), 3, (255, 255, 255), -1, cv2.LINE_AA)
+    bary_cx, bary_cy = float(bx), float(by)
     img_id = _store_image(out)
     n_edge_strong = int((mag >= m.strong_grad).sum())
     n_edge_total = int(edge_mask.sum() / 255)
@@ -745,6 +814,10 @@ def save_recipe(p: SaveRecipeParams):
         tipo=p.tipo, simmetria=p.simmetria, scala=p.scala,
         precisione=p.precisione,
         use_polarity=p.use_polarity, use_gpu=p.use_gpu,
+        edge_weak_grad=p.edge_weak_grad,
+        edge_strong_grad=p.edge_strong_grad,
+        edge_num_features=p.edge_num_features,
+        edge_min_feature_spacing=p.edge_min_feature_spacing,
     )
     tech = _simple_to_technical(sp, roi_img)
     m = LineShapeMatcher(
@@ -864,7 +937,7 @@ def match_recipe(p: RecipeMatchParams):
     )
     t_find = time.time() - t0
     tg = m.template_gray if m.template_gray is not None else np.zeros((1, 1), np.uint8)
-    annotated = _draw_matches(scene, matches, tg)
+    annotated = _draw_matches(scene, matches, tg, matcher=m)
     ann_id = _store_image(annotated)
     return MatchResp(
         matches=[MatchResult(

pm2d/web/static/app.js

@@ -53,10 +53,34 @@ function readUserParams() {
       document.getElementById("p-penalita-scala").value),
     min_score: parseFloat(document.getElementById("p-min-score").value),
     max_matches: parseInt(document.getElementById("p-max-matches").value, 10),
+    ...readEdgeOverrides(),
     ...readHalconFlags(),
   };
 }
 
+function readEdgeOverrides() {
+  // Override edge dal pannello "Anteprima edge". Settati = utente li ha
+  // toccati (anche se uguali al default attuale). Vengono propagati a
+  // _simple_to_technical e usati identici sia in training sia in find.
+  // Inoltre salvati nella ricetta cosi' si replicano al load.
+  const _v = (id, parser) => {
+    const el = document.getElementById(id);
+    if (!el) return null;
+    const v = parser(el.value);
+    return Number.isFinite(v) ? v : null;
+  };
+  // Sempre passa i valori correnti degli slider: e' la richiesta utente
+  // che i param di pulizia rumore vengano usati anche nel find/ricetta.
+  const polCb = document.getElementById("hc-use-polarity");
+  return {
+    edge_weak_grad: _v("ep-weak", parseFloat),
+    edge_strong_grad: _v("ep-strong", parseFloat),
+    edge_num_features: _v("ep-nf", parseInt),
+    edge_min_feature_spacing: _v("ep-sp", parseInt),
+    use_polarity: polCb?.checked || document.getElementById("ep-pol")?.checked,
+  };
+}
+
 function readHalconFlags() {
   // Halcon-mode toggle: tutti i flag default-off, esposti via "Modalità Halcon"
   const $cb = (id) => document.getElementById(id)?.checked ?? false;
@@ -716,6 +740,10 @@ async function saveRecipe() {
     precisione: user.precisione,
     use_polarity: user.use_polarity,
     use_gpu: user.use_gpu,
+    edge_weak_grad: user.edge_weak_grad,
+    edge_strong_grad: user.edge_strong_grad,
+    edge_num_features: user.edge_num_features,
+    edge_min_feature_spacing: user.edge_min_feature_spacing,
     name: name,
   };
   try {