feat(web): UI carica/stacca ricetta + match con ricetta caricata

Manca il path "load" della V feature: utente poteva salvare ricetta
ma non caricarla dalla UI. Aggiunto:

Server:
- POST /recipes/{name}/load: carica .npz in cache _RECIPE_MATCHERS
- POST /match_recipe: usa matcher caricato senza re-train (zero
  training time, solo find params propagati)

UI:
- Dropdown ricette disponibili (auto-refreshed da GET /recipes)
- Bottone "Carica" attiva ricetta + popola state.active_recipe
- Bottone "Stacca" torna al flow normale (training da ROI)
- Status indicator mostra ricetta attiva e dimensioni

doMatch dispatcha automaticamente:
- ricetta attiva → /match_recipe (no model/ROI necessari)
- altrimenti → /match o /match_simple come prima

Use case: ricetta tarata offline, deploy a runtime production senza
ricaricare modello+ROI ogni volta.

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

pm2d/line_matcher.py

@@ -241,13 +241,49 @@ class LineShapeMatcher:
             bins = np.clip(bins, 0, N_BINS - 1)
         return mag, bins
 
+    def _hysteresis_mask(self, mag: np.ndarray) -> np.ndarray:
+        """Edge mask con hysteresis (Halcon Contrast='auto' two-threshold).
+
+        Procedura:
+        1. seed = pixel con mag >= strong_grad (edge nitidi)
+        2. weak = pixel con mag >= weak_grad (edge candidati)
+        3. Espande seed dentro weak via componenti connesse 8-vicini
+
+        Risultato: edge debole connesso a edge forte viene PROMOSSO a
+        feature valida; edge debole isolato (rumore) viene SCARTATO.
+
+        Riduce sia falsi-positivi (rumore puro) sia falsi-negativi
+        (continuita' interrotta su edge sottili a basso contrasto).
+        """
+        weak = (mag >= self.weak_grad).astype(np.uint8)
+        strong = (mag >= self.strong_grad).astype(np.uint8)
+        # connectedComponentsWithStats su weak: per ogni componente,
+        # se contiene almeno un pixel strong → tutto componente accettato
+        n_lab, labels = cv2.connectedComponents(weak, connectivity=8)
+        if n_lab <= 1:
+            return strong.astype(bool)
+        # Label dei pixel strong: marker per componenti da accettare
+        strong_labels = np.unique(labels[strong > 0])
+        strong_labels = strong_labels[strong_labels > 0]  # 0 = bg
+        if len(strong_labels) == 0:
+            return strong.astype(bool)
+        # Mask = appartiene a label di componente "promosso"
+        keep = np.isin(labels, strong_labels)
+        return keep
+
     def _extract_features(
         self, mag: np.ndarray, bins: np.ndarray, mask: np.ndarray | None,
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         if mask is not None:
             mag = np.where(mask > 0, mag, 0)
-        strong = mag >= self.strong_grad
+        # Halcon-style edge selection: hysteresis tra weak_grad e strong_grad.
-        ys, xs = np.where(strong)
+        # Edge weak connessi a edge strong sono inclusi (continuita' bordi).
+        # Se weak_grad >= strong_grad → fallback a soglia singola strong.
+        if self.weak_grad < self.strong_grad:
+            edge = self._hysteresis_mask(mag)
+        else:
+            edge = mag >= self.strong_grad
+        ys, xs = np.where(edge)
         if len(xs) == 0:
             return (np.zeros(0, np.int32),) * 3
         vals = mag[ys, xs]

pm2d/web/server.py

@@ -607,7 +607,9 @@ def tune(p: TuneParams):
     x, y, w, h = p.roi
     roi_img = model[y:y + h, x:x + w]
     t = auto_tune(roi_img)
-    return {k: v for k, v in t.items() if not k.startswith("_")}
+    # Esponi parametri tecnici + meta diagnostica (_self_score, _validation,
+    # _symmetry_order, _orient_entropy) per feedback UI.
+    return t
 
 
 # --- V: Save/Load ricette pre-trained ---
@@ -674,6 +676,102 @@ def list_recipes():
     return {"files": files, "dir": str(RECIPES_DIR)}
 
 
+# Cache di matcher caricati da .npz (V feature). Key: nome ricetta.
+_RECIPE_MATCHERS: OrderedDict = OrderedDict()
+_RECIPE_MATCHERS_SIZE = 4
+
+
+@app.post("/recipes/{name}/load")
+def load_recipe(name: str):
+    """Carica ricetta .npz e popola cache matcher in memoria.
+
+    Una volta caricata, /match_recipe la usa direttamente senza
+    re-train. Halcon-equivalent read_shape_model + handle.
+    """
+    safe_name = "".join(c for c in name if c.isalnum() or c in "._-")
+    if not safe_name.endswith(".npz"):
+        safe_name += ".npz"
+    path = RECIPES_DIR / safe_name
+    if not path.is_file():
+        raise HTTPException(404, f"Ricetta non trovata: {safe_name}")
+    m = LineShapeMatcher.load_model(str(path))
+    _RECIPE_MATCHERS[safe_name] = m
+    _RECIPE_MATCHERS.move_to_end(safe_name)
+    while len(_RECIPE_MATCHERS) > _RECIPE_MATCHERS_SIZE:
+        _RECIPE_MATCHERS.popitem(last=False)
+    return {
+        "name": safe_name,
+        "n_variants": len(m.variants),
+        "template_size": list(m.template_size),
+        "use_polarity": m.use_polarity,
+    }
+
+
+class RecipeMatchParams(BaseModel):
+    recipe: str
+    scene_id: str
+    # Solo find-time params (training gia' fatto offline)
+    min_score: float = 0.65
+    max_matches: int = 25
+    min_recall: float = 0.0
+    use_soft_score: bool = False
+    subpixel_lm: bool = False
+    nms_iou_threshold: float = 0.3
+    coarse_stride: int = 1
+    pyramid_propagate: bool = False
+    greediness: float = 0.0
+    refine_pose_joint: bool = False
+    search_roi: list[int] | None = None
+    verify_threshold: float = 0.5
+    scale_penalty: float = 0.0
+
+
+@app.post("/match_recipe", response_model=MatchResp)
+def match_recipe(p: RecipeMatchParams):
+    """Match con ricetta pre-trained: zero training, solo find."""
+    safe_name = p.recipe if p.recipe.endswith(".npz") else f"{p.recipe}.npz"
+    m = _RECIPE_MATCHERS.get(safe_name)
+    if m is None:
+        # Auto-load on demand
+        path = RECIPES_DIR / safe_name
+        if not path.is_file():
+            raise HTTPException(404, f"Ricetta non trovata: {safe_name}")
+        m = LineShapeMatcher.load_model(str(path))
+        _RECIPE_MATCHERS[safe_name] = m
+    scene = _load_image(p.scene_id)
+    if scene is None:
+        raise HTTPException(404, "Scena non trovata")
+    search_roi_t = tuple(p.search_roi) if p.search_roi else None
+    t0 = time.time()
+    matches = m.find(
+        scene,
+        min_score=p.min_score, max_matches=p.max_matches,
+        verify_threshold=p.verify_threshold,
+        scale_penalty=p.scale_penalty,
+        min_recall=p.min_recall,
+        use_soft_score=p.use_soft_score,
+        subpixel_lm=p.subpixel_lm,
+        nms_iou_threshold=p.nms_iou_threshold,
+        coarse_stride=p.coarse_stride,
+        pyramid_propagate=p.pyramid_propagate,
+        greediness=p.greediness,
+        refine_pose_joint=p.refine_pose_joint,
+        search_roi=search_roi_t,
+    )
+    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)
+    ann_id = _store_image(annotated)
+    return MatchResp(
+        matches=[MatchResult(
+            cx=mt.cx, cy=mt.cy, angle_deg=mt.angle_deg, scale=mt.scale,
+            score=mt.score, bbox_poly=mt.bbox_poly.tolist(),
+        ) for mt in matches],
+        train_time=0.0, find_time=t_find,
+        num_variants=len(m.variants), annotated_id=ann_id,
+    )
+
+
 # Mount static
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 

pm2d/web/static/app.js

@@ -19,6 +19,7 @@ const PALETTE = [
 const state = {
   model: null, scene: null, roi: null, drag: null,
   matches: [], annotatedImg: null,
+  active_recipe: null,  // V: ricetta caricata (string nome) o null
 };
 
 // ---------- Forms ----------
@@ -307,7 +308,42 @@ function setupROI() {
 }
 
 // ---------- Match action ----------
+async function doMatchRecipe() {
+  if (!state.scene) { setStatus("Carica scena"); return; }
+  setStatus(`Match ricetta ${state.active_recipe}...`);
+  const hc = readHalconFlags();
+  const body = {
+    recipe: state.active_recipe,
+    scene_id: state.scene.id,
+    min_score: parseFloat(document.getElementById("p-min-score").value),
+    max_matches: parseInt(document.getElementById("p-max-matches").value, 10),
+    verify_threshold: 0.50,
+    ...hc,
+  };
+  const r = await fetch("/match_recipe", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) { setStatus(`Errore: ${await r.text()}`); return; }
+  const data = await r.json();
+  state.matches = data.matches;
+  state.annotatedImg = await loadImage(
+    `/image/${data.annotated_id}/raw?t=${Date.now()}`);
+  renderScene();
+  renderLegend();
+  document.getElementById("t-train").textContent = "—";
+  document.getElementById("t-find").textContent = `${data.find_time.toFixed(2)}s`;
+  document.getElementById("t-var").textContent = data.num_variants;
+  document.getElementById("t-match").textContent = data.matches.length;
+  setStatus(`${data.matches.length} match trovati (ricetta ${state.active_recipe})`);
+}
+
 async function doMatch() {
+  // Path V: ricetta caricata → bypass training, solo find su scena
+  if (state.active_recipe) {
+    return doMatchRecipe();
+  }
   if (!state.model) { setStatus("Carica modello"); return; }
   if (!state.scene) { setStatus("Carica scena"); return; }
   if (!state.roi) { setStatus("Seleziona ROI sul modello"); return; }
@@ -400,6 +436,104 @@ function setStatus(s) {
 }
 
 // ---------- Init ----------
+// ---------- Auto-tune (Halcon-style) ----------
+async function doAutoTune() {
+  if (!state.model || !state.roi) {
+    alert("Seleziona modello e disegna ROI prima di Auto-tune.");
+    return;
+  }
+  const status = document.getElementById("status");
+  status.textContent = "Analisi ROI in corso...";
+  try {
+    const r = await fetch("/auto_tune", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model_id: state.model.id,
+        roi: state.roi,
+      }),
+    });
+    if (!r.ok) throw new Error(await r.text());
+    const t = await r.json();
+    // Applica ai campi avanzati (override automatico)
+    for (const [key] of ADV_PARAMS) {
+      const el = document.getElementById(`adv-${key}`);
+      if (el && t[key] !== undefined) el.value = String(t[key]);
+    }
+    // Espandi la sezione Avanzate per mostrare i valori applicati
+    const advDetails = document.querySelector("#col-params details:last-of-type");
+    if (advDetails) advDetails.open = true;
+    // Feedback diagnostico
+    const lines = [
+      `weak/strong: ${t.weak_grad} / ${t.strong_grad}`,
+      `feature: ${t.num_features}, piramide: ${t.pyramid_levels}`,
+      `angle: [${t.angle_min}..${t.angle_max}]@${t.angle_step}°`,
+    ];
+    if (t._symmetry_order > 1) {
+      lines.push(`simmetria rotaz. ${t._symmetry_order}x (conf ${t._symmetry_conf})`);
+    }
+    if (t._self_score !== undefined) {
+      lines.push(`self-validation: ${t._validation}`);
+    }
+    status.textContent = `Auto-tune OK — ${lines[0]}`;
+    alert("Auto-tune completato:\n\n" + lines.join("\n"));
+  } catch (e) {
+    status.textContent = `Auto-tune errore: ${e.message}`;
+    alert(`Errore auto-tune: ${e.message}`);
+  }
+}
+
+// ---------- V: Recipe load/list/unload ----------
+async function refreshRecipeList() {
+  try {
+    const r = await fetch("/recipes");
+    if (!r.ok) return;
+    const j = await r.json();
+    const sel = document.getElementById("hc-recipe-list");
+    const cur = sel.value;
+    sel.innerHTML = '<option value="">— ricette disponibili —</option>';
+    for (const f of j.files) {
+      const o = document.createElement("option");
+      o.value = f.name;
+      o.textContent = `${f.name}  (${(f.size / 1024).toFixed(1)} KB)`;
+      sel.appendChild(o);
+    }
+    if (cur) sel.value = cur;
+  } catch (e) { /* silent */ }
+}
+
+async function loadRecipe() {
+  const sel = document.getElementById("hc-recipe-list");
+  const name = sel.value;
+  if (!name) {
+    alert("Seleziona una ricetta dalla lista.");
+    return;
+  }
+  try {
+    const r = await fetch(`/recipes/${encodeURIComponent(name)}/load`, {
+      method: "POST",
+    });
+    if (!r.ok) throw new Error(await r.text());
+    const j = await r.json();
+    state.active_recipe = j.name;
+    document.getElementById("recipe-status").textContent =
+      `Caricata: ${j.name} — ${j.n_variants} varianti, ` +
+      `${j.template_size[0]}x${j.template_size[1]} px` +
+      (j.use_polarity ? " (polarity)" : "");
+    document.getElementById("recipe-status").style.color = "#0c0";
+    document.getElementById("btn-unload-recipe").disabled = false;
+  } catch (e) {
+    alert(`Errore caricamento: ${e.message}`);
+  }
+}
+
+function unloadRecipe() {
+  state.active_recipe = null;
+  document.getElementById("recipe-status").textContent = "Nessuna ricetta caricata";
+  document.getElementById("recipe-status").style.color = "#888";
+  document.getElementById("btn-unload-recipe").disabled = true;
+}
+
 // ---------- V: Save recipe ----------
 async function saveRecipe() {
   if (!state.model || !state.roi) {
@@ -433,6 +567,7 @@ async function saveRecipe() {
     if (!r.ok) throw new Error(await r.text());
     const j = await r.json();
     alert(`Ricetta salvata: ${j.name}\n${j.n_variants} varianti, ${j.size} bytes`);
+    refreshRecipeList();
   } catch (e) {
     alert(`Errore salvataggio: ${e.message}`);
   }
@@ -465,8 +600,14 @@ window.addEventListener("DOMContentLoaded", async () => {
     e.target.value = "";  // consente re-upload stesso file
   });
   document.getElementById("btn-match").addEventListener("click", doMatch);
+  document.getElementById("btn-autotune").addEventListener("click", doAutoTune);
   document.getElementById("btn-save-recipe").addEventListener("click",
     saveRecipe);
+  document.getElementById("btn-load-recipe").addEventListener("click",
+    loadRecipe);
+  document.getElementById("btn-unload-recipe").addEventListener("click",
+    unloadRecipe);
+  refreshRecipeList();
   const slider = document.getElementById("p-min-score");
   slider.addEventListener("input", (e) => {
     document.getElementById("v-score").textContent =

pm2d/web/static/index.html

@@ -26,6 +26,10 @@
       <div class="picker-list"></div>
     </div>
     <button class="btn btn-go" id="btn-match">▶ MATCH</button>
+    <button class="btn" id="btn-autotune"
+            title="Analizza ROI e derivata parametri ottimali (Halcon-style)">
+      ⚙ Auto-tune
+    </button>
     <label class="btn" title="Carica nuovo file nella cartella immagini">
       ⬆ Carica file
       <input type="file" id="file-upload" accept="image/*" hidden>
@@ -186,6 +190,16 @@
             <input type="text" id="hc-recipe-name" placeholder="nome_ricetta" style="flex:1">
             <button class="btn" id="btn-save-recipe" type="button">💾 Salva</button>
           </div>
+          <div style="display:flex; gap:6px; margin-top:6px; align-items:center">
+            <select id="hc-recipe-list" style="flex:1">
+              <option value="">— ricette disponibili —</option>
+            </select>
+            <button class="btn" id="btn-load-recipe" type="button">📂 Carica</button>
+            <button class="btn" id="btn-unload-recipe" type="button" disabled>✖ Stacca</button>
+          </div>
+          <div id="recipe-status" style="margin-top:4px; font-size:11px; color:#888">
+            Nessuna ricetta caricata
+          </div>
         </div>
       </div>
     </details>