acquisitore: immagini caricate come sorgenti e anteprima calibrata (Refs #92)

POST/DELETE /camera/immagini (cartella <config>/immagini), elenco sorgenti con le immagini e senza camera:file, apertura per nome di file con loop, frame grezzo tenuto dall'anteprima e POST /camera/anteprima/calibrata che raddrizza senza leggere un frame nuovo. 22 test nuovi.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

scripts/calibrazione_pagina.py

@@ -8,6 +8,10 @@ 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.
+#91: due tab, «Acquisizione» e «Calibrazione», nella stessa pagina; l'anteprima resta
+visibile in entrambe. Calibrazioni salvate con nome in un archivio unico
+(/camera/calibrazioni, /camera/calibrazione-attiva); il calcolo non salva piu':
+si salva dal calcolo_id con un nome.
 Dipende da: niente. E' una stringa, cosi' il pacchetto compilato non ha file dati.
 """
 
@@ -75,16 +79,45 @@ PAGINA = r"""<!doctype html>
   .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); }
+  /* #91: tab Acquisizione | Calibrazione */
+  .tabs { display: flex; gap: 6px; margin: 0 0 14px; border-bottom: 1px solid var(--bordo); }
+  .tabs button { background: transparent; color: var(--secondario); border-radius: 6px 6px 0 0; border-bottom: 3px solid transparent;
+                 flex: 0 1 auto; padding: 8px 18px; }
+  .tabs button[aria-selected=true] { color: var(--testo); background: var(--pannello); border-bottom-color: var(--accento); font-weight: 600; }
+  /* #91: calibrazione con nome, elenco delle salvate */
+  /* #91: elenco a schede, una per calibrazione; nome e risoluzione sempre visibili, niente scorrimento orizzontale */
+  .elenco { margin-top: 8px; }
+  .scheda-cal { border-top: 1px solid var(--bordo); padding: 8px 0; }
+  .scheda-cal .nome-cal { font-weight: 700; overflow-wrap: anywhere; }
+  .scheda-cal .dettagli { font-size: .8rem; color: var(--secondario); margin-top: 2px; overflow-wrap: anywhere; }
+  .scheda-cal .azioni { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 6px; }
+  .scheda-cal .azioni button { padding: 3px 10px; font-size: .82rem; }
+  .segno { display: inline-block; font-size: .72rem; padding: 0 6px; border-radius: 9px; background: var(--ok); color: #052e16; margin-left: 6px; }
+  .segno.diversa { background: var(--avviso); color: #422006; }
+  .origine label { display: inline-block; margin: 0 14px 4px 0; color: var(--testo); font-size: .92rem; }
+  input[type=radio] { accent-color: var(--accento); }
   @media (max-width: 900px) {
     .griglia { grid-template-columns: minmax(0, 1fr); }
     .cornice img { max-height: 60vh; }
   }
+  @media (max-width: 500px) {  /* #91: utilizzabile anche stretta (400 px) */
+    main { padding: 8px; }
+    .scheda { padding: 10px; }
+    .tabs button { flex: 1 1 0; padding: 8px 6px; }
+    .parametro .campo input[type=text] { width: 88px; }
+  }
 </style>
 </head>
 <body>
 <main>
   <h1>Acquisizione camera</h1>
 
+  <!-- #91: due tab; la colonna dell'anteprima resta visibile in entrambe -->
+  <div class="tabs" role="tablist" aria-label="Sezioni della pagina">
+    <button id="tabAcq" type="button" role="tab" aria-selected="true" aria-controls="pannelloAcq">Acquisizione</button>
+    <button id="tabCal" type="button" role="tab" aria-selected="false" aria-controls="pannelloCal" tabindex="-1">Calibrazione</button>
+  </div>
+
   <div class="griglia">
     <div class="colonna">
       <!-- #87: sezione Anteprima -->
@@ -132,7 +165,7 @@ PAGINA = r"""<!doctype html>
       </section>
     </div>
 
-    <div class="colonna">
+    <div class="colonna" id="pannelloAcq" role="tabpanel" aria-labelledby="tabAcq">
       <!-- #87: sezione Sorgente -->
       <section class="scheda" id="sezioneSorgente">
         <h2>Sorgente</h2>
@@ -151,43 +184,51 @@ PAGINA = r"""<!doctype html>
         </div>
         <div id="msgParametri" class="messaggio"></div>
       </section>
+    </div>
 
+    <!-- #91: tab Calibrazione (colonna destra al posto di Sorgente e Parametri) -->
+    <div class="colonna" id="pannelloCal" role="tabpanel" aria-labelledby="tabCal" hidden>
       <section class="scheda" id="sezioneCalibrazione">
         <h2>Calibrazione</h2>
-        <div class="riga">
+        <div class="stato" style="margin:0 0 10px">Sorgente: <strong id="calSorgente">-</strong> (si cambia nella tab Acquisizione)</div>
+        <div class="origine">
+          <label for="origSorgente"><input id="origSorgente" name="origine" type="radio" value="sorgente" checked> Sorgente selezionata</label>
+          <label for="origFile"><input id="origFile" name="origine" type="radio" value="file"> Immagine da file</label>
+        </div>
+        <div class="riga" style="margin-top:4px">
+          <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>
+        </div>
+        <div class="riga" style="margin-top:10px">
           <div><label for="quadrato">Lato dello scacco (mm)</label><input id="quadrato" type="text" inputmode="decimal" value="2" size="8"></div>
+          <button id="acquisisci" title="Acquisisci e calibra">Calcola</button>
         </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>
+          Calcolando dalla sorgente l'anteprima si sospende e poi riprende.</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>
+          <div id="origineCalcolo" class="nota" style="margin:2px 0 6px"></div>
           <table id="tabella"></table>
           <div id="avviso" class="avviso"></div>
           <div class="riga" style="margin-top:10px">
+            <div><label for="nomeCal">Nome</label><input id="nomeCal" type="text" maxlength="60" size="22" autocomplete="off"></div>
             <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>
+          <div id="msgSalva" class="messaggio"></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>
+      </section>
 
-        <div style="margin-top:14px">
+      <section class="scheda" id="sezioneSalvate">
-          <strong>Calibrazione salvata</strong>
+        <h2>Calibrazioni salvate</h2>
-          <div id="stato" class="stato">-</div>
+        <div id="stato" class="stato">-</div>
-          <div class="riga" style="margin-top:10px">
+        <div id="calibrazioni" class="elenco"></div>  <!-- #91: una scheda per calibrazione, niente tabella larga -->
-            <button id="elimina" class="pericolo" disabled>Elimina calibrazione</button>
+        <div id="msgElenco" class="messaggio"></div>
-          </div>
-        </div>
       </section>
     </div>
   </div>
@@ -275,6 +316,7 @@ function cambioSorgente(salva) {
   fermaAnteprima();
   azzeraIndicatori();
   dire("msgAnteprima", "");
+  dire("msgElenco", "");  // #91
   aggiornaStato();
   caricaParametri();
   if (era) avviaAnteprima();
@@ -282,7 +324,7 @@ function cambioSorgente(salva) {
 
 // ---- Anteprima (#87)
 
-var A = { attiva: false, gen: 0, inVolo: false, url: null, nitMax: 0 };
+var A = { attiva: false, gen: 0, inVolo: false, url: null, nitMax: 0, ris: null };  // #91: ris = {w, h} dell'ultimo frame
 
 function azzeraIndicatori() {
   A.nitMax = 0;
@@ -290,6 +332,8 @@ function azzeraIndicatori() {
   $("saturati").className = "valore";
   $("barraNitidezza").style.width = "0";
   $("raddrizzato").textContent = " ";
+  A.ris = null;  // #91: risoluzione del frame non piu' nota
+  segnaRisoluzioni();
 }
 
 function pulsantiAnteprima() {
@@ -322,7 +366,12 @@ function aggiornaIndicatori(h) {
   }
   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);
+  if (w && a) {
+    $("dimensioni").textContent = fmt(w, 0) + " x " + fmt(a, 0);
+    // #91: risoluzione nota del frame, per segnare le calibrazioni che non combaciano
+    var nw = parseInt(w, 10), na = parseInt(a, 10);
+    if (!A.ris || A.ris.w !== nw || A.ris.h !== na) { A.ris = { w: nw, h: na }; segnaRisoluzioni(); }
+  }
   var r = h.get("X-Raddrizzato");
   $("raddrizzato").textContent = r === "si" ? "raddrizzata dalla calibrazione" : r === "no" ? "non raddrizzata" : " ";
 }
@@ -439,6 +488,12 @@ async function caricaParametri() {
   $("salvaParametriRiga").hidden = true;
   dire("msgParametri", "");
   if (!sorgente) { $("parametri").textContent = "-"; return; }
+  // #91: subito via il testo della sorgente precedente; la prima apertura della camera puo' durare ~20 s
+  $("parametri").textContent = "";
+  var attesa = document.createElement("div");
+  attesa.className = "nota";
+  attesa.textContent = "Lettura dei parametri...";
+  $("parametri").appendChild(attesa);
   try {
     var r = await fetch("/camera/parametri?source=" + encodeURIComponent(sorgente));
     if (g !== P.gen) return;
@@ -611,6 +666,29 @@ $("salvaParametri").onclick = async function () {
   }
 };
 
+// ---- Tab (#91): «Acquisizione» | «Calibrazione»; l'anteprima sta fuori dai pannelli e resta sempre visibile
+
+function scegliTab(nome, salva) {
+  var cal = nome === "cal";
+  $("tabAcq").setAttribute("aria-selected", cal ? "false" : "true");
+  $("tabCal").setAttribute("aria-selected", cal ? "true" : "false");
+  $("tabAcq").tabIndex = cal ? -1 : 0;
+  $("tabCal").tabIndex = cal ? 0 : -1;
+  $("pannelloAcq").hidden = cal;
+  $("pannelloCal").hidden = !cal;
+  if (salva) { memoria("tmf.acq.tab", nome); if (cal) caricaCalibrazioni(); }  // l'elenco si rilegge entrando
+}
+$("tabAcq").onclick = function () { scegliTab("acq", true); };
+$("tabCal").onclick = function () { scegliTab("cal", true); };
+[$("tabAcq"), $("tabCal")].forEach(function (b) {  // frecce sinistra/destra fra le tab
+  b.onkeydown = function (e) {
+    if (e.key !== "ArrowLeft" && e.key !== "ArrowRight") return;
+    var cal = b.id === "tabAcq";
+    scegliTab(cal ? "cal" : "acq", true);
+    $(cal ? "tabCal" : "tabAcq").focus();
+  };
+});
+
 // ---- Calibrazione (logica di #83 e #84; #87: lato precompilato, data italiana, conferma in pagina)
 
 function righe(d) {
@@ -644,37 +722,6 @@ function tabella(el, d) {
   });
 }
 
-async function aggiornaStato() {
-  var sorgente = $("sorgente").value;
-  var stato = $("stato");
-  annullaConferma();
-  $("elimina").disabled = true;
-  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 = [];
@@ -687,78 +734,288 @@ function avvisi(d) {
   return a.join(" ");
 }
 
-async function calcola(conFile, salva) {
+// ---- Calibrazioni con nome (#91): archivio unico, una attiva per sorgente
+
+var C = { elenco: [], attiva: null, celle: [], gen: 0, confermaNome: null, confermaBtn: null, confermaTimer: null };
+var S = { nome: null, timer: null };  // secondo clic su «Sovrascrivi» entro 4 s
+var JSON_H = { "Content-Type": "application/json" };
+
+function descriviOrigine(o) { return String(o || "-").replace(":", " "); }
+
+// stato della calibrazione attiva sulla sorgente selezionata (come prima di #91, piu' il nome)
+async function aggiornaStato() {
   var sorgente = $("sorgente").value;
-  if (!sorgente) { messaggio("Scegliere una sorgente.", "errore"); return; }
+  var stato = $("stato");
+  annullaConferma();
+  $("calSorgente").textContent = sorgente ? $("sorgente").options[$("sorgente").selectedIndex].textContent : "-";  // #91
+  if (!sorgente) { stato.textContent = "-"; $("statoSorgente").textContent = "-"; caricaCalibrazioni(); 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";
+    } else if (!r.ok) {
+      stato.textContent = await dettaglio(r);
+    } else {
+      var d = await r.json();
+      stato.textContent = "";
+      var titolo = document.createElement("div");
+      titolo.textContent = "Calibrazione attiva: " + (d.nome ? "«" + d.nome + "»" : "(senza nome)");
+      titolo.style.fontWeight = "600";
+      var t = document.createElement("table");
+      tabella(t, d);
+      var quando = document.createElement("div");
+      quando.textContent = "Calibrata il " + dataItaliana(d.calibrated_at);
+      stato.appendChild(titolo);
+      stato.appendChild(t);
+      stato.appendChild(quando);
+      $("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.";
+  }
+  caricaCalibrazioni();
+}
+
+// #91: elenco unico delle calibrazioni salvate; "attiva" e' quella della sorgente selezionata
+async function caricaCalibrazioni() {
+  var sorgente = $("sorgente").value;
+  var g = ++C.gen;
+  try {
+    var r = await fetch("/camera/calibrazioni" + (sorgente ? "?source=" + encodeURIComponent(sorgente) : ""));
+    if (g !== C.gen) return;
+    if (!r.ok) { dire("msgElenco", await dettaglio(r), "errore"); return; }
+    var j = await r.json();
+    if (g !== C.gen) return;
+    C.elenco = j.calibrazioni || [];
+    C.attiva = j.attiva || null;
+    disegnaElenco();
+  } catch (e) {
+    if (g === C.gen) dire("msgElenco", "Servizio non raggiungibile.", "errore");
+  }
+}
+
+function bottone(testo, classe, fn) {
+  var b = document.createElement("button");
+  b.textContent = testo;
+  b.className = classe || "";
+  b.onclick = fn;
+  return b;
+}
+
+function disegnaElenco() {
+  var t = $("calibrazioni");
+  annullaConferma();
+  t.textContent = "";
+  C.celle = [];
+  if (!C.elenco.length) {
+    var vuota = document.createElement("div");
+    vuota.className = "nota";
+    vuota.textContent = "Nessuna calibrazione salvata.";
+    t.appendChild(vuota);
+    return;
+  }
+  C.elenco.forEach(function (c) {
+    var sc = document.createElement("div");  // #91: scheda della calibrazione
+    sc.className = "scheda-cal";
+    var attiva = C.attiva !== null && c.nome === C.attiva;
+    var riga1 = document.createElement("div");
+    riga1.className = "nome-cal";
+    riga1.appendChild(document.createTextNode(c.nome));
+    if (attiva) {
+      var s1 = document.createElement("span");
+      s1.className = "segno";
+      s1.textContent = "attiva";
+      riga1.appendChild(s1);
+    }
+    var s2 = document.createElement("span");  // «risoluzione diversa» dal frame della sorgente (si accende in segnaRisoluzioni)
+    s2.className = "segno diversa";
+    s2.textContent = "risoluzione diversa";
+    s2.hidden = true;
+    riga1.appendChild(s2);
+    C.celle.push({ w: Number(c.image_width), h: Number(c.image_height), span: s2 });
+    var riga2 = document.createElement("div");
+    riga2.className = "dettagli";
+    riga2.textContent = [
+      c.image_width && c.image_height ? fmt(c.image_width, 0) + "×" + fmt(c.image_height, 0) : "-",
+      fmt(c.px_per_mm, 3) + " px/mm",
+      c.metodo === "densa" ? "densa" : "planare",
+      c.calibrated_at ? dataItaliana(c.calibrated_at) : "-",
+      descriviOrigine(c.origine)
+    ].join(" · ");
+    var az = document.createElement("div");
+    az.className = "azioni";
+    var bc = bottone("Carica", "", function () { caricaNome(c.nome); });
+    bc.disabled = !$("sorgente").value;
+    az.appendChild(bc);
+    if (attiva) az.appendChild(bottone("Scollega", "secondario", scollega));
+    az.appendChild(bottone("Elimina", "secondario", function (e) { eliminaNome(c.nome, e.currentTarget); }));
+    sc.appendChild(riga1);
+    sc.appendChild(riga2);
+    sc.appendChild(az);
+    t.appendChild(sc);
+  });
+  segnaRisoluzioni();
+}
+
+// #91: «risoluzione diversa» se il frame noto della sorgente non combacia con quello della calibrazione
+function segnaRisoluzioni() {
+  (C.celle || []).forEach(function (c) {
+    c.span.hidden = !(A.ris && c.w > 0 && c.h > 0 && (A.ris.w !== c.w || A.ris.h !== c.h));
+  });
+}
+
+// «Carica»: la calibrazione diventa quella attiva della sorgente. Un errore (es. risoluzione diversa) non ferma l'anteprima.
+async function caricaNome(nome) {
+  var sorgente = $("sorgente").value;
+  if (!sorgente) { dire("msgElenco", "Scegliere una sorgente nella tab Acquisizione.", "errore"); return; }
+  dire("msgElenco", "Caricamento di «" + nome + "»...", "");
+  try {
+    var r = await fetch("/camera/calibrazione-attiva", { method: "PUT", headers: JSON_H, body: JSON.stringify({ source: sorgente, nome: nome }) });
+    if (sorgente !== $("sorgente").value) return;
+    if (!r.ok) { dire("msgElenco", await dettaglio(r), "errore"); return; }
+    dire("msgElenco", "Calibrazione «" + nome + "» caricata sulla sorgente.", "ok");
+    $("raddrizzato").textContent = $("grezzo").checked ? "non raddrizzata" : "raddrizzata dalla calibrazione";  // il prossimo frame conferma
+    aggiornaStato();
+  } catch (e) {
+    dire("msgElenco", "Servizio non raggiungibile.", "errore");
+  }
+}
+
+// «Scollega»: la sorgente torna senza calibrazione, la libreria resta
+async function scollega() {
+  var sorgente = $("sorgente").value;
+  if (!sorgente) return;
+  try {
+    var r = await fetch("/camera/calibration?source=" + encodeURIComponent(sorgente), { method: "DELETE" });
+    dire("msgElenco", r.ok ? "Calibrazione scollegata dalla sorgente (resta fra le salvate)." : await dettaglio(r), r.ok ? "ok" : "errore");
+    if (r.ok) $("raddrizzato").textContent = "non raddrizzata";
+  } catch (e) {
+    dire("msgElenco", "Servizio non raggiungibile.", "errore");
+  }
+  aggiornaStato();
+}
+
+// «Elimina» di una riga: conferma in pagina con un secondo clic entro 4 s (niente finestre del browser)
+function annullaConferma() {
+  clearTimeout(C.confermaTimer);
+  C.confermaTimer = null;
+  if (C.confermaBtn) C.confermaBtn.textContent = "Elimina";
+  C.confermaBtn = null;
+  C.confermaNome = null;
+}
+async function eliminaNome(nome, btn) {
+  if (C.confermaNome !== nome) {
+    annullaConferma();
+    C.confermaNome = nome;
+    C.confermaBtn = btn;
+    btn.textContent = "Confermi? Clic ancora";
+    C.confermaTimer = setTimeout(annullaConferma, 4000);
+    return;
+  }
+  annullaConferma();
+  try {
+    var r = await fetch("/camera/calibrazioni?nome=" + encodeURIComponent(nome), { method: "DELETE" });
+    dire("msgElenco", r.ok ? "Calibrazione «" + nome + "» eliminata." : await dettaglio(r), r.ok ? "ok" : "errore");
+  } catch (e) {
+    dire("msgElenco", "Servizio non raggiungibile.", "errore");
+  }
+  aggiornaStato();
+}
+
+// #91: il calcolo non salva mai; il servizio tiene il risultato e ne da' il calcolo_id per «Salva»
+async function calcola() {
+  var daFile = $("origFile").checked;
+  var sorgente = $("sorgente").value;
+  if (!daFile && !sorgente) { messaggio("Scegliere una sorgente nella tab Acquisizione.", "errore"); return; }
   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", String(lato));  // al servizio sempre con il punto
-  f.append("save", salva ? "true" : "false");
+  if (daFile) {
-  if (conFile) {
     var file = $("file").files[0];
     if (!file) { messaggio("Scegliere un file immagine.", "errore"); return; }
     f.append("image", file);
+  } else {
+    f.append("source", sorgente);
   }
-  var eraAttiva = A.attiva;  // #87: l'anteprima si sospende e poi riprende
+  var eraAttiva = !daFile && A.attiva;  // #87: da sorgente l'anteprima si sospende e poi riprende
   if (eraAttiva) fermaAnteprima();
   messaggio("Calcolo in corso...", "");
-  ["acquisisci", "carica", "salva"].forEach(function (i) { $(i).disabled = true; });
+  ["acquisisci", "salva"].forEach(function (i) { $(i).disabled = true; });
   try {
     var r = await fetch("/camera/calibrate", { method: "POST", body: f });
     if (!r.ok) { messaggio(await dettaglio(r), "errore"); return; }
     var d = await r.json();
-    ultimo = { conFile: conFile, dati: d };
+    ultimo = { dati: d };
     tabella($("tabella"), d);
     $("overlay").src = "data:image/png;base64," + d.overlay_png;
     $("avviso").textContent = avvisi(d);
+    $("origineCalcolo").textContent = "Origine: " + descriviOrigine(d.origine);
     $("risultato").hidden = false;
-    messaggio(d.saved ? "Calibrazione salvata." : "Calibrazione riuscita: controllare e salvare.", "ok");
+    annullaSovrascrivi();
-    if (d.saved) aggiornaStato();
+    dire("msgSalva", "");
+    messaggio("Calcolo riuscito: dare un nome e salvare.", "ok");
   } catch (e) {
     messaggio("Servizio non raggiungibile.", "errore");
   } finally {
-    ["acquisisci", "carica", "salva"].forEach(function (i) { $(i).disabled = false; });
+    $("acquisisci").disabled = false;
+    $("salva").disabled = false;
     if (eraAttiva) avviaAnteprima();
   }
 }
 
-$("acquisisci").onclick = function () { calcola(false, false); };
+// «Salva» con nome; se il nome c'e' gia' il pulsante chiede un secondo clic per sovrascrivere
-$("carica").onclick = function () { calcola(true, false); };
+function annullaSovrascrivi() {
-// «Salva» rifa il calcolo con save=true sulla stessa origine (altra acquisizione se da camera)
+  clearTimeout(S.timer);
-$("salva").onclick = function () { calcola(ultimo ? ultimo.conFile : false, true); };
+  S.timer = null;
+  S.nome = null;
+  $("salva").textContent = "Salva";
+}
+async function salvaNome() {
+  if (!ultimo || !ultimo.dati.calcolo_id) { dire("msgSalva", "Nessun calcolo da salvare: calcolare prima.", "errore"); return; }
+  var nome = $("nomeCal").value.trim();
+  if (!nome) { dire("msgSalva", "Scrivere un nome per la calibrazione.", "errore"); return; }
+  if (nome.length > 60) { dire("msgSalva", "Il nome può avere al massimo 60 caratteri.", "errore"); return; }
+  var sovrascrivi = S.timer !== null && S.nome === nome.toLowerCase();  // secondo clic sullo stesso nome
+  annullaSovrascrivi();
+  $("salva").disabled = true;
+  try {
+    var r = await fetch("/camera/calibrazioni", {
+      method: "POST", headers: JSON_H,
+      body: JSON.stringify({ calcolo_id: ultimo.dati.calcolo_id, nome: nome, sovrascrivi: sovrascrivi })
+    });
+    if (r.status === 409) {
+      S.nome = nome.toLowerCase();
+      $("salva").textContent = "Sovrascrivi «" + nome + "»? Clic ancora";
+      S.timer = setTimeout(annullaSovrascrivi, 4000);
+      dire("msgSalva", await dettaglio(r), "errore");
+      return;
+    }
+    if (!r.ok) { dire("msgSalva", await dettaglio(r), "errore"); return; }
+    dire("msgSalva", "Calibrazione «" + nome + "» salvata. Per usarla su una sorgente: «Carica» nell'elenco.", "ok");
+    caricaCalibrazioni();
+  } catch (e) {
+    dire("msgSalva", "Servizio non raggiungibile.", "errore");
+  } finally {
+    $("salva").disabled = false;
+  }
+}
+
+$("acquisisci").onclick = calcola;
+$("salva").onclick = salvaNome;
+$("nomeCal").onkeydown = function (e) { if (e.key === "Enter") salvaNome(); };
 // #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";
-};
+  if ($("file").files[0]) $("origFile").checked = true;  // #91: scelto un file, l'origine diventa il file
-
-// #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;
-  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 = function () { cambioSorgente(true); };
+scegliTab(memoria("tmf.acq.tab") === "cal" ? "cal" : "acq", false);  // #91: tab ricordata
 caricaSorgenti();
 </script>
 </body>

scripts/camera_service.py

@@ -68,6 +68,9 @@ Uso (dalla radice del repo):
       [--host 127.0.0.1] [--port 8765] [--folder <cartella immagini>] \
       [--config-dir <cartella calibrazioni>]
   --folder abilita la sorgente finta `camera:folder` (loop sulle immagini).
+  Immagini caricate (#92): POST/DELETE /camera/immagini, in <config-dir>/immagini; sono sorgenti
+  a pieno titolo (/camera/sources, grab, anteprima, calibrate). POST /camera/anteprima/calibrata
+  raddrizza l'ultimo frame grezzo dell'anteprima con la calibrazione attiva, senza leggerne uno nuovo.
   Da Docker su Linux: --host 172.17.0.1 (gateway di docker0).
 
 Dipende da: venv di VisionSuite (`uv sync --all-packages` in vendor/visionsuite):
@@ -82,8 +85,10 @@ from __future__ import annotations
 import argparse
 import logging
 import os
+import re  # #92: nome sicuro per le immagini caricate
 import sys
 import threading
+import urllib.parse  # #92: nome calibrazione nell'header X-Calibrazione
 import uuid  # #91 id dei calcoli in attesa di nome
 from collections import OrderedDict
 from contextlib import asynccontextmanager
@@ -96,7 +101,7 @@ from fastapi.concurrency import run_in_threadpool  # #83: il grab bloccante fuor
 from fastapi.responses import HTMLResponse, Response
 
 from visionsuite.camera.camera_interface import CameraError, CameraGrabError, CameraStateError
-from visionsuite.camera.sources import SourceNotFound, list_sources, open_source
+from visionsuite.camera.sources import _ESTENSIONI, SourceNotFound, list_sources, open_source  # #92: _ESTENSIONI = tipi ammessi per le immagini caricate
 
 # #83: calibrazione e pagina stanno accanto a questo file (che non e' un pacchetto)
 sys.path.insert(0, str(Path(__file__).resolve().parent))
@@ -148,6 +153,8 @@ def create_app(folder: Path | str | None = None,
     archivio = calibrazione.Archivio(config_dir if config_dir is not None
                                      else _config_dir_default())  # #83
     aperte: dict = {}
+    grezzi: dict = {}  # #92: sorgente -> ultimo frame pieno GREZZO dell'anteprima (per anteprima/calibrata)
+    cartella_immagini = archivio.cartella / "immagini"  # #92: immagini caricate dalla pagina (creata al bisogno)
     lock = threading.Lock()  # protegge SOLO i dizionari, mai un'apertura
     lock_sorgenti: dict = {}  # nome sorgente -> Lock che serializza apertura e grab
     calcoli: OrderedDict = OrderedDict()  # #91: calcolo_id -> (dati, mappa); gli ultimi _MAX_CALCOLI
@@ -179,15 +186,69 @@ def create_app(folder: Path | str | None = None,
     @app.get("/camera/sources")
     def camera_sources():
         voci = list_sources(None, cameras=True, config=_config())
-        return {"sources": [{"name": v.name, "kind": v.kind, "label": v.label}
+        # #92: camera:file (replay) non e' mai configurato in TMF -> fuori dall'elenco
-                            for v in voci if v.kind in ("camera", "virtual")]}
+        elenco = [{"name": v.name, "kind": v.kind, "label": v.label}
+                  for v in voci if v.kind in ("camera", "virtual") and v.name != "camera:file"]
+        # #92: in coda le immagini caricate, che sono sorgenti a pieno titolo
+        for v in list_sources(cartella_immagini, cameras=False):
+            elenco.append({"name": v.name, "kind": "image", "label": f"immagine — {v.name}"})
+        return {"sources": elenco}
+
+    def _chiudi(nome: str) -> None:
+        """#92: chiude la sorgente aperta e scorda il frame tenuto (immagine sostituita o tolta)."""
+        with _lock_di(nome):
+            with lock:
+                s = aperte.pop(nome, None)
+                grezzi.pop(nome, None)
+            if s is not None:
+                try:
+                    s.close()
+                except Exception:  # noqa: BLE001 - la chiusura non deve far fallire la rotta
+                    pass
+
+    def _nome_immagine(grezzo: str) -> str:
+        """#92: solo il nome del file, coi caratteri sicuri di Archivio._file; "" se non ammesso."""
+        base = Path((grezzo or "").replace("\\", "/")).name
+        pulito = re.sub(r"[^A-Za-z0-9._-]+", "_", base).strip("._")
+        radice, punto, estensione = pulito.rpartition(".")
+        if not punto or not radice or f".{estensione.lower()}" not in _ESTENSIONI:
+            return ""
+        return f"{radice[:100]}.{estensione}"
+
+    @app.post("/camera/immagini", status_code=201)
+    async def immagini_carica(image: UploadFile | None = File(None)):
+        if image is None:
+            raise HTTPException(400, "manca il file «image»")
+        nome = _nome_immagine(image.filename or "")
+        if not nome:
+            raise HTTPException(400, "estensione non ammessa: " + ", ".join(_ESTENSIONI))
+        contenuto = await image.read()
+        # #92: 422 se non e' un'immagine; la verifica sta PRIMA della scrittura, cosi' non resta nulla su disco
+        if not contenuto or cv2.imdecode(np.frombuffer(contenuto, np.uint8), cv2.IMREAD_UNCHANGED) is None:
+            raise HTTPException(422, "il file caricato non è leggibile come immagine")
+        cartella_immagini.mkdir(parents=True, exist_ok=True)
+        (cartella_immagini / nome).write_bytes(contenuto)  # stesso nome = sostituisce
+        await run_in_threadpool(_chiudi, nome)  # se era aperta, si riapre sul file nuovo
+        return {"source": nome, "label": f"immagine — {nome}", "kind": "image"}
+
+    @app.delete("/camera/immagini", status_code=204)
+    def immagini_elimina(nome: str = ""):
+        percorso = cartella_immagini / nome
+        # #92: solo il nome di un file dentro la cartella, niente percorsi
+        if not nome or Path(nome).name != nome or not percorso.is_file():
+            raise HTTPException(404, "immagine non trovata")
+        _chiudi(nome)
+        percorso.unlink()
+        return Response(status_code=204)
 
     def _apri(nome: str):
         """#87: sorgente aperta (o da aprire); da chiamare SOLO sotto _lock_di(nome)."""
         with lock:
             sorgente = aperte.get(nome)
         if sorgente is None:
-            sorgente = open_source(nome, None, config=_config())
+            sorgente = open_source(nome, cartella_immagini, config=_config())  # #92: un nome di file = immagine caricata
+            if hasattr(sorgente, "loop"):  # #92: l'immagine singola non deve "finire" al secondo grab (anteprima continua)
+                sorgente.loop = True
             # TieVision-Core#341 / #89: free-run, serve la scena di adesso, non il frame vecchio in coda
             if hasattr(sorgente, "solo_ultimo_frame"):
                 try:
@@ -414,7 +475,12 @@ def create_app(folder: Path | str | None = None,
         timeout = corpo.get("timeout_ms", 5000)
         if isinstance(timeout, bool) or not isinstance(timeout, int) or not 1 <= timeout <= 10000:
             raise HTTPException(400, "«timeout_ms» deve essere un intero fra 1 e 10000")
-        frame = _grab(nome, timeout)
+        def leggi(s):  # #92: il frame grezzo si tiene sotto il lock della sorgente
+            f = s.grab(timeout)
+            with lock:
+                grezzi[nome] = f.copy()
+            return f
+        frame = _con_sorgente(nome, leggi)
         raddrizzato = False
         if not grezzo:  # come /camera/grab
             mappa = archivio.leggi_mappa(nome)
@@ -442,6 +508,44 @@ def create_app(folder: Path | str | None = None,
             "X-Nitidezza": f"{nitidezza:.1f}", "X-Saturati-Pct": f"{saturati:.2f}",
             "X-Media": f"{media:.1f}"})
 
+    @app.post("/camera/anteprima/calibrata")
+    def camera_anteprima_calibrata(corpo: dict = Body(default=None)):
+        """#92: l'ultimo frame grezzo dell'anteprima, raddrizzato; NON legge un frame nuovo."""
+        corpo = corpo if isinstance(corpo, dict) else {}
+        nome = _sorgente(corpo.get("source"))
+        lato = corpo.get("lato_max", 1280)
+        if isinstance(lato, bool) or not isinstance(lato, int) or not 320 <= lato <= 4096:
+            raise HTTPException(400, "«lato_max» deve essere un intero fra 320 e 4096")
+        with lock:
+            frame = grezzi.get(nome)
+        if frame is None:
+            raise HTTPException(404, "nessun frame: avviare l'anteprima o scattare")
+        attiva = archivio.attiva_di(nome)
+        if attiva is None:
+            raise HTTPException(409, "nessuna calibrazione attiva su questa sorgente")
+        mappa = archivio.leggi_mappa(nome)
+        if mappa is None:  # planare: ha solo scala, nessuna mappa da applicare
+            raise HTTPException(409, f"la calibrazione «{attiva}» non ha una mappa di correzione (planare)")
+        corretto = calibrazione.raddrizza(frame, mappa)
+        if corretto is None:  # risoluzione diversa da quella calibrata
+            ch, cw = mappa.shape[:2]
+            alt, larg = frame.shape[:2]
+            raise HTTPException(409, f"la calibrazione «{attiva}» è per immagini {cw}×{ch}, "
+                                     f"il frame è {larg}×{alt}")
+        alt, larg = corretto.shape[:2]
+        if corretto.dtype != np.uint8:  # il JPEG vuole 8 bit
+            corretto = _grigio8(corretto)
+        scala = lato / max(alt, larg)
+        if scala < 1.0:  # mai ingrandita
+            corretto = cv2.resize(corretto, (max(1, round(larg * scala)), max(1, round(alt * scala))),
+                                  interpolation=cv2.INTER_AREA)
+        ok, buf = cv2.imencode(".jpg", corretto, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        if not ok:
+            raise HTTPException(500, "codifica JPEG fallita")
+        return Response(buf.tobytes(), media_type="image/jpeg", headers={
+            "X-Raddrizzato": "si", "X-Larghezza": str(larg), "X-Altezza": str(alt),
+            "X-Calibrazione": urllib.parse.quote(attiva, safe="")})
+
     @app.get("/camera/parametri")
     def parametri_leggi(source: str = ""):
         nome = _sorgente(source)

scripts/tests/test_immagini_affiancate.py

@@ -0,0 +1,263 @@
+"""Test di #92: immagini caricate come sorgenti e anteprima calibrata (scripts/camera_service.py).
+
+Uso: uv run --python 3.13 --extra vision-worker --extra dev \
+       --with-editable vendor/visionsuite/packages/vs-camera pytest scripts/tests -q
+Solo tmp_path: niente ProgramData, niente camera vera. Le immagini le scrive il test.
+"""
+from urllib.parse import quote, unquote
+
+import cv2
+import numpy as np
+import pytest
+
+from test_calibrazione import (  # fixture e helper della calibrazione (#83/#84)
+    CAMPI, _png, carica_su, cartella, client, salva_con_nome, una_scacchiera,
+    una_scacchiera_densa,
+)
+
+__all__ = ["cartella", "client"]  # le fixture importate restano usate
+
+DENSA = "densa.png"
+PIANA = "piana.png"
+
+
+def _modulo(c) -> dict:
+    """Il dict globale di camera_service (per sostituire open_source con una spia)."""
+    return next(r.endpoint for r in c.app.routes if r.path == "/camera/grab").__globals__
+
+
+def _carica(c, nome: str, img: np.ndarray, **extra):
+    """POST /camera/immagini con un'immagine codificata PNG (o il contenuto dato)."""
+    return c.post("/camera/immagini", files={"image": (nome, _png(img), "image/png")}, **extra)
+
+
+def _densa(**kw) -> np.ndarray:
+    return una_scacchiera_densa(k=1e-7, **kw)
+
+
+def _calibra_e_attiva(c, nome_immagine: str, nome_calibrazione: str, **campi):
+    """Calcola dalla sorgente, salva con nome e la rende attiva su quella sorgente."""
+    r = c.post("/camera/calibrate", data={"source": nome_immagine, "square_mm": "2", **campi})
+    assert r.status_code == 200, r.text
+    assert salva_con_nome(c, r.json(), nome_calibrazione).status_code == 201
+    assert carica_su(c, nome_immagine, nome_calibrazione).status_code == 200
+
+
+def _anteprima(c, nome: str, **extra):
+    return c.post("/camera/anteprima", json={"source": nome, "grezzo": True, **extra})
+
+
+def _calibrata(c, nome: str, **extra):
+    return c.post("/camera/anteprima/calibrata", json={"source": nome, **extra})
+
+
+# ---- POST /camera/immagini
+
+def test_carica_201_salva_in_cartella_immagini(client):
+    r = _carica(client, "calibration_135_1.bmp", una_scacchiera())
+    assert r.status_code == 201, r.text
+    assert r.json() == {"source": "calibration_135_1.bmp",
+                        "label": "immagine — calibration_135_1.bmp", "kind": "image"}
+    assert (client.config / "immagini" / "calibration_135_1.bmp").is_file()
+
+
+def test_carica_ripulisce_il_nome_e_toglie_il_percorso(client):
+    r = _carica(client, "C:\\foto\\ban co è1.PNG", una_scacchiera())
+    assert r.status_code == 201, r.text
+    assert r.json()["source"] == "ban_co_1.PNG"  # niente percorso, caratteri sicuri, estensione intatta
+    assert (client.config / "immagini" / "ban_co_1.PNG").is_file()
+
+
+def test_carica_stesso_nome_sostituisce(client):
+    _carica(client, "a.png", np.full((48, 64), 10, np.uint8))
+    assert _carica(client, "a.png", np.full((30, 40), 200, np.uint8)).status_code == 201
+    assert [f.name for f in (client.config / "immagini").iterdir()] == ["a.png"]
+    img = cv2.imread(str(client.config / "immagini" / "a.png"), cv2.IMREAD_UNCHANGED)
+    assert img.shape[:2] == (30, 40)
+
+
+def test_carica_senza_file_400(client):
+    assert client.post("/camera/immagini").status_code == 400
+
+
+def test_carica_estensione_non_ammessa_400(client):
+    r = client.post("/camera/immagini", files={"image": ("note.txt", b"ciao", "text/plain")})
+    assert r.status_code == 400
+    assert not (client.config / "immagini").exists() or not list((client.config / "immagini").iterdir())
+
+
+def test_carica_file_illeggibile_422_e_niente_su_disco(client):
+    r = client.post("/camera/immagini", files={"image": ("rotta.png", b"non e una immagine", "image/png")})
+    assert r.status_code == 422
+    assert not (client.config / "immagini").exists() or not list((client.config / "immagini").iterdir())
+
+
+# ---- GET /camera/sources
+
+def test_sources_con_immagini_e_senza_camera_file(client):
+    _carica(client, "b.png", una_scacchiera())
+    _carica(client, "a.png", una_scacchiera())
+    voci = client.get("/camera/sources").json()["sources"]
+    nomi = [v["name"] for v in voci]
+    assert "camera:file" not in nomi
+    assert "camera:folder" in nomi
+    assert nomi[-2:] == ["a.png", "b.png"]  # le immagini stanno in coda
+    assert voci[-1] == {"name": "b.png", "kind": "image", "label": "immagine — b.png"}
+    assert nomi.index("camera:folder") < nomi.index("a.png")
+
+
+def test_sources_senza_immagini_non_crea_la_cartella(client):
+    voci = client.get("/camera/sources").json()["sources"]
+    assert all(v["kind"] != "image" for v in voci)
+
+
+# ---- grab / anteprima / calibrate su un'immagine caricata
+
+def test_grab_anteprima_e_grab_ripetuti_su_immagine(client):
+    _carica(client, "foto.png", una_scacchiera())
+    for _ in range(3):  # l'anteprima continua non deve esaurire un'immagine sola
+        r = client.post("/camera/grab", json={"source": "foto.png"})
+        assert r.status_code == 200 and r.headers["content-type"] == "image/png"
+    for _ in range(3):
+        r = _anteprima(client, "foto.png")
+        assert r.status_code == 200 and r.headers["content-type"] == "image/jpeg"
+        assert (r.headers["X-Larghezza"], r.headers["X-Altezza"]) == ("520", "400")
+
+
+def test_grab_immagine_inesistente_404(client):
+    assert client.post("/camera/grab", json={"source": "non_c_e.png"}).status_code == 404
+
+
+def test_calibrate_su_immagine_origine_e_il_nome(client):
+    _carica(client, "calibration_135_1.bmp", una_scacchiera())
+    r = client.post("/camera/calibrate", data={"source": "calibration_135_1.bmp", **CAMPI})
+    assert r.status_code == 200, r.text
+    assert r.json()["origine"] == "calibration_135_1.bmp"
+
+
+# ---- DELETE /camera/immagini
+
+def test_elimina_204_poi_404_e_sparisce_dalle_sorgenti(client):
+    _carica(client, "foto.png", una_scacchiera())
+    assert client.delete("/camera/immagini", params={"nome": "foto.png"}).status_code == 204
+    assert not (client.config / "immagini" / "foto.png").exists()
+    assert client.delete("/camera/immagini", params={"nome": "foto.png"}).status_code == 404
+    assert "foto.png" not in [v["name"] for v in client.get("/camera/sources").json()["sources"]]
+    assert client.post("/camera/grab", json={"source": "foto.png"}).status_code == 404
+
+
+def test_elimina_nome_con_percorso_404(client):
+    _carica(client, "foto.png", una_scacchiera())
+    assert client.delete("/camera/immagini", params={"nome": "../immagini/foto.png"}).status_code == 404
+    assert client.delete("/camera/immagini").status_code == 404
+    assert (client.config / "immagini" / "foto.png").is_file()
+
+
+def test_elimina_chiude_la_sorgente_aperta(client, monkeypatch):
+    chiuse = []
+    modulo = _modulo(client)
+    reale = modulo["open_source"]
+
+    def spia(*a, **k):
+        s = reale(*a, **k)
+        chiusura = s.close
+        s.close = lambda: (chiuse.append(a[0]), chiusura())[1]
+        return s
+
+    monkeypatch.setitem(modulo, "open_source", spia)
+    _carica(client, "foto.png", una_scacchiera())
+    assert client.post("/camera/grab", json={"source": "foto.png"}).status_code == 200
+    assert client.delete("/camera/immagini", params={"nome": "foto.png"}).status_code == 204
+    assert chiuse == ["foto.png"]
+
+
+# ---- POST /camera/anteprima/calibrata
+
+def test_calibrata_senza_frame_404(client):
+    _carica(client, DENSA, _densa())
+    r = _calibrata(client, DENSA)
+    assert r.status_code == 404 and r.json()["detail"] == "nessun frame: avviare l'anteprima o scattare"
+
+
+def test_calibrata_senza_attiva_409(client):
+    _carica(client, DENSA, _densa())
+    assert _anteprima(client, DENSA).status_code == 200
+    r = _calibrata(client, DENSA)
+    assert r.status_code == 409 and r.json()["detail"] == "nessuna calibrazione attiva su questa sorgente"
+
+
+def test_calibrata_validazione_ingresso(client):
+    assert client.post("/camera/anteprima/calibrata", json={}).status_code == 400
+    assert _calibrata(client, DENSA, lato_max=100).status_code == 400
+    assert _calibrata(client, DENSA, lato_max=True).status_code == 400
+
+
+def test_calibrata_200_densa_senza_nuova_lettura(client, monkeypatch):
+    modulo = _modulo(client)
+    reale = modulo["open_source"]
+    letture = []
+
+    def conta(*a, **k):
+        s = reale(*a, **k)
+        originale = s.grab
+        s.grab = lambda t=1000: (letture.append(1), originale(t))[1]
+        return s
+
+    monkeypatch.setitem(modulo, "open_source", conta)
+    _carica(client, DENSA, _densa())
+    _calibra_e_attiva(client, DENSA, "Banco àè 1")
+    assert _anteprima(client, DENSA).status_code == 200
+    prima = len(letture)
+    for _ in range(3):
+        r = _calibrata(client, DENSA)
+        assert r.status_code == 200, r.text
+        assert r.headers["content-type"] == "image/jpeg"
+        assert r.headers["X-Raddrizzato"] == "si"
+        assert (r.headers["X-Larghezza"], r.headers["X-Altezza"]) == ("640", "480")
+        assert unquote(r.headers["X-Calibrazione"]) == "Banco àè 1"
+        assert r.headers["X-Calibrazione"] == quote("Banco àè 1", safe="")  # percent-encoded UTF-8
+        img = cv2.imdecode(np.frombuffer(r.content, np.uint8), cv2.IMREAD_UNCHANGED)
+        assert img.shape[:2] == (480, 640)
+    assert len(letture) == prima  # la calibrata non legge mai un frame nuovo
+
+
+def test_calibrata_ridotta_a_lato_max(client):
+    _carica(client, DENSA, _densa())
+    _calibra_e_attiva(client, DENSA, "Banco")
+    assert _anteprima(client, DENSA).status_code == 200
+    r = _calibrata(client, DENSA, lato_max=320)
+    assert r.status_code == 200
+    img = cv2.imdecode(np.frombuffer(r.content, np.uint8), cv2.IMREAD_UNCHANGED)
+    assert max(img.shape[:2]) == 320
+    assert (r.headers["X-Larghezza"], r.headers["X-Altezza"]) == ("640", "480")  # misure del frame pieno
+
+
+def test_anteprima_grezza_e_calibrata_usano_lo_stesso_frame_grezzo(client):
+    # anche con anteprima NON grezza la copia tenuta e' quella prima di raddrizzare
+    _carica(client, DENSA, _densa())
+    _calibra_e_attiva(client, DENSA, "Banco")
+    r = client.post("/camera/anteprima", json={"source": DENSA})  # calibrata: raddrizzata
+    assert r.status_code == 200 and r.headers["X-Raddrizzato"] == "si"
+    r = _calibrata(client, DENSA)
+    assert r.status_code == 200 and r.headers["X-Raddrizzato"] == "si"  # raddrizzata una volta sola
+
+
+def test_calibrata_risoluzione_diversa_409(client):
+    _carica(client, DENSA, _densa())
+    _calibra_e_attiva(client, DENSA, "Banco")
+    # stessa sorgente, immagine sostituita con un'altra risoluzione: la calibrazione resta attiva
+    assert _carica(client, DENSA, _densa(w=320, h=240)).status_code == 201
+    assert _calibrata(client, DENSA).status_code == 404  # sostituire l'immagine scorda il frame vecchio
+    assert _anteprima(client, DENSA).status_code == 200
+    r = _calibrata(client, DENSA)
+    assert r.status_code == 409
+    assert r.json()["detail"] == "la calibrazione «Banco» è per immagini 640×480, il frame è 320×240"
+
+
+def test_calibrata_planare_senza_mappa_409(client):
+    _carica(client, PIANA, una_scacchiera())
+    _calibra_e_attiva(client, PIANA, "Piana", cols="9", rows="6")
+    assert _anteprima(client, PIANA).status_code == 200
+    r = _calibrata(client, PIANA)
+    assert r.status_code == 409
+    assert r.json()["detail"] == "la calibrazione «Piana» non ha una mappa di correzione (planare)"

scripts/tests/test_pagina_acquisizione.py

@@ -32,7 +32,7 @@ def test_id_principali():
     attesi = {"sorgente", "avvia", "ferma", "scatta", "grezzo", "mirinoCasella", "immagine",
               "nitidezza", "nitidezzaMax", "saturati", "media", "dimensioni",
               "parametri", "salvaParametri", "quadrato", "acquisisci", "scegliFile", "file",
-              "carica", "salva", "elimina", "stato", "statoSorgente"}
+              "salva", "stato", "statoSorgente"}  # #91: carica/elimina sono ora per riga, nell'elenco
     assert attesi <= ids, attesi - ids
     # ogni id usato dal JS con $("...") esiste nel markup
     usati = set(re.findall(r'\$\("([^"]+)"\)', PAGINA))

scripts/tests/test_pagina_tab.py

@@ -0,0 +1,77 @@
+"""Test della pagina a due tab (#91): 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_tab", _FILE)
+_mod = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_mod)
+PAGINA = _mod.PAGINA
+
+
+def test_due_tab_con_ruolo_e_selezione():
+    assert re.search(r'<button id="tabAcq"[^>]*role="tab"[^>]*aria-selected="true"', PAGINA)
+    assert re.search(r'<button id="tabCal"[^>]*role="tab"[^>]*aria-selected="false"', PAGINA)
+    assert ">Acquisizione</button>" in PAGINA and ">Calibrazione</button>" in PAGINA
+    assert 'role="tablist"' in PAGINA and 'role="tabpanel"' in PAGINA
+    assert 'aria-selected", cal ?' in PAGINA  # la selezione cambia da JS
+    assert '"tmf.acq.tab"' in PAGINA  # tab scelta ricordata (via memoria(), protetta)
+
+
+def test_anteprima_fuori_dai_pannelli():
+    # l'anteprima sta nella colonna sinistra, prima dei due pannelli: visibile in entrambe le tab
+    i_ant = PAGINA.index('id="sezioneAnteprima"')
+    i_acq = PAGINA.index('id="pannelloAcq"')
+    i_cal = PAGINA.index('id="pannelloCal"')
+    assert i_ant < i_acq < i_cal
+    # Sorgente e Parametri nel pannello Acquisizione, la calibrazione in quello Calibrazione
+    assert i_acq < PAGINA.index('id="sezioneSorgente"') < PAGINA.index('id="sezioneParametri"') < i_cal
+    assert PAGINA.index('id="sezioneCalibrazione"') > i_cal
+
+
+def test_id_del_pannello_calibrazione():
+    ids = set(re.findall(r'id="([^"]+)"', PAGINA))
+    attesi = {"calSorgente", "origSorgente", "origFile", "scegliFile", "file", "quadrato", "acquisisci",
+              "nomeCal", "salva", "msgSalva", "calibrazioni", "msgElenco", "stato", "risultato", "overlay"}
+    assert attesi <= ids, attesi - ids
+    usati = set(re.findall(r'\$\("([^"]+)"\)', PAGINA))
+    assert usati <= ids, usati - ids
+    assert len(re.findall(r'id="([^"]+)"', PAGINA)) == len(ids)  # nessun id doppio
+
+
+def test_testi_del_pannello():
+    for testo in ("Sorgente selezionata", "Immagine da file", "Scegli immagine...", "Calcola",
+                  "Calibrazioni salvate", "si cambia nella tab Acquisizione", "risoluzione diversa",
+                  "Carica", "Elimina", "Scollega", "Sovrascrivi «", "Clic ancora", "Nome"):
+        assert testo in PAGINA, testo
+
+
+def test_rotte_del_contratto():
+    for rotta in ("/camera/calibrazioni", "/camera/calibrazione-attiva", "/camera/calibrate",
+                  "/camera/calibration?source="):
+        assert '"' + rotta in PAGINA, rotta
+    for parola in ("calcolo_id", "sovrascrivi", "method: \"PUT\"", "method: \"DELETE\"", "X-Larghezza", "X-Altezza"):
+        assert parola in PAGINA, parola
+    # il calcolo non salva piu': il campo save sparisce
+    assert 'append("save"' not in PAGINA
+
+
+def test_nessuna_finestra_del_browser_e_offline():
+    for vietato in ("alert(", "confirm(", "prompt(", "http://", "https://"):
+        assert vietato not in PAGINA, vietato
+
+
+def test_acquisizione_di_87_90_conservata():
+    # anteprima, indicatori, mirino, grezzo, parametri camera e ciclo a 100 ms restano
+    for parola in ("Parametri camera", "Immagine grezza (senza correzione)", "Mirino centrale",
+                   "Math.max(100 - (Date.now() - t0), 0)", "/camera/anteprima", "/camera/parametri"):
+        assert parola in PAGINA, parola
+
+
+def test_pagina_stretta():
+    assert "@media (max-width: 500px)" in PAGINA
+    # #91: elenco a schede, niente tabella larga ne' scorrimento orizzontale
+    assert 'id="calibrazioni" class="elenco"' in PAGINA and "overflow-x" not in PAGINA
+    assert "Lettura dei parametri..." in PAGINA