Acquisizione: pagina, attributo hidden rispettato, indicatori su una riga, mirino a 2 px (#87 )

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB
Acquisizione: pagina nuova con anteprima, parametri camera e stile TMF (#87 )
2026-10-24 14:41:25 +02:00 · 2026-10-24 14:38:39 +02:00 · 2026-10-24 13:54:25 +02:00 · 2026-10-24 13:53:01 +02:00 · 2026-10-24 10:17:47 +02:00 · 2026-10-24 10:17:45 +02:00
7 changed files with 1433 additions and 122 deletions
@@ -1,80 +1,194 @@
-"""Pagina HTML della calibrazione a scacchiera (servita da camera_service su /calibrazione, #83).
+"""Pagina HTML dell'acquisizione camera (servita da camera_service su /calibrazione e /acquisizione, #83 #87).

-Cosa fa: una pagina sola, autonoma e offline (niente CDN, JS e CSS inline), in
-italiano. Parla con le rotte dello stesso servizio (/camera/sources,
-/camera/calibration, /camera/calibrate).
-#84: calibrazione densa, un solo dato dell'operatore (lato dello scacco in mm):
-scacchiera che riempie il campo, griglia trovata da sola, mappa di distorsione.
+Cosa fa: una pagina sola, autonoma e offline (niente CDN, niente font esterni,
+JS e CSS inline), in italiano, stile scuro TMF. Quattro sezioni: Sorgente,
+Anteprima (dal vivo, con nitidezza/saturazione/livello medio), Parametri camera
+(esposizione e guadagno), Calibrazione a scacchiera.
+Parla con le rotte dello stesso servizio: /camera/sources, /camera/anteprima,
+/camera/parametri, /camera/parametri/salva, /camera/calibration, /camera/calibrate.
+#84: calibrazione densa, un solo dato dell'operatore (lato dello scacco in mm).
+#87: anteprima, parametri camera, stile TMF.
 Dipende da: niente. E' una stringa, cosi' il pacchetto compilato non ha file dati.
 """

-PAGINA = """<!doctype html>
+PAGINA = r"""<!doctype html>
 <html lang="it">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Calibrazione camera</title>
+<title>Acquisizione camera</title>
 <style>
-  body { font-family: system-ui, sans-serif; margin: 0; background: #f3f4f6; color: #1f2937; }
-  main { max-width: 960px; margin: 0 auto; padding: 16px; }
-  h1 { font-size: 1.4rem; margin: 0 0 12px; }
-  .scheda { background: #fff; border: 1px solid #d1d5db; border-radius: 8px; padding: 14px; margin-bottom: 14px; }
-  label { display: block; font-size: .85rem; margin-bottom: 4px; color: #4b5563; }
-  select, input[type=number] { padding: 6px 8px; font-size: 1rem; border: 1px solid #9ca3af; border-radius: 6px; }
-  .riga { display: flex; flex-wrap: wrap; gap: 12px; align-items: flex-end; }
-  button { padding: 8px 14px; font-size: 1rem; border: 0; border-radius: 6px; background: #2563eb; color: #fff; cursor: pointer; }
-  button.secondario { background: #6b7280; }
+  /* #87: stile scuro TMF (slate/blu), font di sistema */
+  :root { --sfondo: #0f172a; --pannello: #1e293b; --bordo: #334155; --accento: #3b82f6;
+          --testo: #e2e8f0; --secondario: #94a3b8; --errore: #f87171; --ok: #4ade80; --avviso: #fbbf24; }
+  * { box-sizing: border-box; }
+  [hidden] { display: none !important; }  /* #87: vale anche dove il CSS imposta display */
+  body { font-family: "Segoe UI", system-ui, sans-serif; margin: 0; background: var(--sfondo); color: var(--testo); }
+  main { max-width: 1500px; margin: 0 auto; padding: 14px; }
+  h1 { font-size: 1.35rem; margin: 0 0 12px; }
+  h2 { font-size: 1.02rem; margin: 0 0 10px; }
+  .griglia { display: grid; grid-template-columns: minmax(0, 1.7fr) minmax(320px, 1fr); gap: 14px; align-items: start; }
+  .colonna { display: flex; flex-direction: column; gap: 14px; min-width: 0; }
+  .scheda { background: var(--pannello); border: 1px solid var(--bordo); border-radius: 8px; padding: 14px; }
+  label { display: block; font-size: .82rem; margin-bottom: 4px; color: var(--secondario); }
+  select, input[type=text] { padding: 6px 8px; font-size: .95rem; color: var(--testo); background: var(--sfondo);
+          border: 1px solid var(--bordo); border-radius: 6px; font-family: inherit; }
+  select { max-width: 100%; }
+  select:focus, input:focus, button:focus-visible { outline: 2px solid var(--accento); outline-offset: 1px; }
+  input[type=range] { width: 100%; accent-color: var(--accento); }
+  input[type=checkbox] { accent-color: var(--accento); }
+  .riga { display: flex; flex-wrap: wrap; gap: 10px; align-items: flex-end; }
+  .nota { font-size: .82rem; color: var(--secondario); margin: 8px 0 0; }
+  button { padding: 7px 13px; font-size: .95rem; border: 0; border-radius: 6px; background: var(--accento); color: #fff;
+           cursor: pointer; font-family: inherit; }
+  button.secondario { background: var(--bordo); color: var(--testo); }
  button.pericolo { background: #b91c1c; }
-  button:disabled { opacity: .5; cursor: default; }
-  .messaggio { margin-top: 10px; font-weight: 600; }
-  .errore { color: #b91c1c; }
-  .ok { color: #15803d; }
-  table { border-collapse: collapse; }
-  td { padding: 3px 14px 3px 0; }
-  td:first-child { color: #4b5563; }
-  img { max-width: 100%; border: 1px solid #d1d5db; border-radius: 6px; margin-top: 8px; }
-  .avviso { color: #92400e; }
+  button:disabled { opacity: .45; cursor: default; }
+  .messaggio { min-height: 1.2em; margin-top: 8px; font-size: .9rem; font-weight: 600; color: var(--secondario); }
+  .errore { color: var(--errore); }
+  .ok { color: var(--ok); }
+  .avviso { color: var(--avviso); font-size: .88rem; }
+  table { border-collapse: collapse; font-size: .88rem; }
+  td { padding: 2px 14px 2px 0; }
+  td:first-child { color: var(--secondario); }
+  .stato { font-size: .9rem; color: var(--secondario); margin-top: 8px; }
+  /* anteprima */
+  .palco { background: #020617; border: 1px solid var(--bordo); border-radius: 6px; min-height: 340px;
+           display: flex; align-items: center; justify-content: center; margin-top: 10px; overflow: hidden; }
+  .cornice { position: relative; display: inline-block; line-height: 0; max-width: 100%; }
+  .cornice img { max-width: 100%; max-height: calc(100vh - 330px); min-height: 200px; border: 0; margin: 0; }
+  #mirino { position: absolute; inset: 0; pointer-events: none;
+            background: linear-gradient(#fbbf24, #fbbf24) center / 2px 100% no-repeat,
+                        linear-gradient(#fbbf24, #fbbf24) center / 100% 2px no-repeat; opacity: .85; }
+  #vuoto { padding: 30px 16px; color: var(--secondario); text-align: center; }
+  .indicatori { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; margin-top: 10px; }
+  .indicatore { background: var(--sfondo); border: 1px solid var(--bordo); border-radius: 6px; padding: 8px 10px; }
+  .indicatore .nome { font-size: .78rem; color: var(--secondario); }
+  .indicatore .valore { font-size: 1.35rem; font-weight: 600; font-variant-numeric: tabular-nums; }
+  .indicatore .piccolo { font-size: .76rem; color: var(--secondario); }
+  .barra { height: 6px; background: var(--bordo); border-radius: 3px; margin-top: 4px; overflow: hidden; }
+  .barra > div { height: 100%; width: 0; background: var(--accento); transition: width .15s; }
+  .rosso { color: var(--errore); }
+  /* parametri */
+  .parametro { margin-bottom: 12px; }
+  .parametro .campo { display: flex; align-items: center; gap: 6px; }
+  .parametro .campo input[type=text] { width: 110px; text-align: right; flex: none; }
+  .parametro .unita { font-size: .82rem; color: var(--secondario); min-width: 2.2em; }
+  .parametro .limiti { font-size: .75rem; color: var(--secondario); }
+  @media (max-width: 900px) {
+    .griglia { grid-template-columns: minmax(0, 1fr); }
+    .cornice img { max-height: 60vh; }
+  }
 </style>
 </head>
 <body>
 <main>
-  <h1>Calibrazione camera con scacchiera</h1>
+  <h1>Acquisizione camera</h1>

-  <div class="scheda">
-    <div class="riga">
-      <div><label for="sorgente">Sorgente</label><select id="sorgente"></select></div>
-      <div><label for="quadrato">Lato dello scacco (mm)</label><input id="quadrato" type="number" min="0.001" step="any" value="2"></div>
+  <div class="griglia">
+    <div class="colonna">
+      <!-- #87: sezione Anteprima -->
+      <section class="scheda" id="sezioneAnteprima">
+        <h2>Anteprima</h2>
+        <div class="riga">
+          <button id="avvia">Avvia anteprima</button>
+          <button id="ferma" class="secondario" disabled>Ferma anteprima</button>
+          <button id="scatta" class="secondario">Scatta</button>
+          <label style="margin:0 0 6px"><input id="grezzo" type="checkbox"> Immagine grezza (senza correzione)</label>
+          <label style="margin:0 0 6px"><input id="mirinoCasella" type="checkbox"> Mirino centrale</label>
+        </div>
+        <div class="palco">
+          <div id="vuoto">Anteprima ferma. Premere «Avvia anteprima» o «Scatta».</div>
+          <div class="cornice" id="cornice" hidden>
+            <img id="immagine" alt="Anteprima della camera">
+            <div id="mirino" hidden></div>
+          </div>
+        </div>
+        <div class="indicatori">
+          <div class="indicatore">
+            <div class="nome">Nitidezza</div>
+            <div class="valore" id="nitidezza">-</div>
+            <div class="barra"><div id="barraNitidezza"></div></div>
+            <div class="piccolo">massimo visto: <span id="nitidezzaMax">-</span>
+              <button id="azzeraMax" class="secondario" style="padding:1px 7px;font-size:.75rem;margin-left:6px">Azzera</button></div>
+          </div>
+          <div class="indicatore">
+            <div class="nome">Saturati</div>
+            <div class="valore" id="saturati">-</div>
+            <div class="piccolo">pixel a 250 o più; da tenere sotto l'1 %</div>
+          </div>
+          <div class="indicatore">
+            <div class="nome">Livello medio</div>
+            <div class="valore" id="media">-</div>
+            <div class="piccolo">scala 0-255</div>
+          </div>
+          <div class="indicatore">
+            <div class="nome">Frame pieno</div>
+            <div class="valore" id="dimensioni">-</div>
+            <div class="piccolo" id="raddrizzato">&nbsp;</div>
+          </div>
+        </div>
+        <div id="msgAnteprima" class="messaggio"></div>
+      </section>
    </div>
-    <p style="font-size:.85rem;color:#4b5563;margin:10px 0 0">
-      Servono una scacchiera che riempie tutto il campo della camera, piana, ferma e ben illuminata, e il lato di uno scacco.
-      La griglia si trova da sola; il risultato corregge anche la distorsione dell'ottica.</p>
-  </div>

-  <div class="scheda">
-    <div class="riga">
-      <button id="acquisisci">Acquisisci e calibra</button>
-      <div><label for="file">oppure un file immagine</label><input id="file" type="file" accept="image/*"></div>
-      <button id="carica" class="secondario">Carica immagine e calibra</button>
-    </div>
-    <div id="messaggio" class="messaggio"></div>
-  </div>
+    <div class="colonna">
+      <!-- #87: sezione Sorgente -->
+      <section class="scheda" id="sezioneSorgente">
+        <h2>Sorgente</h2>
+        <label for="sorgente">Camera o cartella</label>
+        <select id="sorgente"></select>
+        <div class="stato" id="statoSorgente">-</div>
+        <div id="msgSorgente" class="messaggio"></div>
+      </section>

-  <div class="scheda" id="risultato" hidden>
-    <strong>Risultato del calcolo</strong>
-    <table id="tabella"></table>
-    <div id="avviso" class="avviso"></div>
-    <div class="riga" style="margin-top:10px">
-      <button id="salva">Salva</button>
-      <span style="font-size:.85rem;color:#4b5563">Da camera, salvando si acquisisce e si calcola di nuovo: tenere la scacchiera ferma.</span>
-    </div>
-    <img id="overlay" alt="Angoli trovati sulla scacchiera">
-  </div>
+      <!-- #87: sezione Parametri camera -->
+      <section class="scheda" id="sezioneParametri">
+        <h2>Parametri camera</h2>
+        <div id="parametri"><div class="nota">-</div></div>
+        <div class="riga" id="salvaParametriRiga" hidden>
+          <button id="salvaParametri" class="secondario">Salva come predefiniti</button>
+        </div>
+        <div id="msgParametri" class="messaggio"></div>
+      </section>

-  <div class="scheda">
-    <strong>Calibrazione salvata</strong>
-    <div id="stato">-</div>
-    <div class="riga" style="margin-top:10px">
-      <button id="elimina" class="pericolo" disabled>Elimina</button>
+      <section class="scheda" id="sezioneCalibrazione">
+        <h2>Calibrazione</h2>
+        <div class="riga">
+          <div><label for="quadrato">Lato dello scacco (mm)</label><input id="quadrato" type="text" inputmode="decimal" value="2" size="8"></div>
+        </div>
+        <p class="nota">
+          Servono una scacchiera che riempie tutto il campo della camera, piana, ferma e ben illuminata, e il lato di uno scacco.
+          La griglia si trova da sola; il risultato corregge anche la distorsione dell'ottica.
+          Durante il calcolo l'anteprima si sospende.</p>
+        <div class="riga" style="margin-top:10px">
+          <button id="acquisisci">Acquisisci e calibra</button>
+          <button id="scegliFile" class="secondario">Scegli immagine...</button>
+          <input id="file" type="file" accept="image/*" hidden>
+          <span id="nomeFile" class="nota" style="margin:0 0 6px">nessuna immagine scelta</span>
+          <button id="carica" class="secondario">Carica immagine e calibra</button>
+        </div>
+        <div id="messaggio" class="messaggio"></div>
+
+        <div id="risultato" hidden style="margin-top:10px">
+          <strong>Risultato del calcolo</strong>
+          <table id="tabella"></table>
+          <div id="avviso" class="avviso"></div>
+          <div class="riga" style="margin-top:10px">
+            <button id="salva">Salva</button>
+            <span class="nota" style="margin:0 0 6px">Da camera, salvando si acquisisce e si calcola di nuovo: tenere la scacchiera ferma.</span>
+          </div>
+          <img id="overlay" alt="Angoli trovati sulla scacchiera" style="max-width:100%;margin-top:8px;border:1px solid var(--bordo);border-radius:6px">
+        </div>
+
+        <div style="margin-top:14px">
+          <strong>Calibrazione salvata</strong>
+          <div id="stato" class="stato">-</div>
+          <div class="riga" style="margin-top:10px">
+            <button id="elimina" class="pericolo" disabled>Elimina calibrazione</button>
+          </div>
+        </div>
+      </section>
    </div>
  </div>
 </main>
@@ -82,31 +196,437 @@ PAGINA = """<!doctype html>
 <script>
 "use strict";
 var $ = function (id) { return document.getElementById(id); };
-var ultimo = null;  // ultimo calcolo, per «Salva»
+var ultimo = null;  // ultimo calcolo di calibrazione, per «Salva»

-function messaggio(testo, classe) {
-  var m = $("messaggio");
+// ---- utilita'
+
+// numero all'italiana (virgola decimale); cifre = decimali fissi, omesso = fino a 4
+function fmt(v, cifre) {
+  var n = Number(v);
+  if (!isFinite(n)) return "-";
+  var o = cifre === undefined ? { maximumFractionDigits: 4 } : { minimumFractionDigits: cifre, maximumFractionDigits: cifre };
+  return n.toLocaleString("it-IT", o);
+}
+// numero senza separatore delle migliaia, per le caselle di input
+function fmtCasella(v) { return Number(v).toLocaleString("it-IT", { maximumFractionDigits: 6, useGrouping: false }); }
+// legge un numero scritto con virgola o con punto
+function leggiNumero(testo) {
+  var n = Number(String(testo).split(" ").join("").replace(",", "."));
+  return isFinite(n) && String(testo).trim() !== "" ? n : NaN;
+}
+function dataItaliana(iso) {
+  var d = new Date(iso);
+  if (isNaN(d.getTime())) return String(iso);
+  return d.toLocaleString("it-IT", { day: "2-digit", month: "2-digit", year: "numeric", hour: "2-digit", minute: "2-digit" }).replace(",", "");
+}
+function dire(id, testo, classe) {
+  var m = $(id);
  m.textContent = testo || "";
  m.className = "messaggio " + (classe || "");
 }
+function messaggio(testo, classe) { dire("messaggio", testo, classe); }
+function pausa(ms) { return new Promise(function (r) { setTimeout(r, ms); }); }
+function memoria(chiave, valore) {  // localStorage sempre protetto: puo' essere bloccato
+  try {
+    if (valore === undefined) return localStorage.getItem(chiave);
+    localStorage.setItem(chiave, valore);
+  } catch (e) { /* niente memoria, la pagina funziona lo stesso */ }
+  return null;
+}

-function numero(v, cifre) { return Number(v).toFixed(cifre); }
+// testo d'errore da una risposta; #87: rotte nuove assenti in un servizio vecchio -> messaggio chiaro
+async function dettaglio(risposta) {
+  var testo;
+  try { var j = await risposta.json(); testo = j.detail || JSON.stringify(j); }
+  catch (e) { testo = "errore " + risposta.status; }
+  if (testo === "Not Found" || testo === "Method Not Allowed") {
+    return "Funzione non disponibile: il servizio della camera è una versione più vecchia (errore " + risposta.status + ").";
+  }
+  return typeof testo === "string" ? testo : JSON.stringify(testo);
+}
+
+// ---- Sorgente
+
+async function caricaSorgenti() {
+  var sel = $("sorgente");
+  try {
+    var r = await fetch("/camera/sources");
+    var j = await r.json();
+    (j.sources || []).forEach(function (s) {
+      var o = document.createElement("option");
+      o.value = s.name;
+      o.textContent = s.label || s.name;
+      sel.appendChild(o);
+    });
+  } catch (e) { dire("msgSorgente", "Elenco delle sorgenti non disponibile.", "errore"); }
+  if (!sel.options.length) dire("msgSorgente", "Nessuna sorgente camera trovata.", "errore");
+  var ricordata = memoria("tmf.acq.sorgente");  // #87: ultima scelta ricordata
+  if (ricordata) {
+    for (var i = 0; i < sel.options.length; i++) if (sel.options[i].value === ricordata) sel.value = ricordata;
+  }
+  cambioSorgente(false);
+}
+
+// #87: cambiando sorgente si azzerano gli indicatori e si rileggono parametri e calibrazione
+function cambioSorgente(salva) {
+  if (salva) memoria("tmf.acq.sorgente", $("sorgente").value);
+  var era = A.attiva;
+  fermaAnteprima();
+  azzeraIndicatori();
+  dire("msgAnteprima", "");
+  aggiornaStato();
+  caricaParametri();
+  if (era) avviaAnteprima();
+}
+
+// ---- Anteprima (#87)
+
+var A = { attiva: false, gen: 0, inVolo: false, url: null, nitMax: 0 };
+
+function azzeraIndicatori() {
+  A.nitMax = 0;
+  ["nitidezza", "saturati", "media", "dimensioni", "nitidezzaMax"].forEach(function (i) { $(i).textContent = "-"; });
+  $("saturati").className = "valore";
+  $("barraNitidezza").style.width = "0";
+  $("raddrizzato").textContent = " ";
+}
+
+function pulsantiAnteprima() {
+  $("avvia").disabled = A.attiva;
+  $("ferma").disabled = !A.attiva;
+}
+
+function mostraImmagine(blob) {
+  var vecchio = A.url;
+  A.url = URL.createObjectURL(blob);
+  $("immagine").src = A.url;
+  if (vecchio) URL.revokeObjectURL(vecchio);  // niente memoria che cresce a ogni frame
+  $("cornice").hidden = false;
+  $("vuoto").hidden = true;
+}
+
+function aggiornaIndicatori(h) {
+  var nit = parseFloat(h.get("X-Nitidezza"));
+  var sat = parseFloat(h.get("X-Saturati-Pct"));
+  var media = parseFloat(h.get("X-Media"));
+  if (isFinite(nit)) {
+    if (nit > A.nitMax) A.nitMax = nit;
+    $("nitidezza").textContent = fmt(nit, 1);
+    $("nitidezzaMax").textContent = fmt(A.nitMax, 1);
+    $("barraNitidezza").style.width = (A.nitMax > 0 ? Math.round(100 * nit / A.nitMax) : 0) + "%";
+  }
+  if (isFinite(sat)) {
+    $("saturati").textContent = fmt(sat, 2) + " %";
+    $("saturati").className = "valore" + (sat > 1 ? " rosso" : "");  // oltre l'1 % si perde dettaglio
+  }
+  if (isFinite(media)) $("media").textContent = fmt(media, 1);
+  var w = h.get("X-Larghezza"), a = h.get("X-Altezza");
+  if (w && a) $("dimensioni").textContent = fmt(w, 0) + " x " + fmt(a, 0);
+  var r = h.get("X-Raddrizzato");
+  $("raddrizzato").textContent = r === "si" ? "raddrizzata dalla calibrazione" : r === "no" ? "non raddrizzata" : " ";
+}
+
+// una richiesta di anteprima; ritorna "ok" | "errore" | "fatale" (errore che non passa riprovando)
+async function unaAnteprima(lato) {
+  var sorgente = $("sorgente").value;
+  if (!sorgente) { dire("msgAnteprima", "Scegliere una sorgente.", "errore"); return "fatale"; }
+  var g = A.gen;
+  A.inVolo = true;
+  try {
+    var r = await fetch("/camera/anteprima", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ source: sorgente, grezzo: $("grezzo").checked, lato_max: lato, timeout_ms: 5000 })
+    });
+    if (!r.ok) {
+      var d = await dettaglio(r);
+      if (g === A.gen) dire("msgAnteprima", d, "errore");
+      return r.status >= 500 ? "errore" : "fatale";  // 503/504: la camera puo' tornare
+    }
+    var blob = await r.blob();
+    if (g !== A.gen) return "ok";  // frame di una sorgente o di un ciclo ormai chiuso: si scarta
+    mostraImmagine(blob);
+    aggiornaIndicatori(r.headers);
+    dire("msgAnteprima", "");
+    return "ok";
+  } catch (e) {
+    if (g === A.gen) dire("msgAnteprima", "Servizio non raggiungibile.", "errore");
+    return "errore";
+  } finally {
+    A.inVolo = false;
+  }
+}
+
+// ciclo sequenziale: la richiesta dopo parte solo a risposta arrivata, almeno 300 ms dopo la precedente
+async function ciclo(g) {
+  while (A.inVolo) await pausa(50);
+  while (A.attiva && g === A.gen) {
+    var t0 = Date.now();
+    var esito = await unaAnteprima(1280);
+    if (g !== A.gen) return;
+    if (esito === "fatale") { fermaAnteprima(); return; }
+    await pausa(esito === "errore" ? 1500 : Math.max(300 - (Date.now() - t0), 0));
+  }
+}
+
+function avviaAnteprima() {
+  if (A.attiva) return;
+  A.attiva = true;
+  A.gen++;
+  pulsantiAnteprima();
+  ciclo(A.gen);
+}
+
+function fermaAnteprima() {
+  A.attiva = false;
+  A.gen++;
+  pulsantiAnteprima();
+}
+
+// «Scatta»: ferma il ciclo e mostra un frame solo, alla risoluzione piena (fino a 4096 px)
+async function scatta() {
+  fermaAnteprima();
+  $("scatta").disabled = true;
+  dire("msgAnteprima", "Scatto in corso...", "");
+  while (A.inVolo) await pausa(50);
+  await unaAnteprima(4096);
+  $("scatta").disabled = false;
+}
+
+$("avvia").onclick = avviaAnteprima;
+$("ferma").onclick = fermaAnteprima;
+$("scatta").onclick = scatta;
+$("azzeraMax").onclick = function () { A.nitMax = 0; $("nitidezzaMax").textContent = "-"; $("barraNitidezza").style.width = "0"; };
+$("mirinoCasella").onchange = function () { $("mirino").hidden = !$("mirinoCasella").checked; };
+
+// ---- Parametri camera (#87)
+
+var ORDINE = ["esposizione", "esposizione_auto", "guadagno", "guadagno_auto"];
+var ETICHETTE = { esposizione: "Esposizione", esposizione_auto: "Esposizione automatica",
+                  guadagno: "Guadagno", guadagno_auto: "Guadagno automatico" };
+var UNITA = { esposizione: "µs", guadagno: "dB" };
+var ETICHETTE_SCELTE = { Off: "Spenta", Once: "Una volta", Continuous: "Continua" };
+var P = { el: {}, dati: {}, pendenti: {}, timer: null, inScrittura: false, gen: 0 };
+
+function usaLog(d) { return typeof d.min === "number" && typeof d.max === "number" && d.min > 0 && d.max / d.min >= 100; }
+function haCursore(d) { return typeof d.min === "number" && typeof d.max === "number" && d.max > d.min; }
+function aPosizione(d, v) {
+  var t = usaLog(d) ? Math.log(Math.max(v, d.min) / d.min) / Math.log(d.max / d.min) : (v - d.min) / (d.max - d.min);
+  return Math.round(1000 * Math.min(Math.max(t, 0), 1));
+}
+function daPosizione(d, p) {
+  var t = p / 1000;
+  return usaLog(d) ? d.min * Math.pow(d.max / d.min, t) : d.min + t * (d.max - d.min);
+}
+// porta il valore nei limiti e sul passo della camera
+function adatta(d, v) {
+  if (typeof d.min === "number") v = Math.max(v, d.min);
+  if (typeof d.max === "number") v = Math.min(v, d.max);
+  if (typeof d.passo === "number" && d.passo > 0) {
+    var base = typeof d.min === "number" ? d.min : 0;
+    v = base + Math.round((v - base) / d.passo) * d.passo;
+    if (typeof d.max === "number") v = Math.min(v, d.max);
+  }
+  return Number(v.toFixed(6));
+}
+
+async function caricaParametri() {
+  var sorgente = $("sorgente").value;
+  var g = ++P.gen;
+  P.pendenti = {};
+  clearTimeout(P.timer);
+  $("salvaParametriRiga").hidden = true;
+  dire("msgParametri", "");
+  if (!sorgente) { $("parametri").textContent = "-"; return; }
+  try {
+    var r = await fetch("/camera/parametri?source=" + encodeURIComponent(sorgente));
+    if (g !== P.gen) return;
+    if (!r.ok) {
+      $("parametri").textContent = "";
+      dire("msgParametri", await dettaglio(r), "errore");
+      return;
+    }
+    costruisciParametri(await r.json());
+  } catch (e) {
+    if (g === P.gen) dire("msgParametri", "Servizio non raggiungibile.", "errore");
+  }
+}
+
+function costruisciParametri(j) {
+  var box = $("parametri");
+  box.textContent = "";
+  P.el = {};
+  P.dati = j.parametri || {};
+  var nomi = ORDINE.filter(function (n) { return P.dati[n]; });
+  if (!j.regolabile || !nomi.length) {
+    var n = document.createElement("div");
+    n.className = "nota";
+    n.textContent = "Questa sorgente non ha parametri regolabili.";
+    box.appendChild(n);
+    $("salvaParametriRiga").hidden = true;
+    return;
+  }
+  nomi.forEach(function (nome) { box.appendChild(creaParametro(nome, P.dati[nome])); });
+  $("salvaParametriRiga").hidden = false;
+}
+
+function creaParametro(nome, d) {
+  var riga = document.createElement("div");
+  riga.className = "parametro";
+  var et = document.createElement("label");
+  et.textContent = ETICHETTE[nome] + (UNITA[nome] ? " (" + UNITA[nome] + ")" : "");
+  riga.appendChild(et);
+  var el = { tipo: d.tipo };
+  var bloccato = d.scrivibile === false;
+  if (d.tipo === "scelta") {
+    var sel = document.createElement("select");
+    (d.scelte || []).forEach(function (s) {
+      var o = document.createElement("option");
+      o.value = s;
+      o.textContent = ETICHETTE_SCELTE[s] || s;
+      sel.appendChild(o);
+    });
+    sel.value = d.valore;
+    sel.disabled = bloccato;
+    sel.onchange = function () { modifica(nome, sel.value); };
+    riga.appendChild(sel);
+    el.select = sel;
+  } else {
+    var campo = document.createElement("div");
+    campo.className = "campo";
+    var cur = null;
+    var casella = document.createElement("input");
+    if (haCursore(d)) {
+      cur = document.createElement("input");
+      cur.type = "range";
+      cur.min = 0; cur.max = 1000; cur.step = 1;
+      cur.value = aPosizione(d, d.valore);
+      cur.disabled = bloccato;
+      cur.oninput = function () {  // il cursore aggiorna la casella subito, la scrittura arriva dopo 300 ms
+        var v = adatta(d, daPosizione(d, Number(cur.value)));
+        casella.value = fmtCasella(v);
+        modifica(nome, v);
+      };
+      campo.appendChild(cur);
+    }
+    casella.type = "text";
+    casella.inputMode = "decimal";
+    casella.value = fmtCasella(d.valore);
+    casella.disabled = bloccato;
+    casella.onchange = function () {
+      var v = leggiNumero(casella.value);
+      if (isNaN(v)) { dire("msgParametri", "Valore non valido per " + ETICHETTE[nome].toLowerCase() + ".", "errore"); casella.value = fmtCasella(P.dati[nome].valore); return; }
+      v = adatta(d, v);
+      casella.value = fmtCasella(v);
+      if (cur) cur.value = aPosizione(d, v);
+      modifica(nome, v);
+    };
+    campo.appendChild(casella);
+    var u = document.createElement("span");
+    u.className = "unita";
+    u.textContent = UNITA[nome] || "";
+    campo.appendChild(u);
+    riga.appendChild(campo);
+    if (typeof d.min === "number" || typeof d.max === "number") {
+      var lim = document.createElement("div");
+      lim.className = "limiti";
+      lim.textContent = "da " + (typeof d.min === "number" ? fmt(d.min) : "?") + " a " + (typeof d.max === "number" ? fmt(d.max) : "?") +
+        (typeof d.passo === "number" ? ", passo " + fmt(d.passo) : "") + (usaLog(d) ? " (cursore logaritmico)" : "");
+      riga.appendChild(lim);
+    }
+    el.cursore = cur;
+    el.casella = casella;
+  }
+  P.el[nome] = el;
+  return riga;
+}
+
+// una modifica dell'operatore: si accoda e parte dopo 300 ms dall'ultima
+function modifica(nome, valore) {
+  P.pendenti[nome] = valore;
+  var aut = nome + "_auto";
+  // impostare un valore manuale spegne prima l'automatico corrispondente
+  if ((nome === "esposizione" || nome === "guadagno") && P.el[aut] && P.el[aut].select && P.el[aut].select.value !== "Off") {
+    P.pendenti[aut] = "Off";
+    P.el[aut].select.value = "Off";
+  }
+  clearTimeout(P.timer);
+  P.timer = setTimeout(scriviParametri, 300);
+}
+
+async function scriviParametri() {
+  if (P.inScrittura) { P.timer = setTimeout(scriviParametri, 100); return; }
+  var valori = P.pendenti;
+  P.pendenti = {};
+  if (!Object.keys(valori).length) return;
+  P.inScrittura = true;
+  try {
+    var r = await fetch("/camera/parametri", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ source: $("sorgente").value, valori: valori })
+    });
+    if (!r.ok) {
+      dire("msgParametri", await dettaglio(r), "errore");
+      if (r.status !== 404 && r.status !== 405) caricaParametri();  // si rilegge cosa ha la camera
+      return;
+    }
+    aggiornaValori(await r.json());
+    dire("msgParametri", "Parametri applicati.", "ok");
+  } catch (e) {
+    dire("msgParametri", "Servizio non raggiungibile.", "errore");
+  } finally {
+    P.inScrittura = false;
+  }
+}
+
+// rilegge i valori dalla risposta, lasciando stare quelli che l'operatore sta ancora toccando
+function aggiornaValori(j) {
+  var dati = j.parametri || {};
+  Object.keys(dati).forEach(function (nome) {
+    var el = P.el[nome], d = dati[nome];
+    if (!el || P.pendenti.hasOwnProperty(nome)) return;
+    P.dati[nome].valore = d.valore;
+    if (el.select) el.select.value = d.valore;
+    if (el.casella && document.activeElement !== el.casella) el.casella.value = fmtCasella(d.valore);
+    if (el.cursore && document.activeElement !== el.cursore) el.cursore.value = aPosizione(P.dati[nome], d.valore);
+  });
+}
+
+$("salvaParametri").onclick = async function () {
+  $("salvaParametri").disabled = true;
+  try {
+    var r = await fetch("/camera/parametri/salva", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ source: $("sorgente").value })
+    });
+    if (!r.ok) dire("msgParametri", await dettaglio(r), "errore");
+    else dire("msgParametri", "Predefiniti salvati: si ricaricano all'apertura della camera.", "ok");
+  } catch (e) {
+    dire("msgParametri", "Servizio non raggiungibile.", "errore");
+  } finally {
+    $("salvaParametri").disabled = false;
+  }
+};
+
+// ---- Calibrazione (logica di #83 e #84; #87: lato precompilato, data italiana, conferma in pagina)

 function righe(d) {
  return [
-    ["Scala", numero(d.px_per_mm, 4) + " px/mm (" + numero(d.mm_per_px, 5) + " mm/px)"],
+    ["Scala", fmt(d.px_per_mm, 4) + " px/mm (" + fmt(d.mm_per_px, 5) + " mm/px)"],
    ["Metodo", d.metodo !== "densa" ? "planare (senza correzione della distorsione)" : "densa (immagine raddrizzata)"],
-    ["Griglia trovata", d.cols + " x " + d.rows + " angoli (" + d.n_corners + ")"]
+    ["Griglia trovata", d.cols + " x " + d.rows + " angoli (" + fmt(d.n_corners, 0) + ")"]
  ].concat(d.metodo !== "densa" ? [
-    ["Errore di riproiezione (RMS)", numero(d.rms_px, 3) + " px"],
-    ["Variazione di scala nell'area", numero(d.scale_spread_pct, 2) + " %"]
+    ["Errore di riproiezione (RMS)", fmt(d.rms_px, 3) + " px"],
+    ["Variazione di scala nell'area", fmt(d.scale_spread_pct, 2) + " %"]
  ] : [
-    ["Residuo massimo", numero(d.residuo_max_px, 3) + " px"],
-    ["Residuo RMS", numero(d.residuo_rms_px, 3) + " px"],
-    ["Copertura del campo", numero(d.copertura_pct, 1) + " %"]
+    ["Residuo massimo", fmt(d.residuo_max_px, 3) + " px"],
+    ["Residuo RMS", fmt(d.residuo_rms_px, 3) + " px"],
+    ["Copertura del campo", fmt(d.copertura_pct, 1) + " %"]
  ]).concat([
-    ["Lato dello scacco", d.square_mm + " mm"],
-    ["Immagine", d.image_width + " x " + d.image_height + " px"]
+    ["Lato dello scacco", fmt(d.square_mm) + " mm"],
+    ["Immagine", fmt(d.image_width, 0) + " x " + fmt(d.image_height, 0) + " px"]
  ]);
 }

@@ -123,58 +643,45 @@ function tabella(el, d) {
  });
 }

-async function dettaglio(risposta) {
-  try { var j = await risposta.json(); return j.detail || JSON.stringify(j); }
-  catch (e) { return "errore " + risposta.status; }
-}
-
-async function caricaSorgenti() {
-  var sel = $("sorgente");
-  try {
-    var r = await fetch("/camera/sources");
-    var j = await r.json();
-    (j.sources || []).forEach(function (s) {
-      var o = document.createElement("option");
-      o.value = s.name;
-      o.textContent = s.label || s.name;
-      sel.appendChild(o);
-    });
-  } catch (e) { messaggio("Elenco delle sorgenti non disponibile.", "errore"); }
-  if (!sel.options.length) messaggio("Nessuna sorgente camera trovata.", "errore");
-  aggiornaStato();
-}
-
 async function aggiornaStato() {
  var sorgente = $("sorgente").value;
  var stato = $("stato");
+  annullaConferma();
  $("elimina").disabled = true;
-  if (!sorgente) { stato.textContent = "-"; return; }
-  var r = await fetch("/camera/calibration?source=" + encodeURIComponent(sorgente));
-  if (r.status === 404) { stato.textContent = "Sorgente non calibrata."; return; }
-  if (!r.ok) { stato.textContent = await dettaglio(r); return; }
-  var d = await r.json();
-  stato.textContent = "";
-  var t = document.createElement("table");
-  tabella(t, d);
-  var quando = document.createElement("div");
-  quando.textContent = "Calibrata il " + d.calibrated_at;
-  stato.appendChild(t);
-  stato.appendChild(quando);
-  $("elimina").disabled = false;
-}
-
-function parametri() {
-  return { quadrato: $("quadrato").value };
+  if (!sorgente) { stato.textContent = "-"; $("statoSorgente").textContent = "-"; return; }
+  try {
+    var r = await fetch("/camera/calibration?source=" + encodeURIComponent(sorgente));
+    if (sorgente !== $("sorgente").value) return;  // nel frattempo si e' cambiata sorgente
+    if (r.status === 404) {
+      stato.textContent = "Sorgente non calibrata.";
+      $("statoSorgente").textContent = "non calibrata";
+      return;
+    }
+    if (!r.ok) { stato.textContent = await dettaglio(r); return; }
+    var d = await r.json();
+    stato.textContent = "";
+    var t = document.createElement("table");
+    tabella(t, d);
+    var quando = document.createElement("div");
+    quando.textContent = "Calibrata il " + dataItaliana(d.calibrated_at);
+    stato.appendChild(t);
+    stato.appendChild(quando);
+    $("elimina").disabled = false;
+    $("statoSorgente").textContent = "calibrata: " + fmt(d.px_per_mm, 2) + " px/mm";
+    if (d.square_mm) $("quadrato").value = fmtCasella(d.square_mm);  // #87: parte dal lato gia' usato
+  } catch (e) {
+    stato.textContent = "Servizio non raggiungibile.";
+  }
 }

 // avvisi sulla qualita' (solo calibrazione densa): copertura bassa o residuo alto
 function avvisi(d) {
  var a = [];
  if (d.metodo !== "densa") {
-    if (d.scale_spread_pct > 1) a.push("Attenzione: la scala varia di " + numero(d.scale_spread_pct, 2) + " % nell'area: scacchiera inclinata o ottica non telecentrica.");
+    if (d.scale_spread_pct > 1) a.push("Attenzione: la scala varia di " + fmt(d.scale_spread_pct, 2) + " % nell'area: scacchiera inclinata o ottica non telecentrica.");
  } else {
-    if (d.copertura_pct < 70) a.push("Attenzione: la scacchiera copre solo il " + numero(d.copertura_pct, 1) + " % del campo (meno del 70 %): la correzione ai bordi non e' misurata.");
-    if (d.residuo_max_px > 0.5) a.push("Attenzione: residuo massimo " + numero(d.residuo_max_px, 3) + " px (oltre 0,5 px): scacchiera non piana, sfocata o con scacchi irregolari.");
+    if (d.copertura_pct < 70) a.push("Attenzione: la scacchiera copre solo il " + fmt(d.copertura_pct, 1) + " % del campo (meno del 70 %): la correzione ai bordi non è misurata.");
+    if (d.residuo_max_px > 0.5) a.push("Attenzione: residuo massimo " + fmt(d.residuo_max_px, 3) + " px (oltre 0,5 px): scacchiera non piana, sfocata o con scacchi irregolari.");
  }
  return a.join(" ");
 }
@@ -182,16 +689,19 @@ function avvisi(d) {
 async function calcola(conFile, salva) {
  var sorgente = $("sorgente").value;
  if (!sorgente) { messaggio("Scegliere una sorgente.", "errore"); return; }
-  var p = parametri();
+  var lato = leggiNumero($("quadrato").value);
+  if (!(lato > 0)) { messaggio("Il lato dello scacco deve essere un numero maggiore di zero.", "errore"); return; }
  var f = new FormData();
  f.append("source", sorgente);
-  f.append("square_mm", p.quadrato);
+  f.append("square_mm", String(lato));  // al servizio sempre con il punto
  f.append("save", salva ? "true" : "false");
  if (conFile) {
    var file = $("file").files[0];
    if (!file) { messaggio("Scegliere un file immagine.", "errore"); return; }
    f.append("image", file);
  }
+  var eraAttiva = A.attiva;  // #87: l'anteprima si sospende e poi riprende
+  if (eraAttiva) fermaAnteprima();
  messaggio("Calcolo in corso...", "");
  ["acquisisci", "carica", "salva"].forEach(function (i) { $(i).disabled = true; });
  try {
@@ -209,6 +719,7 @@ async function calcola(conFile, salva) {
    messaggio("Servizio non raggiungibile.", "errore");
  } finally {
    ["acquisisci", "carica", "salva"].forEach(function (i) { $(i).disabled = false; });
+    if (eraAttiva) avviaAnteprima();
  }
 }

@@ -216,14 +727,37 @@ $("acquisisci").onclick = function () { calcola(false, false); };
 $("carica").onclick = function () { calcola(true, false); };
 // «Salva» rifa il calcolo con save=true sulla stessa origine (altra acquisizione se da camera)
 $("salva").onclick = function () { calcola(ultimo ? ultimo.conFile : false, true); };
+// #87: il pulsante del file e' in italiano, l'input nativo resta nascosto
+$("scegliFile").onclick = function () { $("file").click(); };
+$("file").onchange = function () {
+  $("nomeFile").textContent = $("file").files[0] ? $("file").files[0].name : "nessuna immagine scelta";
+};
+
+// #87: «Elimina calibrazione» chiede conferma in pagina con un secondo clic (niente finestre del browser)
+var confermaTimer = null;
+function annullaConferma() {
+  clearTimeout(confermaTimer);
+  confermaTimer = null;
+  $("elimina").textContent = "Elimina calibrazione";
+}
 $("elimina").onclick = async function () {
+  if (!confermaTimer) {
+    $("elimina").textContent = "Confermi? Clic ancora per eliminare";
+    confermaTimer = setTimeout(annullaConferma, 4000);
+    return;
+  }
+  annullaConferma();
  var sorgente = $("sorgente").value;
-  if (!confirm("Eliminare la calibrazione salvata di " + sorgente + "?")) return;
-  var r = await fetch("/camera/calibration?source=" + encodeURIComponent(sorgente), { method: "DELETE" });
-  messaggio(r.ok ? "Calibrazione eliminata." : await dettaglio(r), r.ok ? "ok" : "errore");
+  try {
+    var r = await fetch("/camera/calibration?source=" + encodeURIComponent(sorgente), { method: "DELETE" });
+    messaggio(r.ok ? "Calibrazione eliminata." : await dettaglio(r), r.ok ? "ok" : "errore");
+  } catch (e) {
+    messaggio("Servizio non raggiungibile.", "errore");
+  }
  aggiornaStato();
 };
-$("sorgente").onchange = aggiornaStato;
+
+$("sorgente").onchange = function () { cambioSorgente(true); };
 caricaSorgenti();
 </script>
 </body>
@@ -0,0 +1,458 @@
+"""Seed per il PC della fiera: utenti, stazione, tre ricette e quattro settimane di misure.
+
+Cosa fa
+  Popola un database TieMeasureFlow (SQLite del pacchetto Windows) cosi' che al primo
+  avvio NON compaia la procedura di setup e la demo abbia gia' qualcosa da mostrare:
+
+  - utenti adriano (admin), maker, capoturno, operatore (password nella costante
+    UTENTI qui sotto, decise da Adriano per la fiera);
+  - la stazione ST-DEFAULT (quella del pacchetto, vedi packaging/windows/avvio.py)
+    con camera_url http://127.0.0.1:8765 e camera_source camera:601020 (Itala);
+  - FIERA-FLANGIA «Flangia Ø80» (5 quote) e FIERA-ALBERO «Albero rettificato»
+    (4 quote), con circa 4 settimane di storico fino a ieri (lun-ven 8-17, una
+    produzione chiusa per giorno, lotti e seriali coerenti, misure con Cpk diversi
+    per quota, una deriva lenta nell'ultima settimana, una quota con 1-3% fuori
+    tolleranza);
+  - FIERA-DXF «Profilo DXF (visione)»: un task dxf_compare senza ricetta di visione
+    (si crea in fiera dal pannello «Crea ricetta da DXF»).
+
+  «Setup fatto» per il backend vuol dire: esiste almeno un utente admin
+  (api/routers/setup.py::_admin_exists), quindi basta creare adriano.
+
+Come si usa (da daitarn, TMF fermo sul PC, su una COPIA del file SQLite)
+    uv run python scripts/seed_fiera.py --db C:/percorso/tmf.db [--replace] [--dry-run]
+                                        [--fine AAAA-MM-GG]
+
+  Il file deve avere gia' lo schema (alembic upgrade head: lo fa l'exe al primo
+  avvio). --replace toglie solo i dati FIERA-* (ricette, misure, produzioni) e li
+  rifa'; senza, un secondo giro non duplica le ricette. Gli utenti e la stazione
+  sono idempotenti: se esistono si aggiornano password, ruoli e camera.
+  --dry-run fa tutto e annulla (stampa i numeri). Il seme casuale e' fisso: stesso
+  comando e stessa data di fine, stessi dati.
+
+Da cosa dipende
+  src.backend (modelli ORM, auth_service, measurement_service), SQLAlchemy +
+  aiosqlite, tzdata su Windows (gia' in pyproject). Non usa MySQL.
+"""
+import argparse
+import asyncio
+import random
+import sys
+from datetime import date, datetime, time, timedelta, timezone
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+from sqlalchemy import delete, event, select
+from sqlalchemy.ext.asyncio import (
+    AsyncSession, async_sessionmaker, create_async_engine,
+)
+
+# La radice del repo nel path, cosi' "src.backend" si importa lanciando lo script da ovunque
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from src.backend.database import async_session_factory  # noqa: E402
+from src.backend.models.orm.measurement import Measurement  # noqa: E402
+from src.backend.models.orm.production import (  # noqa: E402
+    ProductionEvent, ProductionRun,
+)
+from src.backend.models.orm.recipe import Recipe, RecipeVersion  # noqa: E402
+from src.backend.models.orm.setting import RecipeVersionAudit  # noqa: E402
+from src.backend.models.orm.station import (  # noqa: E402
+    Station, StationRecipeAssignment,
+)
+from src.backend.models.orm.task import RecipeSubtask, RecipeTask  # noqa: E402
+from src.backend.models.orm.task_result import TaskResult  # noqa: E402
+from src.backend.models.orm.user import User  # noqa: E402
+from src.backend.services import auth_service  # noqa: E402
+from src.backend.services.measurement_service import calculate_pass_fail  # noqa: E402
+
+CODES = ("FIERA-FLANGIA", "FIERA-ALBERO", "FIERA-DXF")
+STATION_CODE = "ST-DEFAULT"  # STATION_CODE del pacchetto Windows (avvio.py PREDEFINITI)
+CAMERA_URL = "http://127.0.0.1:8765"
+CAMERA_SOURCE = "camera:601020"  # Itala sul PC fiera
+SEED = 20261026  # seme fisso: dati ripetibili
+FUSO = ZoneInfo("Europe/Rome")  # le misure sono salvate in UTC naive, l'orario di turno e' locale
+GIORNI_STORICO = 28  # circa 4 settimane
+
+# (username, password, nome, ruoli, admin). Password "123" per tutti, chiesta da Adriano per la fiera (#85); il login non controlla la lunghezza.
+UTENTI = [
+    ("adriano", "123", "Adriano Dal Pastro",
+     ["Maker", "MeasurementTec", "Metrologist", "Supervisor"], True),
+    ("maker", "123", "Marco Ferrari (Maker)", ["Maker"], False),
+    ("capoturno", "123", "Luca Bianchi (Capoturno)",
+     ["Supervisor", "MeasurementTec"], False),
+    ("operatore", "123", "Giulia Rossi (Operatore)", ["MeasurementTec"], False),
+]
+
+
+def _quota(marker, descrizione, nominale, tol, unita="mm", dec=3):
+    """Quota simmetrica: tolleranza = nominale +/- tol, warning al 70% della tolleranza."""
+    return dict(
+        marker_number=marker, description=descrizione, nominal=nominale,
+        ltl=round(nominale - tol, dec), lwl=round(nominale - 0.7 * tol, dec),
+        uwl=round(nominale + 0.7 * tol, dec), utl=round(nominale + tol, dec),
+        unit=unita,
+    )
+
+
+# Profilo statistico di una quota: scostamento medio (in frazioni di tol), sigma (in
+# frazioni di tol) e deriva (frazione di tol aggiunta linearmente nell'ultima settimana).
+# Cpk ~ (1 - |scostamento|) / (3 * sigma): sigma 0.2 -> 1,67; 0.33 -> 1,0.
+FLANGIA = [
+    # (task, quota, scostamento, sigma, deriva)
+    (0, _quota(1, "Diametro esterno Ø80", 80.0, 0.05), 0.0, 0.20, 0.0),      # Cpk ~1,67 capace
+    (0, _quota(2, "Diametro foro centrale Ø25", 25.0, 0.02), 0.0, 0.33, 0.0),  # Cpk ~1,0 al limite
+    (1, _quota(3, "Spessore flangia", 12.0, 0.10), 0.0, 0.22, 0.55),         # deriva ultima settimana
+    (1, _quota(4, "Interasse fori Ø60", 60.0, 0.10), 0.10, 0.25, 0.0),       # Cpk ~1,2
+    (1, _quota(5, "Profondita' lamatura", 8.0, 0.15), 0.50, 0.244, 0.0),     # ~2% fuori tolleranza
+]
+ALBERO = [
+    (0, _quota(1, "Diametro cuscinetto Ø20 h6", 20.0, 0.010), 0.0, 0.20, 0.0),  # Cpk ~1,67
+    (0, _quota(2, "Diametro sede Ø25 j5", 25.0, 0.008), 0.0, 0.25, 0.0),         # Cpk ~1,33
+    (1, _quota(3, "Lunghezza totale", 150.0, 0.10), 0.0, 0.33, 0.0),             # Cpk ~1,0
+    (1, _quota(4, "Rugosita' Ra", 0.40, 0.20, unita="µm"), 0.20, 0.25, 0.0),     # Cpk ~1,07
+]
+
+
+def _ora_utc(giorno: date, minuti_da_mezzanotte: int) -> datetime:
+    """Ora locale di officina -> datetime UTC naive, come le salva il backend."""
+    locale = datetime.combine(giorno, time(0, 0), tzinfo=FUSO) + timedelta(minutes=minuti_da_mezzanotte)
+    return locale.astimezone(timezone.utc).replace(tzinfo=None)
+
+
+def _giorni_lavorativi(fine: date) -> list[date]:
+    """Lun-ven degli ultimi GIORNI_STORICO giorni, fino a `fine` compreso."""
+    giorni = [fine - timedelta(days=i) for i in range(GIORNI_STORICO)]
+    return sorted(g for g in giorni if g.weekday() < 5)
+
+
+def _slot_giornalieri(rng: random.Random, n: int) -> list[int]:
+    """n orari (minuti dalla mezzanotte) in 8-12 e 13-17, ogni ~30 min con un po' di scarto."""
+    mezz_ore = [8 * 60 + 30 * i for i in range(8)] + [13 * 60 + 30 * i for i in range(8)]
+    scelti = sorted(rng.sample(mezz_ore, n))
+    return [m + rng.randint(0, 9) for m in scelti]
+
+
+async def _upsert_utenti(session: AsyncSession) -> dict[str, User]:
+    """Crea gli utenti o, se esistono, ne aggiorna password, nome, ruoli e flag admin."""
+    utenti = {}
+    for username, password, nome, ruoli, admin in UTENTI:
+        esistente = (await session.execute(
+            select(User).where(User.username == username)
+        )).scalar_one_or_none()
+        if esistente is None:
+            utenti[username] = await auth_service.create_user(
+                session, username=username, password=password, display_name=nome,
+                roles=ruoli, is_admin=admin,
+            )
+        else:
+            esistente.password_hash = auth_service.hash_password(password)
+            esistente.display_name = nome
+            esistente.roles = ruoli
+            esistente.is_admin = admin
+            esistente.active = True
+            utenti[username] = esistente
+    await session.flush()
+    return utenti
+
+
+async def _upsert_stazione(session: AsyncSession, owner: User) -> Station:
+    """La stazione del pacchetto, con la camera Itala; se c'e' gia' ne aggiorna la camera."""
+    stazione = (await session.execute(
+        select(Station).where(Station.code == STATION_CODE)
+    )).scalar_one_or_none()
+    if stazione is None:
+        stazione = Station(
+            code=STATION_CODE, name="Postazione fiera", location="Stand",
+            created_by=owner.id,
+        )
+        session.add(stazione)
+    stazione.camera_url = CAMERA_URL
+    stazione.camera_source = CAMERA_SOURCE
+    await session.flush()
+    return stazione
+
+
+async def _conta_e_cancella(session: AsyncSession, ricette: list[Recipe]) -> dict:
+    """Toglie le ricette FIERA-* e tutto cio' che e' misurato contro di esse. Ritorna i conteggi."""
+    conti = {"misure": 0, "produzioni": 0, "eventi": 0}
+    for ricetta in ricette:
+        versioni = (await session.execute(
+            select(RecipeVersion.id).where(RecipeVersion.recipe_id == ricetta.id)
+        )).scalars().all()
+        runs = (await session.execute(
+            select(ProductionRun.id).where(ProductionRun.recipe_id == ricetta.id)
+        )).scalars().all()
+        if versioni:
+            conti["misure"] += (await session.execute(
+                delete(Measurement).where(Measurement.version_id.in_(versioni))
+            )).rowcount
+            await session.execute(  # esiti dei task di queste versioni (FK sulle versioni)
+                delete(TaskResult).where(TaskResult.version_id.in_(versioni))
+            )
+        if runs:
+            conti["eventi"] += (await session.execute(
+                delete(ProductionEvent).where(ProductionEvent.run_id.in_(runs))
+            )).rowcount
+            conti["produzioni"] += (await session.execute(
+                delete(ProductionRun).where(ProductionRun.id.in_(runs))
+            )).rowcount
+        await session.execute(
+            delete(StationRecipeAssignment).where(StationRecipeAssignment.recipe_id == ricetta.id)
+        )
+        await session.execute(
+            delete(RecipeVersionAudit).where(RecipeVersionAudit.recipe_id == ricetta.id)
+        )
+        # Versioni, task e quote se ne vanno con la cascade ORM della ricetta.
+        await session.delete(ricetta)
+    await session.flush()
+    return conti
+
+
+async def _nuova_ricetta(session, owner, stazione, *, code, name, description,
+                         interval, requires_serial, note_versione):
+    """Ricetta + versione 1 corrente + assegnazione alla stazione."""
+    ricetta = Recipe(
+        code=code, name=name, description=description, created_by=owner.id, active=True,
+        measurement_interval_minutes=interval, requires_lot=True,
+        requires_serial=requires_serial, allow_manual_input=True,
+    )
+    session.add(ricetta)
+    await session.flush()
+    versione = RecipeVersion(
+        recipe_id=ricetta.id, version_number=1, is_current=True,
+        created_by=owner.id, change_notes=note_versione,
+    )
+    session.add(versione)
+    session.add(StationRecipeAssignment(
+        station_id=stazione.id, recipe_id=ricetta.id, assigned_by=owner.id,
+    ))
+    await session.flush()
+    return ricetta, versione
+
+
+async def _task(session, versione, ordine, titolo, tipo, direttiva=None,
+                descrizione=None, quote=()):
+    task = RecipeTask(
+        version_id=versione.id, order_index=ordine, title=titolo, task_type=tipo,
+        directive=direttiva, description=descrizione,
+    )
+    session.add(task)
+    await session.flush()
+    sottotask = []
+    for q in quote:
+        st = RecipeSubtask(task_id=task.id, **q)
+        session.add(st)
+        sottotask.append(st)
+    await session.flush()
+    return task, sottotask
+
+
+async def _ricetta_meccanica(session, owner, stazione, *, code, name, description,
+                             interval, requires_serial, profilo, titoli_task):
+    """Ricetta con una nota iniziale e un task di misura per ogni gruppo di quote del profilo."""
+    ricetta, versione = await _nuova_ricetta(
+        session, owner, stazione, code=code, name=name, description=description,
+        interval=interval, requires_serial=requires_serial,
+        note_versione="Ricetta dimostrativa per la fiera",
+    )
+    await _task(session, versione, 0, "Preparazione del pezzo", "note",
+                direttiva="Prima di misurare",
+                descrizione="Pulire il pezzo e controllare che sia a **temperatura ambiente**.")
+    sottotask_per_quota = {}
+    for indice, titolo in enumerate(titoli_task):
+        quote = [q for (t, q, *_r) in profilo if t == indice]
+        _t, sottotask = await _task(
+            session, versione, indice + 1, titolo, "measure",
+            direttiva="Misurare le quote in sequenza", quote=quote,
+        )
+        for st in sottotask:
+            sottotask_per_quota[st.marker_number] = st
+    return ricetta, versione, sottotask_per_quota
+
+
+def _valore(rng, quota, scost, sigma, deriva, frazione_tempo):
+    """Un valore: normale attorno a nominale + scostamento (+ deriva nell'ultima settimana)."""
+    tol = quota["utl"] - quota["nominal"]
+    media = quota["nominal"] + tol * (scost + deriva * max(0.0, (frazione_tempo - 0.75) / 0.25))
+    return round(rng.gauss(media, tol * sigma), 6)
+
+
+async def _storico(session, rng, fine, owner_ricetta, stazione, utenti, ricetta, versione,
+                   sottotask, profilo, pezzi_giorno, prefisso_lotto, prefisso_seriale):
+    """Una produzione chiusa per giorno lavorativo, con i suoi pezzi, eventi e misure."""
+    giorni = _giorni_lavorativi(fine)
+    operatore, capoturno = utenti["operatore"], utenti["capoturno"]
+    task_ids = {}  # marker -> id del task di misura
+    for marker, st in sottotask.items():
+        task_ids[marker] = st.task_id
+    ordine_task = sorted(set(task_ids.values()))
+    ultimo_task = ordine_task[-1]
+    contatore = 0
+    totale = 0
+    for indice_giorno, giorno in enumerate(giorni):
+        frazione = indice_giorno / max(1, len(giorni) - 1)  # 0 = primo giorno, 1 = ieri
+        n = rng.randint(*pezzi_giorno)
+        slot = _slot_giornalieri(rng, n)
+        lotto = f"{prefisso_lotto}{giorno:%y%m%d}"
+        inizio, fine_run = _ora_utc(giorno, slot[0] - 5), _ora_utc(giorno, slot[-1] + 10)
+        run = ProductionRun(
+            station_id=stazione.id, recipe_id=ricetta.id, version_id=versione.id,
+            operator_id=operatore.id, lot_number=lotto, status="closed",
+            measurement_interval_minutes=ricetta.measurement_interval_minutes,
+            cycle_count=n, started_at=inizio, closed_at=fine_run, closed_by=capoturno.id,
+            active_station_id=None,
+        )
+        session.add(run)
+        await session.flush()
+        session.add(ProductionEvent(run_id=run.id, event_type="start", user_id=operatore.id,
+                                    created_at=inizio))
+        for numero, minuti in enumerate(slot, start=1):
+            contatore += 1
+            seriale = f"{prefisso_seriale}{contatore:05d}"
+            istante = _ora_utc(giorno, minuti)
+            for marker in sorted(sottotask):
+                st = sottotask[marker]
+                _t, quota, scost, sigma, deriva = next(p for p in profilo if p[1]["marker_number"] == marker)
+                valore = _valore(rng, quota, scost, sigma, deriva, frazione)
+                esito, scarto = calculate_pass_fail(valore, st)
+                m = Measurement(
+                    subtask_id=st.id, version_id=versione.id, measured_by=operatore.id,
+                    value=valore, pass_fail=esito, deviation=scarto, lot_number=lotto,
+                    serial_number=seriale,
+                    input_method="usb_caliper" if rng.random() < 0.75 else "manual",
+                    input_duration_ms=rng.randint(2500, 9000),
+                    production_run_id=run.id,
+                    # un fuori tolleranza passa solo con l'ok del capoturno (come in produzione)
+                    supervisor_id=capoturno.id if esito == "fail" else None,
+                    authorised_at=istante + timedelta(minutes=1) if esito == "fail" else None,
+                    measured_at=istante + timedelta(seconds=20 * marker),
+                )
+                session.add(m)
+                totale += 1
+            # un task_measured per ogni task di misura non finale, poi il ciclo completato
+            for tid in ordine_task:
+                tipo = "cycle_completed" if tid == ultimo_task else "task_measured"
+                session.add(ProductionEvent(
+                    run_id=run.id, event_type=tipo, user_id=operatore.id, task_id=tid,
+                    created_at=istante + timedelta(minutes=1),
+                ))
+        session.add(ProductionEvent(run_id=run.id, event_type="close", user_id=capoturno.id,
+                                    supervisor_id=capoturno.id, created_at=fine_run))
+        await session.flush()
+    return contatore, totale
+
+
+async def _ricetta_dxf(session, owner, stazione):
+    """Demo visione: un task dxf_compare, senza grafo (si crea in fiera dal pannello DXF)."""
+    ricetta, versione = await _nuova_ricetta(
+        session, owner, stazione, code="FIERA-DXF", name="Profilo DXF (visione)",
+        description="Confronto di un profilo con il disegno DXF tramite la camera. "
+                    "La ricetta di visione si crea in fiera dal pannello «Crea ricetta da DXF».",
+        interval=None, requires_serial=False, note_versione="Ricetta dimostrativa per la fiera",
+    )
+    await _task(session, versione, 0, "Preparazione del pezzo", "note",
+                direttiva="Prima di misurare",
+                descrizione="Appoggiare il pezzo sul piano della camera, **in piano**.")
+    await _task(
+        session, versione, 1, "Confronto profilo con DXF", "dxf_compare",
+        direttiva="Acquisire e confrontare",
+        descrizione="Lo scostamento massimo del profilo rispetto al DXF deve restare entro la tolleranza.",
+        quote=[_quota(1, "Scostamento massimo profilo", 0.0, 0.15)],
+    )
+    return ricetta
+
+
+async def seed(replace: bool, dry_run: bool, fine: date) -> int:
+    """Esegue il seed in una sola transazione; con dry_run annulla tutto alla fine."""
+    rng = random.Random(SEED)
+    async with async_session_factory() as session:
+        utenti = await _upsert_utenti(session)
+        owner = utenti["adriano"]
+        stazione = await _upsert_stazione(session, owner)
+
+        esistenti = list((await session.execute(
+            select(Recipe).where(Recipe.code.in_(CODES))
+        )).scalars().all())
+        if esistenti and not replace:
+            print(f"Ricette FIERA gia' presenti ({', '.join(r.code for r in esistenti)}): "
+                  "non duplico. Usa --replace per rifarle.")
+        else:
+            if esistenti:
+                conti = await _conta_e_cancella(session, esistenti)
+                print(f"--replace: rimosse {', '.join(r.code for r in esistenti)} "
+                      f"({conti['misure']} misure, {conti['produzioni']} produzioni, "
+                      f"{conti['eventi']} eventi)")
+
+            r1, v1, sub1 = await _ricetta_meccanica(
+                session, owner, stazione, code="FIERA-FLANGIA", name="Flangia Ø80",
+                description="Flangia tornita in alluminio: diametri, spessore, interasse fori "
+                            "e profondita' della lamatura. Lotto e seriale obbligatori.",
+                interval=30, requires_serial=True, profilo=FLANGIA,
+                titoli_task=["Misure diametrali", "Spessore e posizione fori"],
+            )
+            n1, m1 = await _storico(session, rng, fine, owner, stazione, utenti, r1, v1, sub1,
+                                    FLANGIA, (10, 14), "LF", "FL")
+            r2, v2, sub2 = await _ricetta_meccanica(
+                session, owner, stazione, code="FIERA-ALBERO", name="Albero rettificato",
+                description="Albero in acciaio rettificato: sedi dei cuscinetti, lunghezza e "
+                            "rugosita'. Tolleranze strette.",
+                interval=30, requires_serial=False, profilo=ALBERO,
+                titoli_task=["Diametri rettificati", "Lunghezza e rugosita'"],
+            )
+            n2, m2 = await _storico(session, rng, fine, owner, stazione, utenti, r2, v2, sub2,
+                                    ALBERO, (8, 11), "LA", "AL")
+            await _ricetta_dxf(session, owner, stazione)
+            print(f"FIERA-FLANGIA: {n1} pezzi, {m1} misure; FIERA-ALBERO: {n2} pezzi, {m2} misure")
+
+        if dry_run:
+            await session.rollback()
+            print("--dry-run: nessuna modifica salvata.")
+        else:
+            await session.commit()
+            print(f"Seed fiera completato (stazione {stazione.code}, utenti: "
+                  f"{', '.join(u[0] for u in UTENTI)}).")
+    return 0
+
+
+def _factory_per_file(db: Path):
+    """Sessioni async su un file SQLite qualsiasi, con le stesse PRAGMA dell'app (FK attive)."""
+    engine = create_async_engine(f"sqlite+aiosqlite:///{db.resolve().as_posix()}", echo=False)
+
+    @event.listens_for(engine.sync_engine, "connect")
+    def _pragma(dbapi_connection, _record) -> None:
+        cur = dbapi_connection.cursor()
+        cur.execute("PRAGMA foreign_keys=ON")
+        cur.execute("PRAGMA busy_timeout=5000")
+        cur.close()
+
+    return engine, async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def _main_async(args) -> int:
+    global async_session_factory
+    engine, async_session_factory = _factory_per_file(args.db)
+    try:
+        fine = date.fromisoformat(args.fine) if args.fine else date.today() - timedelta(days=1)
+        return await seed(args.replace, args.dry_run, fine)
+    finally:
+        await engine.dispose()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--db", required=True, type=Path, help="file SQLite con lo schema gia' creato")
+    parser.add_argument("--replace", action="store_true",
+                        help="rimuove i dati FIERA-* (ricette, misure, produzioni) e li rifa'")
+    parser.add_argument("--dry-run", action="store_true", help="esegue tutto e annulla")
+    parser.add_argument("--fine", default=None, help="ultimo giorno dello storico AAAA-MM-GG (default: ieri)")
+    args = parser.parse_args()
+    if not args.db.is_file():
+        print(f"File non trovato: {args.db}")
+        return 2
+    return asyncio.run(_main_async(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,54 @@
+"""Test della pagina Acquisizione camera (#87): contenuto statico di PAGINA, senza servizio."""
+
+import importlib.util
+import re
+from pathlib import Path
+
+_FILE = Path(__file__).resolve().parents[1] / "calibrazione_pagina.py"
+_spec = importlib.util.spec_from_file_location("calibrazione_pagina", _FILE)
+_mod = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_mod)
+PAGINA = _mod.PAGINA
+
+
+def test_titolo_e_stile_scuro():
+    assert "<title>Acquisizione camera</title>" in PAGINA
+    assert "#0f172a" in PAGINA and "#1e293b" in PAGINA and "#3b82f6" in PAGINA
+
+
+def test_rotte_usate():
+    for rotta in ("/camera/sources", "/camera/anteprima", "/camera/parametri",
+                  "/camera/parametri/salva", "/camera/calibrate", "/camera/calibration"):
+        assert '"' + rotta in PAGINA, rotta
+
+
+def test_offline_e_senza_finestre_del_browser():
+    for vietato in ("alert(", "confirm(", "prompt(", "http://", "https://"):
+        assert vietato not in PAGINA, vietato
+
+
+def test_id_principali():
+    ids = set(re.findall(r'id="([^"]+)"', PAGINA))
+    attesi = {"sorgente", "avvia", "ferma", "scatta", "grezzo", "mirinoCasella", "immagine",
+              "nitidezza", "nitidezzaMax", "saturati", "media", "dimensioni",
+              "parametri", "salvaParametri", "quadrato", "acquisisci", "scegliFile", "file",
+              "carica", "salva", "elimina", "stato", "statoSorgente"}
+    assert attesi <= ids, attesi - ids
+    # ogni id usato dal JS con $("...") esiste nel markup
+    usati = set(re.findall(r'\$\("([^"]+)"\)', PAGINA))
+    assert usati <= ids, usati - ids
+
+
+def test_sezioni_e_testi_italiani():
+    for testo in ("Sorgente", "Anteprima", "Parametri camera", "Calibrazione",
+                  "Salva come predefiniti", "Scegli immagine...", "Questa sorgente non ha parametri regolabili",
+                  "Immagine grezza (senza correzione)"):
+        assert testo in PAGINA, testo
+    assert "it-IT" in PAGINA  # numeri con la virgola
+    assert "Choose File" not in PAGINA
+
+
+def test_localstorage_protetto():
+    # ogni uso di localStorage sta dentro un try
+    for m in re.finditer(r"localStorage[.]", PAGINA):
+        assert "try {" in PAGINA[max(0, m.start() - 200):m.start()]
@@ -0,0 +1,194 @@
+"""Test di scripts/seed_fiera.py (issue #85): il seed del PC della fiera.
+
+Lo script non e' un modulo del pacchetto: si carica da file con importlib, come
+test_seed_collaudo. La parte "dato" gira sul DB in memoria dei test; l'ultimo test
+percorre invece la strada vera (file SQLite con `alembic upgrade head` + --db).
+"""
+import importlib.util
+import sqlite3
+from argparse import Namespace
+from datetime import date
+from pathlib import Path
+
+import pytest
+from alembic import command
+from alembic.config import Config
+from sqlalchemy import func, select
+
+from src.backend.config import Settings, settings
+from src.backend.models.orm.measurement import Measurement
+from src.backend.models.orm.recipe import Recipe
+from src.backend.models.orm.station import Station, StationRecipeAssignment
+from src.backend.models.orm.user import User
+from src.backend.services.auth_service import authenticate_user
+from src.backend.tests.conftest import TestSessionFactory, test_engine
+
+_SCRIPT_PATH = Path(__file__).resolve().parents[3] / "scripts" / "seed_fiera.py"
+_ALEMBIC_INI = Path(__file__).resolve().parents[1] / "migrations" / "alembic.ini"
+FINE = date(2026, 10, 22)  # data fissa: il test non dipende dal giorno in cui gira
+
+
+@pytest.fixture
+def seed_fiera(monkeypatch):
+    spec = importlib.util.spec_from_file_location("seed_fiera", _SCRIPT_PATH)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    monkeypatch.setattr(module, "async_session_factory", TestSessionFactory)
+    return module
+
+
+async def _utente(db_session, username) -> User:
+    return (await db_session.execute(
+        select(User).where(User.username == username)
+    )).scalar_one()
+
+
+class TestSeedFiera:
+    async def test_utenti_ruoli_e_login(self, seed_fiera, db_session):
+        assert await seed_fiera.seed(False, False, FINE) == 0
+
+        attesi = {
+            "adriano": ("123", True),
+            "maker": ("123", False),
+            "capoturno": ("123", False),
+            "operatore": ("123", False),
+        }
+        for username, (password, admin) in attesi.items():
+            utente = await authenticate_user(db_session, username, password)
+            assert utente is not None, username
+            assert utente.is_admin is admin
+        assert (await _utente(db_session, "maker")).roles == ["Maker"]
+        assert "Supervisor" in (await _utente(db_session, "capoturno")).roles
+        assert (await _utente(db_session, "operatore")).roles == ["MeasurementTec"]
+        assert {"Maker", "Metrologist"} <= set((await _utente(db_session, "adriano")).roles)
+
+    async def test_setup_risulta_completato(self, seed_fiera, client, monkeypatch):
+        import src.backend.api.routers.setup as setup_mod
+        monkeypatch.setattr(settings, "setup_password", "test-setup-password")
+        monkeypatch.setattr(setup_mod, "engine", test_engine)
+        monkeypatch.setattr(setup_mod, "async_session_factory", TestSessionFactory)
+
+        # prima del seed il frontend vede il setup da fare, dopo no
+        assert (await client.get("/api/setup/status")).json() == {"initialised": False}
+        await seed_fiera.seed(False, False, FINE)
+        assert (await client.get("/api/setup/status")).json() == {"initialised": True}
+
+    async def test_stazione_e_ricette(self, seed_fiera, db_session):
+        await seed_fiera.seed(False, False, FINE)
+
+        stazione = (await db_session.execute(
+            select(Station).where(Station.code == "ST-DEFAULT")
+        )).scalar_one()
+        assert stazione.camera_url == "http://127.0.0.1:8765"
+        assert stazione.camera_source == "camera:601020"
+
+        assegnate = (await db_session.execute(
+            select(Recipe.code)
+            .join(StationRecipeAssignment, StationRecipeAssignment.recipe_id == Recipe.id)
+            .where(StationRecipeAssignment.station_id == stazione.id)
+        )).scalars().all()
+        assert sorted(assegnate) == ["FIERA-ALBERO", "FIERA-DXF", "FIERA-FLANGIA"]
+
+        # la ricetta DXF ha un task dxf_compare e nessun grafo di visione
+        from src.backend.models.orm.task import RecipeTask
+        dxf = (await db_session.execute(
+            select(RecipeTask).where(RecipeTask.task_type == "dxf_compare")
+        )).scalars().all()
+        assert len(dxf) == 1 and dxf[0].vision_json is None
+
+    async def test_misure_nel_numero_atteso(self, seed_fiera, db_session):
+        await seed_fiera.seed(False, False, FINE)
+
+        # ogni pezzo ha una misura per quota: pezzi 150-300 per ricetta
+        for codice, quote in (("FIERA-FLANGIA", 5), ("FIERA-ALBERO", 4)):
+            misure = (await db_session.execute(
+                select(func.count(Measurement.id))
+                .where(Measurement.version_id.in_(
+                    select(seed_fiera.RecipeVersion.id)
+                    .join(Recipe, Recipe.id == seed_fiera.RecipeVersion.recipe_id)
+                    .where(Recipe.code == codice)
+                ))
+            )).scalar_one()
+            assert misure % quote == 0
+            assert 150 <= misure // quote <= 300, (codice, misure // quote)
+
+        # lun-ven soltanto, e le misure compaiono nelle produzioni
+        giorni = (await db_session.execute(
+            select(seed_fiera.ProductionRun.started_at)
+        )).scalars().all()
+        assert giorni and all(g.weekday() < 5 for g in giorni)
+        senza_run = (await db_session.execute(
+            select(func.count(Measurement.id)).where(Measurement.production_run_id.is_(None))
+        )).scalar_one()
+        assert senza_run == 0
+
+    async def test_statistiche_numeriche(self, seed_fiera, client, db_session):
+        await seed_fiera.seed(False, False, FINE)
+        adriano = await _utente(db_session, "adriano")
+        from src.backend.services.auth_service import issue_api_key
+        chiave = await issue_api_key(db_session, adriano)
+        intestazioni = {"X-API-Key": chiave}
+
+        flangia = (await db_session.execute(
+            select(Recipe).where(Recipe.code == "FIERA-FLANGIA")
+        )).scalar_one()
+        quote = (await client.get(
+            "/api/statistics/subtasks", headers=intestazioni,
+            params={"recipe_id": flangia.id},
+        )).json()
+        assert len(quote) == 5
+        cpk = []
+        for quota in quote:
+            risposta = await client.get(
+                "/api/statistics/capability", headers=intestazioni,
+                params={"recipe_id": flangia.id, "subtask_id": quota["id"]},
+            )
+            assert risposta.status_code == 200
+            d = risposta.json()
+            for campo in ("mean", "std_dev", "cp", "cpk"):
+                assert isinstance(d[campo], (int, float)), (quota["id"], campo)
+            cpk.append(d["cpk"])
+        # Cpk diversi per quota: una capace, una al limite o sotto
+        assert max(cpk) > 1.4
+        assert min(cpk) < 1.1
+
+    async def test_secondo_giro_non_duplica_e_replace_rifa(self, seed_fiera, db_session):
+        async def conta():
+            return [
+                (await db_session.execute(select(func.count(t.id)))).scalar_one()
+                for t in (Recipe, Measurement, User)
+            ]
+
+        await seed_fiera.seed(False, False, FINE)
+        primo = await conta()
+        await seed_fiera.seed(False, False, FINE)
+        assert await conta() == primo  # utenti aggiornati, ricette e misure non duplicate
+
+        await seed_fiera.seed(True, False, FINE)
+        assert await conta() == primo  # stessi numeri: il seme e' fisso
+
+    async def test_dry_run_non_salva(self, seed_fiera, db_session):
+        await seed_fiera.seed(False, True, FINE)
+        assert (await db_session.execute(select(func.count(User.id)))).scalar_one() == 0
+        assert (await db_session.execute(select(func.count(Measurement.id)))).scalar_one() == 0
+
+
+async def test_file_sqlite_con_alembic(seed_fiera, tmp_path, monkeypatch):
+    """La strada vera: schema da `alembic upgrade head`, poi il seed con --db."""
+    db = tmp_path / "tmf.db"
+    url = f"sqlite+aiosqlite:///{db.as_posix()}"
+    monkeypatch.setattr(Settings, "database_url", property(lambda self: url))
+    # alembic fa asyncio.run(): fuori dal loop di pytest-asyncio, in un thread
+    import asyncio
+    await asyncio.to_thread(command.upgrade, Config(str(_ALEMBIC_INI)), "head")
+
+    argomenti = Namespace(db=db, replace=False, dry_run=False, fine=FINE.isoformat())
+    assert await seed_fiera._main_async(argomenti) == 0
+
+    con = sqlite3.connect(db)
+    try:
+        assert con.execute("SELECT COUNT(*) FROM users WHERE is_admin=1").fetchone()[0] == 1
+        assert con.execute("SELECT COUNT(*) FROM recipes").fetchone()[0] == 3
+        assert con.execute("SELECT COUNT(*) FROM measurements").fetchone()[0] > 1000
+    finally:
+        con.close()
@@ -17,6 +17,7 @@ import math
 import tempfile
 from pathlib import Path

+import cv2  # #86: soglia/componenti connesse per la maschera del pezzo
 import numpy as np
 from visionsuite.core.image import Image

@@ -113,12 +114,41 @@ def _locate_reference(gray: np.ndarray, polarity: str) -> dict:
    return pezzo.found_poses[0].to_dict()


-def _candidate_anchors(gray: np.ndarray, dxf_path: Path, px_per_mm: float) -> list[tuple[float, float, float]]:
+def _maschera_pezzo(gray: np.ndarray, polarity: str, px_per_mm: float = 71.0) -> np.ndarray:
+    """Immagine con solo il pezzo: fuori dal blob staccato dal bordo e' sfondo (#86).
+
+    Otsu (INV se dark), componenti connesse, la piu' grande che NON tocca il
+    bordo immagine (piastre del prisma, ombre e angoli neri della foto
+    raddrizzata ci sono attaccati), dilatata di ~0,3 mm (minimo 15 px).
+    """
+    flag = cv2.THRESH_BINARY_INV if polarity == "dark" else cv2.THRESH_BINARY
+    _, binary = cv2.threshold(gray, 0, 255, flag | cv2.THRESH_OTSU)
+    n, labels, stats, _ = cv2.connectedComponentsWithStats(binary, connectivity=8)
+    h, w = gray.shape[:2]
+    best, best_area = 0, 0
+    for i in range(1, n):  # 0 = sfondo
+        x, y, cw, ch, area = (int(v) for v in stats[i])
+        if x == 0 or y == 0 or x + cw >= w or y + ch >= h:
+            continue  # tocca il bordo immagine: non e' il pezzo
+        if area > best_area:
+            best, best_area = i, area
+    if best == 0:
+        raise CostruttoreError("pezzo non trovato: nessun blob staccato dal bordo")
+    raggio = max(15, int(round(0.3 * px_per_mm)))  # margine in funzione della scala
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2 * raggio + 1, 2 * raggio + 1))
+    zona = cv2.dilate((labels == best).astype(np.uint8), kernel) > 0
+    sfondo = 255 if polarity == "dark" else 0
+    return np.where(zona, gray, np.uint8(sfondo)).astype(np.uint8)
+
+
+def _candidate_anchors(gray: np.ndarray, dxf_path: Path, px_per_mm: float,
+                       polarity: str = "dark") -> list[tuple[float, float, float]]:
    """Pose (riga, col, angolo) del disegno sull'immagine: ICP da 4 orientamenti.

    Il disegno e' in px (origine DXF, y capovolta); si parte da ognuno dei 4
    angoli con i centroidi sovrapposti e l'ICP rifinisce. Ritorna le posa trovate
    (anche per orientamenti che non convergono: le giudica la ricetta eseguita).
+    Centroide e ICP lavorano sull'immagine mascherata sul solo pezzo (#86).
    """
    from visionsuite.calibration import ScaleCalibration
    from visionsuite.dxf.compare import DXFCompare, _stack
@@ -126,6 +156,7 @@ def _candidate_anchors(gray: np.ndarray, dxf_path: Path, px_per_mm: float) -> li

    cmp_ = DXFCompare(dxf_path, ScaleCalibration(px_per_mm=px_per_mm))
    drawing = _stack(cmp_.drawing_contours())
+    gray = _maschera_pezzo(gray, polarity, px_per_mm)  # #86: via piastre, ombre, angoli neri
    measured = _stack(cmp_.measured_contours(Image(gray)))
    if len(drawing) < 3:
        raise CostruttoreError("DXF senza geometria utilizzabile")
@@ -134,18 +165,22 @@ def _candidate_anchors(gray: np.ndarray, dxf_path: Path, px_per_mm: float) -> li
    dc, mc = drawing.mean(axis=0), measured.mean(axis=0)

    anchors = []
+    errori = []  # #86: motivo di ogni orientamento caduto, per la diagnosi in campo
    for theta in _START_ANGLES:
        # traslazione che porta il centroide del disegno ruotato sul misurato
        rr, cc = Pose(0.0, 0.0, theta).apply(dc[0], dc[1])
        start = Pose(float(mc[0] - rr), float(mc[1] - cc), theta)
        try:
            result = cmp_.compare(Image(gray), initial_pose=start)
-        except Exception:  # noqa: BLE001 - un orientamento che cade non ferma gli altri
+        except Exception as exc:  # noqa: BLE001 - un orientamento che cade non ferma gli altri
+            errori.append(f"{theta:g}gradi: {type(exc).__name__}: {exc}")  # #86
            continue
        # transform: misurato -> disegno; la posa del disegno e' l'inversa
        m = np.linalg.inv(result.transform)
        angle = math.degrees(math.atan2(m[1, 0], m[0, 0]))
        anchors.append((float(m[0, 2]), float(m[1, 2]), angle))
+    if not anchors and errori:  # #86: nessuna ancora -> il motivo risale al chiamante
+        raise CostruttoreError("disegno non sovrapponibile al pezzo (ICP fallito): " + "; ".join(errori))
    return anchors


@@ -199,7 +234,7 @@ def build_dxf_compare(
            raise CostruttoreError("DXF illeggibile: nessuna entita' geometrica")

        reference_pose = _locate_reference(frame, polarity)
-        anchors = _candidate_anchors(frame, dxf_path, px_per_mm)
+        anchors = _candidate_anchors(frame, dxf_path, px_per_mm, polarity)  # #86
        if not anchors:
            raise CostruttoreError("disegno non sovrapponibile al pezzo (ICP fallito)")

@@ -21,6 +21,8 @@ from src.vision.costruttori import (
    CALIBRATION_FILE,
    DXF_FILE,
    CostruttoreError,
+    _candidate_anchors,
+    _maschera_pezzo,
    build_dxf_compare,
 )
 from src.vision.runner import run_graph
@@ -112,3 +114,37 @@ def test_dxf_illeggibile_solleva():
 def test_parametri_ricetta_invalidi(kwargs):
    with pytest.raises(CostruttoreError):
        build_dxf_compare(a_scene(), SAMPLE_DXF.read_bytes(), **kwargs)
+
+
+def test_maschera_pezzo_tiene_solo_il_blob_staccato_dal_bordo():
+    # #86: pezzo scuro staccato + rettangoli scuri attaccati al bordo + angolo nero
+    img = np.full((500, 600), 230, np.uint8)
+    img[200:300, 250:400] = 20          # il pezzo
+    img[0:60, 100:220] = 15             # attaccato al bordo alto
+    img[420:500, 300:420] = 15          # attaccato al bordo basso
+    img[0:80, 0:80] = 0                 # angolo nero (borderValue=0 del raddrizzamento)
+    out = _maschera_pezzo(img, "dark", px_per_mm=4.0)
+    assert (out[200:300, 250:400] == 20).all()           # il pezzo resta
+    assert (out[0:60, 100:220] == 255).all()             # i rettangoli sono sfondo
+    assert (out[420:500, 300:420] == 255).all()
+    assert (out[0:80, 0:80] == 255).all()                # angolo nero cancellato
+
+
+def test_maschera_pezzo_senza_blob_staccato_solleva():
+    img = np.full((200, 200), 230, np.uint8)
+    img[:, 0:50] = 10                   # solo una fascia attaccata al bordo
+    with pytest.raises(CostruttoreError, match="staccato dal bordo"):
+        _maschera_pezzo(img, "dark")
+
+
+def test_ricetta_dxf_icp_fallito_riporta_il_motivo(monkeypatch, tmp_path):
+    # #86: l'errore "ICP fallito" porta il messaggio degli orientamenti caduti
+    from visionsuite.dxf.compare import DXFCompare
+
+    def boom(self, *a, **k):
+        raise ValueError("negative dimensions are not allowed")
+
+    monkeypatch.setattr(DXFCompare, "compare", boom)
+    with pytest.raises(CostruttoreError, match="ICP fallito.*negative dimensions"):
+        _candidate_anchors(a_scene(), SAMPLE_DXF, PX_PER_MM)
+
Author	SHA1	Message	Date
Adriano	13eeec7119	Acquisizione: pagina, attributo hidden rispettato, indicatori su una riga, mirino a 2 px (#87 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-24 14:41:25 +02:00
Adriano	0629f1b5ec	Acquisizione: pagina nuova con anteprima, parametri camera e stile TMF (#87 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-24 14:38:39 +02:00
Adriano	11c7d2e98b	DXF compare: ancore ICP sul solo pezzo staccato dal bordo, errore ICP con motivo (#86 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-24 13:54:25 +02:00
Adriano	88bba213e2	bump vendor/visionsuite: guardia overlay fuori immagine (TieVision-Core#337) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-24 13:53:01 +02:00
Adriano	8ce7b489d6	Merge branch 'lavoro/daitarn-tmf-seedfiera' into lavoro/daitarn-tmf-dxfcal	2026-10-24 10:17:47 +02:00
Adriano	bc90d327f1	seed fiera: password 123 per tutti, chiesta da Adriano (#85 ) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-24 10:17:45 +02:00
Adriano	e46965cb51	Merge branch 'lavoro/daitarn-tmf-seedfiera' into lavoro/daitarn-tmf-dxfcal	2026-10-24 00:55:21 +02:00
Adriano	c554fcfda7	seed fiera: commento sulle password corretto (#85 ) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-24 00:55:20 +02:00
Adriano	990b5d0db8	Seed fiera: utenti, stazione, ricette e storico misure (#85 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB	2026-10-23 23:51:00 +02:00