Upload 81 files

.gitattributes

@@ -1,3 +1,5 @@
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.pdf filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
+assets/14-16/Fig4_fase1_manuale.JPG filter=lfs diff=lfs merge=lfs -text
+assets/14-16/Fig5_fase2.JPG filter=lfs diff=lfs merge=lfs -text

CHANGELOG_REV7_INTEGRATION.md

@@ -0,0 +1,16 @@
+# REV7 - integrazione 14-16
+
+- integrato il precedente `Plant_segmentation_edu` come quarta sezione dello Space;
+- dataset condiviso, senza duplicazioni;
+- FastSAM condiviso tramite `fastsam_shared.py`;
+- mantenuta l'architettura ZeroGPU della REV6.1 con inferenza FastSAM esplicitamente su CPU;
+- aggiunta calibrazione automatica e manuale del riferimento;
+- aggiunta segmentazione automatica ExG e regolazione manuale ExG/HSV/RGB/Lab;
+- aggiunto calcolo percentuale rispetto al riferimento e stima in cm² quando sono disponibili base, altezza, L1 e L2;
+- aggiunto FastSAM puntuale 14-16;
+- aggiunto metodo ibrido automatico del precedente Space;
+- mantenuta a parte la guida tecnica dettagliata `README_14-16.md` con le schermate reali originali;
+- copiati senza modifica i due PDF originali nella cartella `assets/14-16/`;
+- convertiti in pannelli sempre visibili i passaggi fondamentali di 9-11 e 11-14;
+- uniformata la gerarchia visiva dei pulsanti principali e dei pannelli manuali;
+- eliminate dalle nuove etichette GUI annotazioni come “consigliato” e “avanzato”.

GUI_STRUCTURE_REV7.md

@@ -0,0 +1,47 @@
+# Struttura GUI REV7
+
+## Regole visive comuni
+
+- I pannelli fondamentali sono sempre aperti e visibili.
+- I pulsanti che avviano elaborazioni usano lo stesso stile verde `action-button`.
+- Le regolazioni manuali sono visibili in pannelli secondari con bordo distinto.
+- Le funzioni automatiche compaiono prima dei controlli manuali.
+- Le etichette non usano annotazioni tra parentesi come “consigliato” o “avanzato”.
+
+## 6-9
+
+1. Caricamento fotografia o dataset.
+2. Impostazione della griglia.
+3. Generazione del PDF.
+
+## 9-11
+
+### A scuola
+
+1. Un solo caricamento della fotografia.
+2. Patch 5×5 con valori RGB o HSV sovrapposti direttamente ai pixel.
+3. Laboratorio del colore sempre visibile sotto il patch.
+
+### Con la famiglia
+
+1. Fotografia A e fotografia B.
+2. Confronto automatico del verde.
+3. Risultati visuali e maschere.
+
+## 11-14
+
+1. Caricamento.
+2. Metodo cromatico HSV con parametri predefiniti.
+3. Regolazione manuale HSV già visibile.
+4. ExG già visibile.
+5. FastSAM già visibile con copia locale dell’immagine.
+6. Confronto finale.
+
+## 14-16
+
+1. **Caricamento** — fotografia locale o dataset condiviso.
+2. **Calibrazione** — rilevamento automatico della cornice; controlli manuali visibili sotto; campionamento del colore mediante click.
+3. **Segmentazione e misure** — ExG automatico e pulizia automatica; regolazione ExG/HSV/RGB/Lab e morfologia visibile sotto; percentuale sul riferimento e area reale quando sono fornite le misure geometriche.
+4. **FastSAM** — copia locale dell’immagine, selezione del punto e pulsante di inferenza.
+5. **Metodo ibrido** — esplorazione automatica mediante più prompt FastSAM e scelta finale tramite ExG.
+6. **Esportazione e documentazione** — file prodotti nei pannelli precedenti, README tecnico 14-16 e PDF originali.

MANIFEST_SHA256.txt

@@ -1,20 +1,27 @@
 e0c1edaa83a3c419eb884b51c4b3e2de519de48b46420caa7c694ed802add437  ./.gitattributes
-1f7f03347a308182ed09b0259c5ebb0ffd934fdf4e513b0c7ac73a084b695237  ./CHANGELOG_REV5_ZEROGPU_CPU.md
-f27222a2551e48f94d45dafd181e76e17a2f371e49101b4be4349b0af784be56  ./CHANGELOG_REV6_9-11.md
-2cf251e4db544ae2b6a5ca1e0a91dd1e4975e72cfa6119b5ffd366bb1f869c27  ./ISTRUZIONI_CARICAMENTO_REV5.md
+79f6b297b8815ef21703e0578b7331c33780a2329246443db059a86645d59e93  ./CHANGELOG_REV7_INTEGRATION.md
+f3006c1dc301e47552b548c8cf11896425bea71492532a31aac6de5074e54553  ./GUI_STRUCTURE_REV7.md
 cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  ./LICENSE
 f248798ad0c9a4bfd5e55f0b9fe41208f69791241ac1e506f2ce8b3e8ffc934a  ./NOTE_RUNTIME_ZEROGPU_CPU.md
-a406e2c6d2afc31cd9477104be6c0e9281fc49b0c859697c41fc22e498f28ce0  ./README.md
-51fbe08f35cbc5bbf8a3ef94319d1eaf48b3d009db2e02d2c6d6c92318aaf9a2  ./TEST_REPORT_REV5_ZEROGPU_CPU.md
-06c71db79a8d60ba085e24b013fcb0f0813fbc5c2b294ab9eb9d1b8f5a417a63  ./TEST_REPORT_REV6_9-11.md
+0b150a0ec188b2445da252fdf9964b5c271519edc5636cc5d7bf0a983ffceb02  ./README.md
+fcb5ae34be041af364af67c5d61d7ae0efa741b7432b13b6255145d8e9009d74  ./README_14-16.md
+dd17bfd2856951485515cea6625303b29041d29da4b610472a811b408d32aa9d  ./TEST_REPORT_REV7.md
 4180f6cce89dafd0665dcfd5b3f0c7be639773dba333c6afcb81324413bbe485  ./THIRD_PARTY_NOTICES.md
-773b702f9a79cbd3945bf7a1605799fac008cec4cee6a5665025ddefbad307b2  ./app.py
+cb887ddb39c0b2e83e3ea6023222b8769aa6a0408bf01d904a8cfbdd55488e9d  ./advanced_14_16.py
+ef76cdec7c7a3369c5c8ad456784f6ae6b8182b023476777f1beb7ecefb1a329  ./app.py
 2728fc9fcc6e2eec751fdd07979a85b78cd2143399216a6ee25f659d697ebdda  ./assets/11-14/Approfondimenti_tecnici_docenti.pdf
 1219c20c7528e57b3268d44ba4b58be8fbcfcaf886a0e8b6063eeb36224c54cc  ./assets/11-14/Guida_confronto_segmentazioni.pdf
+a671e38e6bd2ee0e844b056db1b22cfe9a1682512003a6da88309042eb0e5f98  ./assets/14-16/Fig1_cariacamento.JPG
+f80bf46cae5fdd49af34a9ea2fab0a522fa6b517fe4627801d3627413a720f01  ./assets/14-16/Fig2_fasi.JPG
+b850f0e171184b6fe110287d54b063be4da754f36a7a5bb39f628b15dcb437e4  ./assets/14-16/Fig3_fase1_auto.JPG
+f774eee13a95dce40946ebbf51feeab6178cf988eb56dca33df6f85c89736cb8  ./assets/14-16/Fig4_fase1_manuale.JPG
+2b7b05246f771ee02f5dba684021d7dfc9f9aa4968241b29e0c3a1b8218358b5  ./assets/14-16/Fig5_fase2.JPG
+e03415bf911a186c64080ac62627ed914019d07a7f6d8636e190ee4c21606994  ./assets/14-16/Fig6_fase3.JPG
+6cb27b09c3339ae9d702562e9ddece68b38faa9ac3bf42cbcfe356b3d2ab4774  ./assets/14-16/Fig7_IA_semantica.JPG
+3cbf7a3a59db1ed1178f04158ad60cd823c1313733991cbe2ee632566caf2c19  ./assets/14-16/Scheda_esperimento.pdf
+cf68fe5a8d9832899f1fb5a54ec80a360de516412f3395bb541b95fd2081d549  ./assets/14-16/Tutorial_setup_sperimentale.pdf
 d49cff20b915ce9abbda6f3d965943e5d7132ca17b78f6edf51a8a64d8a94c34  ./assets/6-9/Guida_piante_a_quadretti.pdf
 c816c47c19694173765194c7c6579967cb2e5e8a9bbdaba83454053c9952867e  ./assets/9-11/Guida_pixel_e_verde.pdf
-3cbf7a3a59db1ed1178f04158ad60cd823c1313733991cbe2ee632566caf2c19  ./assets/comuni/Scheda_esperimento.pdf
-cf68fe5a8d9832899f1fb5a54ec80a360de516412f3395bb541b95fd2081d549  ./assets/comuni/Tutorial_setup_sperimentale.pdf
 053c47c13a9a5a1078eb8185ed241ec83ec88a0cb07b9d249604b0641390452b  ./assets/screenshots/01_panoramica_annotata.png
 3b7d3488f27001d7e28592b63ec8b7ab282fbeed7c462835e1c66b226ba68038  ./assets/screenshots/02_6-9_annotata.png
 708f658bd5fe1ba96c08ae570c9581b73b49352835eda8dd4735aa0cb927ffab  ./assets/screenshots/03_9-11_annotata.png
@@ -44,7 +51,7 @@ ad4db49b400a5f6c1b184d2d12fa9283b8e8f2c389169235de0c5e94262dbf49  ./dataset/NS_C
 5aef103edd73e7cd2776b4202e7d20f53568315aff9aa09f08781e2eb0731632  ./dataset/NS_C_19.jpg
 d821a6ecef12f5382e789000681dff2027da76956a7a3e319fa4ad7d285227c3  ./dataset/NS_C_23.jpg
 f49b14148dd19211af4956c8e665232dfd7a5a51033dda5e8519b38f972260f1  ./dataset/NS_C_26.jpg
-0e4efe4ac5109accb5155f92c98cf2a814a91ace7be78f3ec6e51dd0d63a2783  ./dataset/README_dataset.md
+be94c929fd3ffd4d73422b0346693dab25684c5781b8cbf168383b35b7ee514e  ./dataset/README_dataset.md
 a9906bfe5f45baf6ddbb1916ef1c479e80f8e2e2c645a290b17e437c263a6eb5  ./dataset/S_A_06.jpg
 8124a2a068f0e96a845ea96134638256e0ce6338588d98083377a77e158092f1  ./dataset/S_A_09.jpg
 770d8581a4d389226c4cc0f8d14591e3ec5f9e7eb17c11310ad7e9cd876604b4  ./dataset/S_A_11.jpg
@@ -69,4 +76,5 @@ ec36860a1cac5eda3c10a745a7d8c8afd78c1caee16e05cd65a8b2b542c59b1f  ./dataset/S_C_
 ee9111fe634934cf0f2ee500efc3aea3288b7c6e793fe36e780acf205bccee55  ./dataset/S_C_19.jpg
 4e7045ded7f4aca9fbb69c8bb5513c5ce3887669d32fe3aed28e6369e51360be  ./dataset/S_C_23.jpg
 5218323ac29cbe93e472edc2e45481d7e65983c5d236ad9a889653c5c42d3406  ./dataset/S_C_26.jpg
-24e57909eb3ddc7f1271256abff7065e61807ed9a50669ac13438b540e0d0965  ./requirements.txt
+fc9d580ca89ab4c800be0ef40eaa821ac1cbfae50ee5f8fb1a4a7f3e207beef7  ./fastsam_shared.py
+d6aef3a8e1836fc8027a6ef4d3dd6eb59ded5db75e9a35d14d66a1603e03cdc8  ./requirements.txt

README.md

@@ -1,5 +1,5 @@
 ---
-title: Computer vision e piante - percorsi 6-14 anni
+title: Computer vision e piante - percorsi 6-16 anni
 emoji: 🌱
 colorFrom: green
 colorTo: gray
@@ -14,17 +14,15 @@ preload_from_hub:
   - Uminosachi/FastSAM FastSAM-s.pt
 ---
 
-# Computer vision e piante - percorsi 6-14 anni
+# Computer vision e piante - percorsi 6-16 anni
 
-Lo Space mantiene un unico indirizzo e organizza tre percorsi distinti:
+Lo Space mantiene un unico indirizzo e organizza quattro percorsi progressivi:
 
 - **6-9 anni:** preparazione di schede PDF con fotografie a quadretti;
 - **9-11 anni:** esplorazione di matrici di pixel, trasformazioni additive del colore e stima automatica del verde;
-- **11-14 anni:** confronto progressivo fra segmentazione HSV, indice ExG e FastSAM guidato da un punto, eseguito esplicitamente su CPU anche quando lo Space usa il runtime ZeroGPU.
+- **11-14 anni:** confronto progressivo fra segmentazione HSV, indice ExG e FastSAM guidato da un punto;
+- **14-16 anni:** calibrazione del riferimento, segmentazione e misura, FastSAM e metodo ibrido. La documentazione tecnica dettagliata è mantenuta separata in `README_14-16.md`.
 
-La fascia 14-16 non è inclusa in questa versione. Le relative attività verranno sviluppate separatamente a partire dal precedente Space sperimentale.
-
-![Panoramica dei moduli](assets/screenshots/01_panoramica_annotata.png)
 
 ## Avvio rapido
 
@@ -145,7 +143,7 @@ Premere **Applica il metodo cromatico**. Lo Space usa soglie HSV iniziali e appl
 
 ### 2. Modifica delle soglie HSV
 
-Aprire **Prova a modificare le soglie nello spazio HSV**. Gli slider consentono di cambiare:
+Nel pannello **Modifica le soglie nello spazio HSV**, già visibile, è possibile cambiare:
 
 - intervallo della tonalità H;
 - saturazione minima e massima;
@@ -155,7 +153,7 @@ Questa sezione serve a osservare come una trasformazione dei limiti numerici mod
 
 ### 3. Indice ExG
 
-Aprire **Prova l'indice ExG**. L'indice viene calcolato per ogni pixel:
+Nel pannello **Prova l’indice ExG**, già visibile, l’indice viene calcolato per ogni pixel:
 
 `ExG = 2G - R - B`
 
@@ -164,7 +162,7 @@ Il programma conserva i pixel per i quali ExG supera la soglia scelta e applica
 ### 4. FastSAM guidato da un punto
 
 1. Caricare o selezionare la fotografia sorgente.
-2. Aprire **Adesso prova FastSAM**.
+2. Raggiungere il pannello **Prova FastSAM**, già visibile nella sequenza.
 3. Usare la copia sincronizzata dell'immagine presente nello stesso pannello: non è necessario tornare alla parte superiore della pagina.
 4. Fare click sulla pianta e controllare il punto rosso.
 5. Premere **Segmenta l'oggetto indicato**.
@@ -181,6 +179,26 @@ Guide:
 
 ---
 
+## 14-16 - Laboratorio di analisi
+
+La sezione integra le funzioni del precedente `Plant_segmentation_edu` in sei pannelli sempre visibili:
+
+1. caricamento unico della fotografia;
+2. calibrazione automatica del riferimento, con regolazione manuale immediatamente disponibile;
+3. segmentazione automatica ExG e misure, con confronto manuale fra ExG, HSV, RGB e Lab;
+4. FastSAM guidato da un punto;
+5. metodo ibrido automatico con più interrogazioni FastSAM e selezione finale tramite ExG;
+6. esportazione e documentazione.
+
+Il dataset è lo stesso usato nelle altre fasce e rimane presente una sola volta nella cartella `dataset/`. Il modello FastSAM è condiviso con la sezione 11-14 e viene caricato una sola volta in memoria.
+
+La guida tecnica del precedente Space, completa delle schermate reali, è conservata separatamente: [`README_14-16.md`](README_14-16.md).
+
+Documenti originali della sezione:
+
+- `assets/14-16/Tutorial_setup_sperimentale.pdf`;
+- `assets/14-16/Scheda_esperimento.pdf`.
+
 ## Runtime ZeroGPU con FastSAM forzato su CPU
 
 Lo Space è predisposto per essere ospitato con hardware **ZeroGPU**, ma le funzioni visibili agli utenti restano sul processo CPU:
@@ -215,8 +233,8 @@ Per mantenere invariati i link già presenti nelle schede:
 
 ## Documenti allegati
 
-- `assets/comuni/Tutorial_setup_sperimentale.pdf`;
-- `assets/comuni/Scheda_esperimento.pdf`;
+- `assets/14-16/Tutorial_setup_sperimentale.pdf`;
+- `assets/14-16/Scheda_esperimento.pdf`;
 - `assets/6-9/Guida_piante_a_quadretti.pdf`;
 - `assets/9-11/Guida_pixel_e_verde.pdf`;
 - `assets/11-14/Guida_confronto_segmentazioni.pdf`;

README_14-16.md

@@ -0,0 +1,198 @@
+# Guida tecnica dettagliata 14-16
+
+> Questa guida conserva contenuti, spiegazioni e schermate reali del precedente Space `Plant_segmentation_edu`. Nello Space integrato le stesse funzioni sono disposte in pannelli sequenziali sempre visibili; nomi e posizione di alcuni controlli possono quindi essere diversi dalle schermate originali. Algoritmi, dataset e documenti sperimentali restano gli stessi.
+
+# 🥬 Computer Vision in Agricoltura: Segmentazione
+
+Questo Spazio mostra il funzionamento di una pipeline di segmentazione su fotografie di piante, con tre approcci confrontabili:
+
+- **deterministico** (soglie su colore + geometria + morfologia),
+- **AI** (FastSAM),
+- **ibrido** (loop deterministico con chiamate AI).
+
+L’obiettivo è rendere visibile il processo di segmentazione: non solo il risultato finale, ma anche i passaggi intermedi, i parametri, i casi limite e le differenze tra approcci.
+In coda a questo documento sono allegati due pdf: 
+- Tutorial per la riproduzione del setup sperimentale, in classe o a casa.
+- Descrizione e analisi dei risultati di un esperimento condotto da noi nelle stesse condizioni (il dataset comune, vedi sotto).
+
+---
+
+## Caricamento immagine
+L’interfaccia permette di iniziare da un’immagine del dataset incluso oppure da un file caricato manualmente. La demo è pensata per essere usata online: è sufficiente selezionare una foto e procedere.
+
+![Caricamento immagine](assets/14-16/Fig1_cariacamento.JPG)
+
+---
+
+## Struttura generale: tre fasi
+L’analisi è organizzata in tre schede:
+
+1. **Calibrazione del riferimento**
+2. **Segmentazione colore (deterministica)**
+3. **Segmentazione AI (FastSAM)**
+
+![Panoramica delle fasi](assets/14-16/Fig2_fasi.JPG)
+
+---
+
+## 📐 Fase 1 — Calibrazione del riferimento
+
+In questa fase si calibra la **cornice di riferimento** presente nella fotografia. La calibrazione serve a standardizzare l’analisi e a rendere confrontabili fotografie di tempi diversi o di piante diverse, perché fornisce un’area di riferimento in pixel su cui rapportare le misure della pianta.
+
+Sono disponibili due modalità:
+
+### Modalità automatica (deterministica)
+L’algoritmo utilizza l’informazione sul colore dello sfondo e della cornice per applicare una serie di soglie preimpostate e generare più maschere candidate. Su ciascun risultato cerca strutture compatibili con un quadrilatero (basandosi sulla presenza di linee rette), quindi confronta i risultati ottenuti nelle diverse iterazioni e propone una soluzione finale per consenso.
+
+L’output è mostrato in tre pannelli:
+- fotografia di partenza,
+- maschera,
+- geometria individuata (quadrilatero proposto).
+
+![Fase 1 automatica](assets/14-16/Fig3_fase1_auto.JPG)
+
+### Modalità manuale
+La modalità manuale espone direttamente i parametri di soglia nei vari spazi di colore. È quindi possibile controllare in modo esplicito l’isolamento della cornice, modificando minimi e massimi degli assi selezionati.
+
+È anche possibile campionare un colore direttamente dall’immagine con un click: il sistema aggiorna automaticamente i valori soglia costruendo un piccolo intervallo di tolleranza attorno al colore selezionato, che può poi essere rifinito manualmente.
+
+In questo caso il terzo pannello mostrerà anche tutte le linee rette compatibili con la maschera individuata.
+
+![Fase 1 manuale](assets/14-16/Fig4_fase1_manuale.JPG)
+
+---
+
+## 🌱 Fase 2 — Segmentazione colore (thresholding deterministico)
+
+Questa fase isola la pianta tramite **sogliatura** (thresholding) e successiva pulizia della maschera.
+
+La demo permette di lavorare sia su **spazi di colore** (HSV, RGB, LAB) sia su **ExG** i valori di default corrispondono a quelli generalmente ottimali, è possibile variarli per osservare gli effetti risultanti.
+
+Nota importante **ExG (Excess Green)** non è uno spazio di colore: è un **indice** calcolato a partire dai canali RGB, molto usato per evidenziare la vegetazione.
+Nella forma usata qui:
+**ExG = 2G - R - B**
+
+
+Dopo la sogliatura, la maschera può contenere:
+- piccoli pixel isolati (rumore),
+- buchi all’interno della regione segmentata,
+- bordi irregolari.
+
+La **pulizia morfologica** è un post-processing della maschera binaria che itera processi di erosione e dilatazione:
+- **Opening** → rimuovere piccoli elementi/rumore : https://it.wikipedia.org/wiki/Apertura_(morfologia)
+- **Closing** → chiudere piccoli buchi o interruzioni : https://it.wikipedia.org/wiki/Chiusura_(morfologia)
+- **Open + Close** → combinazione dei due effetti
+
+Come nella Fase 1, il click sull’immagine può essere usato per campionare un colore e inizializzare i parametri intorno a quel valore; il risultato viene aggiornato mostrando la segmentazione e l’output esportabile.
+
+![Fase 2 segmentazione colore](assets/14-16/Fig5_fase2.JPG)
+
+---
+## 🧠 Nota introduttiva alla fase 3
+
+La terza fase introduce l'utilizzo dell'AI con FastSAM. 
+**FastSAM** è un piccolo e veloce “Segment Anything Model” (SAM), open source e orientato all’efficienza. 
+
+**SAM** è un modello di segmentazione “promptable”, cioè un modello che produce maschere a partire da un prompt (ad esempio un click, un box, ecc.). 
+Nella pratica, SAM è diventato un riferimento per le pipeline che usano prompt (click, box, regioni) per selezionare un oggetto, ma è molto pesante e richiede risorse computazionali importanti.
+
+Questo progetto è pensato per essere **interattivo** e fruibile con risorse computazionali limitate. 
+
+FastSAM è scelta utile per la demo (veloce e gratuito), ma implica un compromesso: stiamo mostrando un modello **forte ma piccolo**, e con architettura diversa dai SAM più pesanti / più recenti.
+
+### Nota di interpretazione dei risultati (importante)
+I fallimenti o i bordi non perfetti osservabili nella pipeline **AI** e **ibrida** di questa demo sono utili per capire limiti reali dei metodi, ma non vanno generalizzati.
+
+In particolare:
+- una parte dei limiti osservati dipende dalla **classe di modello** scelta,
+- una parte dipende dalla **taglia del modello** e dalle risorse disponibili,
+- una parte dipende dalla **pipeline locale** (le regole deterministiche introdotte da noi).
+
+Sistemi più sofisticati (o versioni più pesanti / più recenti) riducono notevolmente questi problemi.
+
+## 🧠 Fase 3 — Segmentazione AI (FastSAM)
+
+La terza fase permette di confrontare due modalità operative:
+
+- **AI con click sull’immagine** (segmentazione dell’oggetto selezionato),
+- **algoritmo ibrido automatico** (loop deterministico con chiamate FastSAM).
+
+Nel caso AI con click, il comportamento dipende dal punto selezionato: il modello segmenta l’oggetto associato a quel click.
+L’esempio seguente mostra un caso importante: cliccando sul vaso, FastSAM segmenta il vaso invece della pianta.
+
+![FastSAM: esempio di segmentazione del vaso](assets/14-16/Fig7_IA_semantica.JPG)
+
+Nella modalità ibrida, la pipeline combina vincoli deterministici e segmentazione AI:
+
+1. usa la cornice calibrata (Fase 1) per definire un’area valida di ricerca;
+2. seleziona punti candidati all’interno dell’area (centroide e punti successivi ricavati da una logica geometrica sulla zona ancora disponibile);
+3. interroga FastSAM più volte con point prompt;
+4. filtra/accumula le istanze ottenute;
+5. seleziona la maschera finale con una regola deterministica (ExG più alto).
+
+![Fase 3 AI / ibrido](assets/14-16/Fig6_fase3.JPG)
+
+---
+
+## Casi particolari e limiti (presenti nel dataset)
+Il dataset incluso contiene casi non banali, utili per osservare il comportamento reale della pipeline, ad esempio:
+
+- casi in cui la segmentazione standard in **ExG** richiede ritocco dei parametri (campione stressato B 26 DAT),
+- casi in cui la calibrazione automatica della **cornice** non è ottimale (campione non stressato B 26 DAT),
+- casi in cui il metodo **ibrido** fallisce (campione stressato C 19 DAT, campione non stressato A 23 DAT ),
+- casi in cui la componente **AI** seleziona o segmenta male l’oggetto (campione stressato A 9 DAT).
+
+---
+
+## Documenti allegati
+
+📄 **Tutorial setup sperimentale (PDF)**  
+[Apri / scarica il documento](assets/14-16/Tutorial_setup_sperimentale.pdf)
+
+
+📄 **Risultati analitici e interpretazione (PDF)**  
+[Apri / scarica il documento](assets/14-16/Scheda_esperimento.pdf)
+
+
+---
+
+## Approfondimenti — spazi colore, thresholding, morfologia, modelli SAM
+<details>
+<summary><b>Apri gli approfondimenti</b></summary>
+
+### Video consigliato (spazi colore)
+Panoramica molto chiara sugli spazi di colore (in inglese, con sottotitoli):
+
+- https://www.youtube.com/watch?v=7KYwi2F5Ce4
+
+---
+
+### Segment Anything (SAM) / FastSAM / varianti efficienti
+
+#### SAM (Segment Anything Model) — fonti ufficiali
+- Paper (arXiv): https://arxiv.org/abs/2304.02643
+- Repository ufficiale (Meta): https://github.com/facebookresearch/segment-anything
+
+#### SAM 2 (immagini + video)
+- Paper (arXiv): https://arxiv.org/abs/2408.00714
+- Repository ufficiale (Meta): https://github.com/facebookresearch/sam2
+- Pagina di ricerca Meta: https://ai.meta.com/research/sam2/
+
+#### FastSAM (modello usato nello Space)
+- Paper (arXiv): https://arxiv.org/abs/2306.12156
+- Repository ufficiale: https://github.com/CASIA-IVA-Lab/FastSAM
+
+#### Varianti/derivati efficienti o specializzati (per confronto)
+- MobileSAM (lightweight SAM): https://github.com/ChaoningZhang/MobileSAM
+- Paper MobileSAM / Towards Lightweight SAM for Mobile Applications: https://arxiv.org/abs/2306.14289
+- HQ-SAM (high-quality masks): https://github.com/SysCV/sam-hq
+
+---
+
+### Spazi colore
+- RGB: https://it.wikipedia.org/wiki/RGB
+- HSL/HSV: https://it.wikipedia.org/wiki/HSL_e_HSV
+- Spazio colore Lab: https://it.wikipedia.org/wiki/Spazio_colore_Lab
+
+### Thresholding / sogliatura
+- Metodo di Otsu: https://it.wikipedia.org/wiki/Metodo_Otsu

TEST_REPORT_REV7.md

@@ -0,0 +1,34 @@
+# Report di verifica REV7
+
+## Struttura
+
+- Quattro tab principali: 6-9, 9-11, 11-14, 14-16.
+- Nessun `gr.Accordion` nei file Python.
+- Dataset condiviso: 48 immagini; nessuna seconda copia del dataset 14-16.
+- Un solo loader FastSAM condiviso in `fastsam_shared.py`.
+- Presente l'ancora `@spaces.GPU(duration=1)` richiesta dal runtime ZeroGPU.
+- `spaces` non è fissato in `requirements.txt`, per evitare conflitti con la versione installata dal runtime Hugging Face.
+
+## Test automatici eseguiti
+
+- Compilazione Python di `app.py`: superata.
+- Compilazione Python di `advanced_14_16.py`: superata.
+- Compilazione Python di `fastsam_shared.py`: superata.
+- Costruzione completa dell'interfaccia Gradio: superata nell'ambiente locale disponibile.
+- Avvio server locale sulla porta 7860: superato; processo mantenuto attivo fino al timeout del test.
+- Calibrazione automatica su `NS_A_14.jpg` con sfondo nero e cornice rossa: riferimento individuato in 5 tentativi su 5.
+- Segmentazione automatica ExG sullo stesso campione: maschera, overlay, metriche e file PNG prodotti.
+- Calibrazione manuale: percorso funzionale verificato.
+- Metodo ibrido: flusso verificato con un modello FastSAM simulato, incluse cinque iterazioni, selezione tramite ExG e produzione di output.
+- FastSAM puntuale condiviso: flusso verificato con un modello simulato.
+
+## Documentazione 14-16
+
+- `README_14-16.md` conserva il testo e le schermate reali del precedente Space; sono stati aggiornati soltanto i percorsi relativi degli asset e aggiunta una nota iniziale sulla nuova disposizione della GUI.
+- `Tutorial_setup_sperimentale.pdf` è copiato senza modifica.
+- `Scheda_esperimento.pdf` è copiata senza modifica.
+- I due PDF non sono duplicati nella cartella degli asset comuni.
+
+## Limiti del test locale
+
+L'ambiente di preparazione dispone di Gradio 6.5.1, mentre lo Space usa Gradio 5.49.1 come già collaudato nella REV6.1. La costruzione della GUI e l'avvio sono stati verificati con la versione locale; il build definitivo con Gradio 5.49.1 e il runtime ZeroGPU devono essere verificati su Hugging Face mediante Factory rebuild. L'inferenza reale FastSAM non è stata eseguita localmente perché il peso viene precaricato nel build Hugging Face; il codice usa lo stesso loader CPU condiviso già adottato nella REV6.1.

advanced_14_16.py

@@ -0,0 +1,551 @@
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import Any, Callable
+
+import cv2
+import gradio as gr
+import numpy as np
+
+_FASTSAM_LOADER: Callable | None = None
+
+
+def _rgb(image: Any) -> np.ndarray | None:
+    if image is None:
+        return None
+    arr = np.asarray(image)
+    if arr.ndim == 2:
+        arr = cv2.cvtColor(arr.astype(np.uint8), cv2.COLOR_GRAY2RGB)
+    if arr.ndim != 3:
+        raise ValueError("Formato immagine non supportato.")
+    if arr.shape[-1] == 4:
+        arr = cv2.cvtColor(arr.astype(np.uint8), cv2.COLOR_RGBA2RGB)
+    return arr.astype(np.uint8)
+
+
+def _save_png(image: np.ndarray, prefix: str) -> str:
+    fd, path = tempfile.mkstemp(prefix=prefix, suffix=".png")
+    os.close(fd)
+    cv2.imwrite(path, cv2.cvtColor(image, cv2.COLOR_RGB2BGR))
+    return path
+
+
+def _mask_rgb(mask: np.ndarray) -> np.ndarray:
+    return cv2.cvtColor(mask.astype(np.uint8), cv2.COLOR_GRAY2RGB)
+
+
+def _overlay(image: np.ndarray, mask: np.ndarray, tint=(30, 220, 80)) -> np.ndarray:
+    out = image.copy()
+    color = np.zeros_like(image)
+    color[:] = np.array(tint, dtype=np.uint8)
+    idx = mask > 0
+    if np.any(idx):
+        out[idx] = cv2.addWeighted(image[idx], 0.56, color[idx], 0.44, 0)
+    return out
+
+
+def _order_vertices(pts: np.ndarray) -> np.ndarray:
+    pts = np.asarray(pts, dtype=np.float32).reshape((4, 2))
+    rect = np.zeros((4, 2), dtype=np.float32)
+    sums = pts.sum(axis=1)
+    rect[0] = pts[np.argmin(sums)]
+    rect[2] = pts[np.argmax(sums)]
+    diff = np.diff(pts, axis=1).ravel()
+    rect[1] = pts[np.argmin(diff)]
+    rect[3] = pts[np.argmax(diff)]
+    return rect
+
+
+def _automatic_frame_mask(image: np.ndarray, frame: str, step: int) -> np.ndarray:
+    hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    s_min = max(50, 150 - step * 25)
+    v_min = max(50, 150 - step * 25)
+    v_max_dark = min(200, 50 + step * 25)
+    v_min_light = max(100, 200 - step * 20)
+    if frame == "Rossa":
+        lower1, upper1 = np.array([0, s_min, v_min]), np.array([10, 255, 255])
+        lower2, upper2 = np.array([170, s_min, v_min]), np.array([179, 255, 255])
+        return cv2.bitwise_or(cv2.inRange(hsv, lower1, upper1), cv2.inRange(hsv, lower2, upper2))
+    if frame == "Blu":
+        return cv2.inRange(hsv, np.array([100, s_min, v_min]), np.array([140, 255, 255]))
+    if frame == "Viola":
+        return cv2.inRange(hsv, np.array([125, s_min, v_min]), np.array([165, 255, 255]))
+    if frame == "Bianca":
+        return cv2.inRange(gray, v_min_light, 255)
+    return cv2.inRange(gray, 0, v_max_dark)
+
+
+def _quad_from_mask(mask: np.ndarray) -> np.ndarray | None:
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))
+    closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    edges = cv2.Canny(closed, 50, 150)
+    lines = cv2.HoughLines(edges, 1, np.pi / 180, 100)
+    if lines is None:
+        return None
+    horizontal, vertical = [], []
+    for line in lines:
+        rho, theta = line[0]
+        angle = theta * 180 / np.pi
+        if 45 < angle < 135:
+            horizontal.append((rho, theta))
+        else:
+            cos = np.cos(theta)
+            vertical.append((rho, theta, rho / cos if abs(cos) > 1e-8 else rho))
+    if len(horizontal) < 2 or len(vertical) < 2:
+        return None
+    horizontal.sort(key=lambda x: x[0])
+    vertical.sort(key=lambda x: x[2])
+    top, bottom = horizontal[0], horizontal[-1]
+    left, right = vertical[0][:2], vertical[-1][:2]
+
+    def intersection(l1, l2):
+        matrix = np.array([[np.cos(l1[1]), np.sin(l1[1])], [np.cos(l2[1]), np.sin(l2[1])]])
+        vector = np.array([l1[0], l2[0]])
+        try:
+            point = np.linalg.solve(matrix, vector)
+            return [int(round(point[0])), int(round(point[1]))]
+        except Exception:
+            return None
+
+    vertices = [intersection(top, left), intersection(top, right), intersection(bottom, right), intersection(bottom, left)]
+    if any(v is None for v in vertices):
+        return None
+    quad = np.asarray(vertices, dtype=np.float32)
+    h, w = mask.shape
+    area = cv2.contourArea(quad)
+    if not (w * h * 0.05 < area < w * h * 0.95):
+        return None
+    return _order_vertices(quad)
+
+
+def calibrate_reference_auto(image: Any, background: str, frame: str):
+    rgb = _rgb(image)
+    if rgb is None:
+        return None, None, "0", "Caricare una fotografia.", None
+    masks, quads = [], []
+    for step in range(5):
+        mask = _automatic_frame_mask(rgb, frame, step)
+        masks.append(mask)
+        quad = _quad_from_mask(mask)
+        if quad is not None:
+            quads.append(quad)
+    if not quads:
+        return _mask_rgb(masks[2]), rgb.copy(), "0", "Riferimento non individuato. Usare la regolazione manuale visibile sotto.", None
+    median = np.median(np.asarray(quads), axis=0).astype(np.int32)
+    contour = median.reshape((-1, 1, 2))
+    geometry = rgb.copy()
+    cv2.polylines(geometry, [contour], True, (25, 220, 70), 5)
+    for vertex in median:
+        cv2.circle(geometry, tuple(vertex), 13, (255, 45, 45), -1)
+    area = int(abs(cv2.contourArea(median)))
+    return _mask_rgb(masks[2]), geometry, f"{area}", f"Riferimento rilevato: consenso in {len(quads)} tentativi su 5.", contour
+
+
+def _convert_space(image: np.ndarray, space: str) -> np.ndarray:
+    if space == "HSV":
+        return cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+    if space == "LAB":
+        return cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+    return image.copy()
+
+
+def _space_updates(space: str):
+    if space == "HSV":
+        values = [("H minimo", 30, 179, True), ("H massimo", 80, 179, True), ("S minimo", 40, 255, True), ("S massimo", 255, 255, True), ("V minimo", 40, 255, True), ("V massimo", 255, 255, True)]
+    elif space == "ExG":
+        values = [("Soglia minima ExG", 40, 255, True), ("", 255, 255, False), ("", 0, 255, False), ("", 255, 255, False), ("", 0, 255, False), ("", 255, 255, False)]
+    elif space == "LAB":
+        values = [("L minimo", 0, 255, True), ("L massimo", 255, 255, True), ("a minimo", 0, 255, True), ("a massimo", 110, 255, True), ("b minimo", 130, 255, True), ("b massimo", 255, 255, True)]
+    else:
+        values = [("R minimo", 0, 255, True), ("R massimo", 100, 255, True), ("G minimo", 100, 255, True), ("G massimo", 255, 255, True), ("B minimo", 0, 255, True), ("B massimo", 100, 255, True)]
+    return tuple(gr.update(label=label, value=value, maximum=maximum, visible=visible) for label, value, maximum, visible in values)
+
+
+def _threshold_mask(image: np.ndarray, space: str, values: list[float]) -> np.ndarray:
+    c1_min, c1_max, c2_min, c2_max, c3_min, c3_max = values
+    if space == "ExG":
+        f = image.astype(np.float32)
+        exg = 2 * f[:, :, 1] - f[:, :, 0] - f[:, :, 2]
+        return np.where(exg >= float(c1_min), 255, 0).astype(np.uint8)
+    conv = _convert_space(image, space)
+    lo = np.array([min(c1_min, c1_max), min(c2_min, c2_max), min(c3_min, c3_max)], dtype=np.uint8)
+    hi = np.array([max(c1_min, c1_max), max(c2_min, c2_max), max(c3_min, c3_max)], dtype=np.uint8)
+    return cv2.inRange(conv, lo, hi)
+
+
+def _morph(mask: np.ndarray, mode: str, intensity: int) -> np.ndarray:
+    if mode == "Nessuna" or int(intensity) <= 0:
+        return mask
+    size = int(intensity) * 2 + 1
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (size, size))
+    if mode == "Apertura":
+        return cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    if mode == "Chiusura":
+        return cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    return cv2.morphologyEx(cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel), cv2.MORPH_CLOSE, kernel)
+
+
+def _auto_morph(mask: np.ndarray, image: np.ndarray) -> np.ndarray:
+    size = 3 if max(image.shape[:2]) < 1400 else 5
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (size, size))
+    return cv2.morphologyEx(cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel), cv2.MORPH_CLOSE, kernel)
+
+
+def calibrate_reference_manual(image: Any, space: str, c1_min, c1_max, c2_min, c2_max, c3_min, c3_max):
+    rgb = _rgb(image)
+    if rgb is None:
+        return None, None, "0", "Caricare una fotografia.", None
+    mask = _threshold_mask(rgb, space, [c1_min, c1_max, c2_min, c2_max, c3_min, c3_max])
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    quad = _quad_from_mask(mask)
+    geometry = rgb.copy()
+    area = 0
+    contour = None
+    if quad is not None:
+        contour = quad.astype(np.int32).reshape((-1, 1, 2))
+        area = int(abs(cv2.contourArea(quad)))
+        cv2.polylines(geometry, [contour], True, (25, 220, 70), 5)
+        for v in quad.astype(np.int32):
+            cv2.circle(geometry, tuple(v), 13, (255, 45, 45), -1)
+        message = "Riferimento individuato con le soglie manuali."
+    else:
+        message = "Riferimento non individuato con queste soglie."
+    return _mask_rgb(mask), geometry, str(area), message, contour
+
+
+def sample_manual_thresholds(image: Any, space: str, evt: gr.SelectData):
+    rgb = _rgb(image)
+    if rgb is None:
+        return _space_updates(space)
+    try:
+        x, y = map(int, evt.index)
+    except Exception:
+        return _space_updates(space)
+    h, w = rgb.shape[:2]
+    if not (0 <= x < w and 0 <= y < h):
+        return _space_updates(space)
+    pixel = rgb[y, x]
+    if space == "ExG":
+        r, g, b = [float(v) for v in pixel]
+        exg = int(np.clip(2 * g - r - b, -255, 510))
+        return (gr.update(value=max(-255, exg - 20)), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
+    converted = _convert_space(np.uint8([[pixel]]), space)[0, 0]
+    max1 = 179 if space == "HSV" else 255
+    vals = [int(v) for v in converted]
+    return (
+        gr.update(value=max(0, vals[0] - 25)), gr.update(value=min(max1, vals[0] + 25)),
+        gr.update(value=max(0, vals[1] - 25)), gr.update(value=min(255, vals[1] + 25)),
+        gr.update(value=max(0, vals[2] - 25)), gr.update(value=min(255, vals[2] + 25)),
+    )
+
+
+def _valid_area_mask(image: np.ndarray, quad: Any) -> np.ndarray:
+    valid = np.zeros(image.shape[:2], dtype=np.uint8)
+    if quad is None:
+        valid.fill(255)
+    else:
+        contour = np.asarray(quad, dtype=np.int32).reshape((-1, 1, 2))
+        cv2.fillPoly(valid, [contour], 255)
+    return valid
+
+
+def _measurement_values(mask: np.ndarray, image: np.ndarray, quad: Any, width_cm: float, height_cm: float, l1_cm: float, l2_cm: float):
+    plant_px = int(np.count_nonzero(mask))
+    valid = _valid_area_mask(image, quad)
+    ref_px = int(np.count_nonzero(valid))
+    pct = 100.0 * plant_px / ref_px if ref_px else 0.0
+    area_cm2 = None
+    try:
+        width_cm, height_cm, l1_cm, l2_cm = map(float, [width_cm, height_cm, l1_cm, l2_cm])
+        if width_cm > 0 and height_cm > 0 and l1_cm > 0 and l2_cm > 0 and ref_px > 0:
+            area_cm2 = (plant_px / ref_px) * (width_cm * height_cm) * ((l2_cm / l1_cm) ** 2)
+    except Exception:
+        area_cm2 = None
+    return plant_px, ref_px, pct, area_cm2
+
+
+def _metrics_html(mask: np.ndarray, image: np.ndarray, quad: Any, width_cm: float, height_cm: float, l1_cm: float, l2_cm: float, title="Risultati") -> str:
+    plant_px, ref_px, pct, area_cm2 = _measurement_values(mask, image, quad, width_cm, height_cm, l1_cm, l2_cm)
+    real = f"{area_cm2:.2f} cm²" if area_cm2 is not None else "—"
+    plant_text = f"{plant_px:,}".replace(",", ".")
+    ref_text = f"{ref_px:,}".replace(",", ".")
+    return (
+        f'<div class="metrics-wrap"><div class="metrics-title">{title}</div><div class="metric-grid">'
+        f'<div class="metric-card"><span>Pixel pianta</span><strong>{plant_text}</strong></div>'
+        f'<div class="metric-card"><span>Pixel riferimento</span><strong>{ref_text}</strong></div>'
+        f'<div class="metric-card"><span>Area sul riferimento</span><strong>{pct:.2f}%</strong></div>'
+        f'<div class="metric-card"><span>Area reale stimata</span><strong>{real}</strong></div>'
+        '</div></div>'
+    )
+
+
+def automatic_plant_segmentation(image: Any, quad: Any, width_cm, height_cm, l1_cm, l2_cm):
+    rgb = _rgb(image)
+    if rgb is None:
+        return None, None, '<div class="warning">Caricare una fotografia.</div>', "Caricare una fotografia.", None, None
+    f = rgb.astype(np.float32)
+    exg = 2 * f[:, :, 1] - f[:, :, 0] - f[:, :, 2]
+    mask = np.where(exg >= 40, 255, 0).astype(np.uint8)
+    mask = _auto_morph(mask, rgb)
+    mask = cv2.bitwise_and(mask, _valid_area_mask(rgb, quad))
+    over = _overlay(rgb, mask)
+    clean = cv2.bitwise_and(rgb, rgb, mask=mask)
+    return _mask_rgb(mask), over, _metrics_html(mask, rgb, quad, width_cm, height_cm, l1_cm, l2_cm, "Segmentazione automatica"), "Eseguita segmentazione ExG con pulizia automatica.", _save_png(clean, "pianta_auto_"), mask
+
+
+def manual_plant_segmentation(image: Any, space: str, c1_min, c1_max, c2_min, c2_max, c3_min, c3_max, morph_mode: str, morph_int: int, quad: Any, width_cm, height_cm, l1_cm, l2_cm):
+    rgb = _rgb(image)
+    if rgb is None:
+        return None, None, '<div class="warning">Caricare una fotografia.</div>', "Caricare una fotografia.", None, None
+    mask = _threshold_mask(rgb, space, [c1_min, c1_max, c2_min, c2_max, c3_min, c3_max])
+    mask = _morph(mask, morph_mode, morph_int)
+    mask = cv2.bitwise_and(mask, _valid_area_mask(rgb, quad))
+    over = _overlay(rgb, mask)
+    clean = cv2.bitwise_and(rgb, rgb, mask=mask)
+    return _mask_rgb(mask), over, _metrics_html(mask, rgb, quad, width_cm, height_cm, l1_cm, l2_cm, "Segmentazione manuale"), f"Eseguita segmentazione in {space}.", _save_png(clean, "pianta_manuale_"), mask
+
+
+def metrics_from_mask_component(mask_image: Any, source_image: Any, quad: Any, width_cm, height_cm, l1_cm, l2_cm):
+    rgb = _rgb(source_image)
+    arr = _rgb(mask_image)
+    if rgb is None or arr is None:
+        return '<div class="warning">Nessuna maschera disponibile.</div>', None
+    gray = cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY)
+    mask = np.where(gray > 127, 255, 0).astype(np.uint8)
+    clean = cv2.bitwise_and(rgb, rgb, mask=mask)
+    return _metrics_html(mask, rgb, quad, width_cm, height_cm, l1_cm, l2_cm, "FastSAM"), _save_png(clean, "pianta_fastsam_")
+
+
+def hybrid_automatic(image: Any, quad: Any, width_cm, height_cm, l1_cm, l2_cm, progress=gr.Progress()):
+    rgb = _rgb(image)
+    if rgb is None:
+        return None, None, '<div class="warning">Caricare una fotografia.</div>', "Caricare una fotografia.", None
+    if _FASTSAM_LOADER is None:
+        return None, None, '<div class="warning">FastSAM non configurato.</div>', "FastSAM non configurato.", None
+    h, w = rgb.shape[:2]
+    valid = _valid_area_mask(rgb, quad)
+    ref_px = max(1, int(np.count_nonzero(valid)))
+    exclude = cv2.bitwise_not(valid)
+    instances = []
+    model = _FASTSAM_LOADER()
+    max_side = 1024
+    scale = min(1.0, max_side / max(h, w))
+    infer = cv2.resize(rgb, (round(w * scale), round(h * scale)), interpolation=cv2.INTER_AREA) if scale < 1 else rgb
+
+    for step in range(5):
+        progress((step + 0.2) / 5.5, desc=f"FastSAM: tentativo {step + 1} di 5")
+        allowed = cv2.bitwise_not(exclude)
+        if np.count_nonzero(allowed) / ref_px < 0.10:
+            break
+        if step == 0:
+            m = cv2.moments(valid)
+            if m["m00"] == 0:
+                break
+            cx, cy = int(m["m10"] / m["m00"]), int(m["m01"] / m["m00"])
+        else:
+            dist = cv2.distanceTransform(allowed, cv2.DIST_L2, 5)
+            _, max_val, _, max_loc = cv2.minMaxLoc(dist)
+            if max_val < 5:
+                break
+            cx, cy = max_loc
+        ix, iy = round(cx * scale), round(cy * scale)
+        try:
+            results = model.predict(infer, points=[[ix, iy]], labels=[1], device="cpu", imgsz=1024, retina_masks=True, verbose=False)
+        except Exception as exc:
+            return None, None, '<div class="warning">Errore FastSAM.</div>', f"FastSAM non disponibile: {exc}", None
+        if not results or results[0].masks is None or len(results[0].masks.data) == 0:
+            cv2.circle(exclude, (cx, cy), 20, 255, -1)
+            continue
+        data = results[0].masks.data.detach().float().cpu().numpy()
+        candidates = []
+        for raw in data:
+            candidate = cv2.resize(raw, (w, h), interpolation=cv2.INTER_NEAREST) > 0.5
+            if candidate[cy, cx]:
+                candidates.append(candidate)
+        selected = min(candidates, key=lambda m: int(m.sum())) if candidates else (cv2.resize(data[0], (w, h), interpolation=cv2.INTER_NEAREST) > 0.5)
+        mask = selected.astype(np.uint8) * 255
+        mask = cv2.bitwise_and(mask, valid)
+        new_pixels = cv2.bitwise_and(mask, cv2.bitwise_not(exclude))
+        if np.count_nonzero(new_pixels) < 100:
+            cv2.circle(exclude, (cx, cy), 20, 255, -1)
+            continue
+        instances.append(mask)
+        exclude = cv2.bitwise_or(exclude, mask)
+
+    if not instances:
+        return None, None, '<div class="warning">Il metodo ibrido non ha isolato una regione valida.</div>', "Il metodo ibrido non ha isolato una regione valida.", None
+
+    f = rgb.astype(np.float32)
+    exg = np.clip(2 * f[:, :, 1] - f[:, :, 0] - f[:, :, 2], -255, 510)
+    scores = [cv2.mean(exg.astype(np.float32), mask=m)[0] for m in instances]
+    best = instances[int(np.argmax(scores))]
+    over = _overlay(rgb, best, (165, 55, 220))
+    clean = cv2.bitwise_and(rgb, rgb, mask=best)
+    return _mask_rgb(best), over, _metrics_html(best, rgb, quad, width_cm, height_cm, l1_cm, l2_cm, "Metodo ibrido"), f"Esplorazione completata: {len(instances)} regioni candidate, selezione finale tramite ExG.", _save_png(clean, "pianta_ibrida_")
+
+
+def _guide_html():
+    return '''<div class="guide-panel"><h3>Guida rapida</h3>
+    <p><b>1 · Caricamento</b><br>Usa il dataset oppure carica una fotografia.</p>
+    <p><b>2 · Calibrazione</b><br>Prova prima il rilevamento automatico della cornice. Se serve, usa i controlli manuali già visibili.</p>
+    <p><b>3 · Segmentazione</b><br>Esegui il metodo automatico e controlla maschera, overlay e misure. Poi sperimenta con gli altri spazi di colore.</p>
+    <p><b>4 · FastSAM</b><br>Clicca la pianta, controlla il punto e avvia la segmentazione.</p>
+    <p><b>5 · Metodo ibrido</b><br>Il programma esplora più regioni con FastSAM e seleziona quella con risposta ExG maggiore.</p>
+    <p><b>6 · Esportazione</b><br>Scarica le immagini pulite prodotte nei diversi passaggi.</p></div>'''
+
+
+def _steps_html():
+    labels = ["Caricamento", "Calibrazione", "Segmentazione e misure", "FastSAM", "Metodo ibrido", "Esportazione"]
+    boxes = "".join(f'<div class="step-box"><span>{i}</span><b>{label}</b></div>' for i, label in enumerate(labels, 1))
+    return f'<div class="step-strip">{boxes}</div>'
+
+
+def build_14_16_tab(load_dataset_image, sync_fastsam_source, select_fastsam_point, run_fastsam_cpu, load_fastsam_cpu):
+    global _FASTSAM_LOADER
+    _FASTSAM_LOADER = load_fastsam_cpu
+
+    with gr.Tab("14-16"):
+        gr.Markdown("## Laboratorio di analisi: calibrazione, segmentazione e misura")
+        gr.Markdown("Il percorso riunisce le funzioni del precedente Space sperimentale in una sequenza continua. Le azioni automatiche sono evidenziate; i controlli manuali rimangono sempre visibili sotto ogni passaggio.")
+        gr.HTML(_steps_html())
+
+        quad_state = gr.State(None)
+        fastsam_point = gr.State(None)
+        automatic_mask_state = gr.State(None)
+
+        with gr.Row():
+            with gr.Column(scale=4):
+                with gr.Group(elem_classes=["workflow-panel"]):
+                    gr.HTML('<div class="panel-kicker">1 · CARICAMENTO</div>')
+                    with gr.Row():
+                        source = gr.Image(type="numpy", label="Fotografia del campione", interactive=True, height=430)
+                        with gr.Column():
+                            condition = gr.Radio(["NS", "S"], value="NS", label="Condizione dataset")
+                            replicate = gr.Radio(["A", "B", "C"], value="A", label="Replica")
+                            day = gr.Dropdown(["06", "09", "11", "14", "16", "19", "23", "26"], value="14", label="Giorno dal trapianto")
+                            load_btn = gr.Button("Carica dal dataset", variant="primary", elem_classes=["action-button"])
+                            load_status = gr.Textbox(label="Stato", interactive=False)
+                    gr.HTML('<div class="note">La fotografia viene caricata una sola volta e alimenta tutti i passaggi successivi.</div>')
+
+                with gr.Group(elem_classes=["workflow-panel"]):
+                    gr.HTML('<div class="panel-kicker">2 · CALIBRAZIONE DEL RIFERIMENTO</div>')
+                    gr.Markdown("### Rilevamento automatico")
+                    gr.Markdown("Usa per primo questo comando. I valori iniziali corrispondono al setup del dataset: sfondo nero e cornice rossa.")
+                    with gr.Row():
+                        bg = gr.Dropdown(["Nero", "Bianco"], value="Nero", label="Colore dello sfondo")
+                        frame = gr.Dropdown(["Rossa", "Nera", "Bianca", "Viola", "Blu"], value="Rossa", label="Colore della cornice")
+                        auto_cal_btn = gr.Button("Rileva automaticamente il riferimento", variant="primary", elem_classes=["action-button"])
+                    with gr.Row():
+                        cal_mask = gr.Image(label="Maschera del riferimento", interactive=False, height=300)
+                        cal_geom = gr.Image(label="Geometria rilevata", interactive=False, height=300)
+                    with gr.Row():
+                        ref_px = gr.Textbox(label="Area del riferimento in pixel", interactive=False)
+                        cal_status = gr.Textbox(label="Esito della calibrazione", interactive=False)
+
+                    with gr.Group(elem_classes=["manual-panel"]):
+                        gr.Markdown("### Regolazione manuale")
+                        gr.Markdown("Questi controlli restano disponibili se il rilevamento automatico non è soddisfacente. Facendo click sulla fotografia sorgente si inizializzano le soglie intorno al colore selezionato.")
+                        cal_space = gr.Radio(["HSV", "ExG", "RGB", "LAB"], value="HSV", label="Rappresentazione del colore")
+                        with gr.Row():
+                            r1min = gr.Slider(0, 179, 30, label="H minimo")
+                            r1max = gr.Slider(0, 179, 80, label="H massimo")
+                            r2min = gr.Slider(0, 255, 40, label="S minimo")
+                            r2max = gr.Slider(0, 255, 255, label="S massimo")
+                            r3min = gr.Slider(0, 255, 40, label="V minimo")
+                            r3max = gr.Slider(0, 255, 255, label="V massimo")
+                        manual_cal_btn = gr.Button("Calcola il riferimento con le soglie manuali", variant="primary", elem_classes=["action-button"])
+
+                    gr.Markdown("### Misure geometriche per l’area reale")
+                    gr.Markdown("La percentuale rispetto alla cornice è disponibile senza misure reali. Per stimare i cm² inserire base, altezza e le distanze L1 e L2 descritte nel tutorial del setup.")
+                    with gr.Row():
+                        width_cm = gr.Number(value=0, label="Base del riferimento · cm")
+                        height_cm = gr.Number(value=0, label="Altezza del riferimento · cm")
+                        l1_cm = gr.Number(value=0, label="Distanza L1 · cm")
+                        l2_cm = gr.Number(value=0, label="Distanza L2 · cm")
+
+                with gr.Group(elem_classes=["workflow-panel"]):
+                    gr.HTML('<div class="panel-kicker">3 · SEGMENTAZIONE E MISURE</div>')
+                    gr.Markdown("### Segmentazione automatica")
+                    gr.Markdown("Il primo tentativo usa ExG con soglia iniziale e pulizia morfologica automatica. Non richiede regolazioni.")
+                    auto_seg_btn = gr.Button("Esegui la segmentazione automatica", variant="primary", elem_classes=["action-button"])
+                    with gr.Row():
+                        auto_mask = gr.Image(label="Maschera automatica", interactive=False, height=330)
+                        auto_overlay = gr.Image(label="Overlay automatico", interactive=False, height=330)
+                    auto_metrics = gr.HTML()
+                    auto_status = gr.Textbox(label="Esito", interactive=False)
+                    auto_file = gr.File(label="Scarica la pianta segmentata", interactive=False)
+
+                    with gr.Group(elem_classes=["manual-panel"]):
+                        gr.Markdown("### Regolazione manuale della segmentazione")
+                        gr.Markdown("Usa questi parametri per confrontare ExG, HSV, RGB e Lab e per osservare l’effetto della pulizia morfologica.")
+                        seg_space = gr.Radio(["ExG", "HSV", "RGB", "LAB"], value="ExG", label="Metodo di segmentazione")
+                        with gr.Row():
+                            s1min = gr.Slider(0, 255, 40, label="Soglia minima ExG")
+                            s1max = gr.Slider(0, 255, 255, label="", visible=False)
+                            s2min = gr.Slider(0, 255, 0, label="", visible=False)
+                            s2max = gr.Slider(0, 255, 255, label="", visible=False)
+                            s3min = gr.Slider(0, 255, 0, label="", visible=False)
+                            s3max = gr.Slider(0, 255, 255, label="", visible=False)
+                        with gr.Row():
+                            morph_mode = gr.Radio(["Nessuna", "Apertura", "Chiusura", "Apertura + chiusura"], value="Apertura + chiusura", label="Pulizia morfologica")
+                            morph_int = gr.Slider(1, 10, value=2, step=1, label="Intensità della pulizia")
+                        manual_seg_btn = gr.Button("Esegui la segmentazione con i parametri manuali", variant="primary", elem_classes=["action-button"])
+                        with gr.Row():
+                            manual_mask = gr.Image(label="Maschera manuale", interactive=False, height=300)
+                            manual_overlay = gr.Image(label="Overlay manuale", interactive=False, height=300)
+                        manual_metrics = gr.HTML()
+                        manual_status = gr.Textbox(label="Esito", interactive=False)
+                        manual_file = gr.File(label="Scarica la pianta segmentata", interactive=False)
+
+                with gr.Group(elem_classes=["workflow-panel"]):
+                    gr.HTML('<div class="panel-kicker">4 · FASTSAM</div>')
+                    gr.HTML('<div class="fastsam-instruction"><b>Procedura</b><br>1. Clicca sulla pianta nell’immagine qui sotto.<br>2. Controlla il punto rosso.<br>3. Premi <b>Segmenta l’oggetto indicato</b>.</div>')
+                    fastsam_image = gr.Image(type="numpy", label="Clicca sulla pianta", interactive=True, height=430)
+                    fastsam_message = gr.Textbox(label="Istruzioni e risultato", value="Caricare una fotografia e scegliere un punto.", interactive=False)
+                    fastsam_btn = gr.Button("Segmenta l’oggetto indicato", variant="primary", elem_classes=["action-button"])
+                    with gr.Row():
+                        fastsam_mask = gr.Image(label="Maschera FastSAM", interactive=False, visible=False, height=320)
+                        fastsam_overlay = gr.Image(label="Overlay FastSAM", interactive=False, visible=False, height=320)
+                    fastsam_metrics = gr.HTML()
+                    fastsam_file = gr.File(label="Scarica la pianta segmentata", interactive=False)
+                    fastsam_overlay_state = gr.State(None)
+
+                with gr.Group(elem_classes=["workflow-panel"]):
+                    gr.HTML('<div class="panel-kicker">5 · METODO IBRIDO</div>')
+                    gr.Markdown("Il metodo esplora automaticamente più regioni con FastSAM all’interno del riferimento e seleziona la regione finale confrontando l’indice ExG. È il passaggio più impegnativo sulla CPU.")
+                    hybrid_btn = gr.Button("Esegui il metodo ibrido automatico", variant="primary", elem_classes=["action-button"])
+                    with gr.Row():
+                        hybrid_mask = gr.Image(label="Maschera ibrida", interactive=False, height=320)
+                        hybrid_overlay = gr.Image(label="Overlay ibrido", interactive=False, height=320)
+                    hybrid_metrics = gr.HTML()
+                    hybrid_status = gr.Textbox(label="Esito", interactive=False)
+                    hybrid_file = gr.File(label="Scarica la pianta segmentata", interactive=False)
+
+                with gr.Group(elem_classes=["workflow-panel"]):
+                    gr.HTML('<div class="panel-kicker">6 · ESPORTAZIONE E DOCUMENTAZIONE</div>')
+                    gr.Markdown("I file prodotti nei passaggi precedenti possono essere scaricati direttamente dai rispettivi pannelli.")
+                    gr.Markdown("- [Guida tecnica dettagliata 14-16](README_14-16.md)\n- [Tutorial setup sperimentale](assets/14-16/Tutorial_setup_sperimentale.pdf)\n- [Scheda esperimento](assets/14-16/Scheda_esperimento.pdf)")
+
+            with gr.Column(scale=1, min_width=270):
+                gr.HTML(_guide_html())
+                gr.HTML('<div class="docs-panel"><h3>Documentazione</h3><p><a href="README_14-16.md" target="_blank">Guida tecnica 14-16</a></p><p><a href="assets/14-16/Tutorial_setup_sperimentale.pdf" target="_blank">Tutorial setup</a></p><p><a href="assets/14-16/Scheda_esperimento.pdf" target="_blank">Scheda esperimento</a></p></div>')
+
+        load_btn.click(load_dataset_image, [condition, replicate, day], [source, load_status])
+        auto_cal_btn.click(calibrate_reference_auto, [source, bg, frame], [cal_mask, cal_geom, ref_px, cal_status, quad_state])
+        manual_cal_btn.click(calibrate_reference_manual, [source, cal_space, r1min, r1max, r2min, r2max, r3min, r3max], [cal_mask, cal_geom, ref_px, cal_status, quad_state])
+        cal_space.change(_space_updates, cal_space, [r1min, r1max, r2min, r2max, r3min, r3max], show_progress="hidden")
+        source.select(sample_manual_thresholds, [source, cal_space], [r1min, r1max, r2min, r2max, r3min, r3max], show_progress="hidden")
+
+        auto_seg_btn.click(automatic_plant_segmentation, [source, quad_state, width_cm, height_cm, l1_cm, l2_cm], [auto_mask, auto_overlay, auto_metrics, auto_status, auto_file, automatic_mask_state])
+        seg_space.change(_space_updates, seg_space, [s1min, s1max, s2min, s2max, s3min, s3max], show_progress="hidden")
+        manual_seg_btn.click(manual_plant_segmentation, [source, seg_space, s1min, s1max, s2min, s2max, s3min, s3max, morph_mode, morph_int, quad_state, width_cm, height_cm, l1_cm, l2_cm], [manual_mask, manual_overlay, manual_metrics, manual_status, manual_file, automatic_mask_state])
+
+        source.change(sync_fastsam_source, source, [fastsam_image, fastsam_point, fastsam_mask, fastsam_overlay, fastsam_message, fastsam_overlay_state], show_progress="hidden")
+        fastsam_image.select(select_fastsam_point, [source], [fastsam_image, fastsam_point, fastsam_message], show_progress="hidden")
+        fastsam_btn.click(run_fastsam_cpu, [source, fastsam_point], [fastsam_mask, fastsam_overlay, fastsam_message, fastsam_overlay_state], concurrency_limit=1).then(
+            metrics_from_mask_component, [fastsam_mask, source, quad_state, width_cm, height_cm, l1_cm, l2_cm], [fastsam_metrics, fastsam_file]
+        )
+        hybrid_btn.click(hybrid_automatic, [source, quad_state, width_cm, height_cm, l1_cm, l2_cm], [hybrid_mask, hybrid_overlay, hybrid_metrics, hybrid_status, hybrid_file], concurrency_limit=1)

app.py

@@ -4,7 +4,6 @@ import os
 import tempfile
 from pathlib import Path
 from typing import Any
-from functools import lru_cache
 
 os.environ.setdefault("YOLO_CONFIG_DIR", "/tmp/Ultralytics")
 
@@ -15,7 +14,8 @@ from PIL import Image, ImageDraw, ImageFont
 from reportlab.lib.pagesizes import A4
 from reportlab.lib.utils import ImageReader
 from reportlab.pdfgen import canvas
-from huggingface_hub import hf_hub_download
+from fastsam_shared import load_fastsam_cpu
+from advanced_14_16 import build_14_16_tab
 
 try:
     import spaces
@@ -33,8 +33,6 @@ DATASET_DIR = Path("dataset")
 DAYS = ["06", "09", "11", "14", "16", "19", "23", "26"]
 CONDITIONS = ["NS", "S"]
 REPLICATES = ["A", "B", "C"]
-FASTSAM_REPO = "Uminosachi/FastSAM"
-FASTSAM_FILENAME = "FastSAM-s.pt"
 
 
 @spaces.GPU(duration=1)
@@ -66,6 +64,17 @@ CSS = """
 .action-button button:hover, button.action-button:hover {background:#155333 !important}
 .action-button button:disabled, button.action-button:disabled {background:#8ca79a !important;color:#f6f6f6 !important}
 .result-card img {border-radius:12px !important}
+.workflow-panel {border:1px solid #cbd8cf !important;border-radius:10px !important;padding:14px !important;margin:10px 0 18px 0 !important;background:#ffffff !important}
+.manual-panel {border:1px solid #9fb3a7 !important;border-left:5px solid #6f8f7a !important;border-radius:8px !important;padding:14px !important;margin:14px 0 !important;background:#f8faf8 !important}
+.panel-kicker {font-weight:800;color:#17653a;letter-spacing:.04em;font-size:1.02rem;margin-bottom:8px}
+.step-strip {display:flex;gap:7px;flex-wrap:wrap;margin:10px 0 18px 0}
+.step-box {display:flex;align-items:center;gap:8px;min-width:145px;flex:1;background:#edf6ef;border:1px solid #b9d2c0;border-radius:9px;padding:9px 12px;color:#194e31}
+.step-box span {display:inline-flex;align-items:center;justify-content:center;width:28px;height:28px;border-radius:50%;background:#1f6f43;color:white;font-weight:800}
+.guide-panel,.docs-panel {background:#f7faf8;border:1px solid #d2ddd5;border-radius:10px;padding:14px;margin:10px 0;line-height:1.42}
+.guide-panel h3,.docs-panel h3 {color:#17653a;margin-top:0}
+.metrics-wrap {margin:8px 0 12px}.metrics-title{font-weight:800;color:#194e31;margin-bottom:7px}.metric-grid{display:grid;grid-template-columns:repeat(4,minmax(120px,1fr));gap:8px}.metric-card{border:1px solid #d4ded7;border-radius:8px;padding:10px;background:#f8fbf9}.metric-card span{display:block;font-size:.82rem;color:#596660}.metric-card strong{display:block;font-size:1.35rem;color:#153c28;margin-top:3px}
+@media(max-width:900px){.metric-grid{grid-template-columns:repeat(2,minmax(120px,1fr))}.step-box{min-width:45%}}
+
 """
 
 
@@ -700,26 +709,6 @@ def compare_green_pair(image_a: Any, image_b: Any):
 # -----------------------------------------------------------------------------
 
 
-@lru_cache(maxsize=1)
-def load_fastsam_cpu():
-    """Carica FastSAM una sola volta e lo mantiene esplicitamente su CPU."""
-    from ultralytics import FastSAM
-
-    local_weight = Path(FASTSAM_FILENAME)
-    if local_weight.exists():
-        weight_path = local_weight
-    else:
-        weight_path = Path(
-            hf_hub_download(repo_id=FASTSAM_REPO, filename=FASTSAM_FILENAME)
-        )
-    model = FastSAM(str(weight_path))
-    # Il percorso visibile agli utenti deve restare CPU anche nello Space ZeroGPU.
-    try:
-        model.model.to("cpu")
-    except Exception:
-        pass
-    return model
-
 
 def sync_fastsam_source(image: Any):
     """Sincronizza la copia cliccabile e azzera i risultati precedenti."""
@@ -860,9 +849,9 @@ def compare_overlays(color_overlay, ai_overlay):
 
 
 with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hue="green"), css=CSS) as demo:
-    gr.Markdown("# Computer vision e piante - percorsi 6-14 anni")
+    gr.Markdown("# Computer vision e piante - percorsi 6-16 anni")
     gr.Markdown(
-        "Lo Space raccoglie tre moduli distinti. Il dataset sperimentale completo rimane disponibile "
+        "Lo Space raccoglie quattro percorsi progressivi. Il dataset sperimentale completo rimane condiviso "
         "per le attività che richiedono fotografie già acquisite."
     )
 
@@ -914,7 +903,8 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
                 height=440,
             )
 
-            with gr.Accordion("1. Esplora un patch 5×5", open=True):
+            with gr.Group(elem_classes=["workflow-panel"]):
+                gr.Markdown("### 1. Esplora un patch 5×5")
                 gr.Markdown(
                     "Fare click sulla fotografia. Il programma ingrandisce esattamente 25 pixel e scrive "
                     "direttamente su ciascun pixel i valori del colore."
@@ -939,7 +929,8 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
                     show_progress="hidden",
                 )
 
-            with gr.Accordion("2. Laboratorio del colore", open=False):
+            with gr.Group(elem_classes=["workflow-panel"]):
+                gr.Markdown("### 2. Laboratorio del colore")
                 gr.HTML(
                     '<div class="info">La fotografia caricata sopra viene trasferita automaticamente nel pennello. '
                     "Dipingere una zona, scegliere un canale e applicare una variazione additiva. "
@@ -1015,6 +1006,7 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
             "Caricare la fotografia della caccia alla pianta segmentabile oppure scegliere un'immagine del dataset. "
             "La stessa immagine viene utilizzata in tutti i passaggi."
         )
+        gr.HTML('<div class="step-strip"><div class="step-box"><span>1</span><b>Caricamento</b></div><div class="step-box"><span>2</span><b>HSV</b></div><div class="step-box"><span>3</span><b>ExG</b></div><div class="step-box"><span>4</span><b>FastSAM</b></div><div class="step-box"><span>5</span><b>Confronto</b></div></div>')
         c_color_overlay_state = gr.State(None)
         c_ai_overlay_state = gr.State(None)
         with gr.Row():
@@ -1044,19 +1036,20 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
             [c_default_mask, c_default_overlay, c_default_message, c_default_raw],
         ).then(lambda x: x, c_default_overlay, c_color_overlay_state)
 
-        with gr.Accordion("Prova a modificare le soglie nello spazio HSV", open=False):
+        with gr.Group(elem_classes=["manual-panel"]):
+            gr.Markdown("### 2. Modifica le soglie nello spazio HSV")
             gr.Markdown(
                 "H descrive la tonalità lungo un cerchio da 0° a 360°. S descrive la saturazione e V la luminosità. "
                 "Modificando i limiti cambia l'insieme dei pixel accettati."
             )
             with gr.Row():
-                c_h_min = gr.Slider(0, 360, value=DEFAULT_HSV["h_min"], step=2, label="H minimo (°)")
-                c_h_max = gr.Slider(0, 360, value=DEFAULT_HSV["h_max"], step=2, label="H massimo (°)")
+                c_h_min = gr.Slider(0, 360, value=DEFAULT_HSV["h_min"], step=2, label="H minimo · gradi")
+                c_h_max = gr.Slider(0, 360, value=DEFAULT_HSV["h_max"], step=2, label="H massimo · gradi")
             with gr.Row():
-                c_s_min = gr.Slider(0, 100, value=DEFAULT_HSV["s_min"], step=1, label="S minimo (%)")
-                c_s_max = gr.Slider(0, 100, value=DEFAULT_HSV["s_max"], step=1, label="S massimo (%)")
-                c_v_min = gr.Slider(0, 100, value=DEFAULT_HSV["v_min"], step=1, label="V minimo (%)")
-                c_v_max = gr.Slider(0, 100, value=DEFAULT_HSV["v_max"], step=1, label="V massimo (%)")
+                c_s_min = gr.Slider(0, 100, value=DEFAULT_HSV["s_min"], step=1, label="S minimo · %")
+                c_s_max = gr.Slider(0, 100, value=DEFAULT_HSV["s_max"], step=1, label="S massimo · %")
+                c_v_min = gr.Slider(0, 100, value=DEFAULT_HSV["v_min"], step=1, label="V minimo · %")
+                c_v_max = gr.Slider(0, 100, value=DEFAULT_HSV["v_max"], step=1, label="V massimo · %")
             c_custom_button = gr.Button("Applica le soglie HSV modificate", variant="primary", elem_classes=["action-button"])
             with gr.Row():
                 c_custom_mask = gr.Image(label="Maschera HSV modificata", interactive=False)
@@ -1069,7 +1062,8 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
                 [c_custom_mask, c_custom_overlay, c_custom_message, c_custom_raw],
             ).then(lambda x: x, c_custom_overlay, c_color_overlay_state)
 
-        with gr.Accordion("Prova l'indice ExG", open=False):
+        with gr.Group(elem_classes=["workflow-panel"]):
+            gr.Markdown("### 3. Prova l’indice ExG")
             gr.HTML(
                 '<div class="info"><b>ExG = 2G - R - B.</b> Il programma calcola questo valore per ogni pixel '
                 "e conserva i pixel per i quali ExG supera la soglia scelta.</div>"
@@ -1088,7 +1082,8 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
             ).then(lambda x: x, c_exg_overlay, c_color_overlay_state)
 
         c_fastsam_point = gr.State(None)
-        with gr.Accordion("Adesso prova FastSAM", open=False):
+        with gr.Group(elem_classes=["workflow-panel"]):
+            gr.Markdown("### 4. Prova FastSAM")
             gr.HTML(
                 '<div class="fastsam-instruction"><b>Procedura FastSAM</b><br>'
                 '1. Cliccare sulla pianta nell’immagine immediatamente sotto.<br>'
@@ -1151,6 +1146,14 @@ with gr.Blocks(title="Computer vision e piante", theme=gr.themes.Soft(primary_hu
         c_compare = gr.Image(label="Metodo cromatico | FastSAM", interactive=False)
         c_compare_button.click(compare_overlays, [c_color_overlay_state, c_ai_overlay_state], c_compare)
 
+    build_14_16_tab(
+        load_dataset_image=load_dataset_image,
+        sync_fastsam_source=sync_fastsam_source,
+        select_fastsam_point=select_fastsam_point,
+        run_fastsam_cpu=run_fastsam_cpu,
+        load_fastsam_cpu=load_fastsam_cpu,
+    )
+
 
 if __name__ == "__main__":
     demo.queue(default_concurrency_limit=4).launch(

assets/14-16/Scheda_esperimento.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3cbf7a3a59db1ed1178f04158ad60cd823c1313733991cbe2ee632566caf2c19
+size 983970

assets/14-16/Tutorial_setup_sperimentale.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf68fe5a8d9832899f1fb5a54ec80a360de516412f3395bb541b95fd2081d549
+size 337935

dataset/README_dataset.md

@@ -4,4 +4,4 @@ Il dataset contiene 48 fotografie: due condizioni (`NS` non stress, `S` stress i
 
 Esempio: `S_B_19.jpg` indica condizione di stress idrico, replica B, 19 giorni dal trapianto.
 
-Le immagini derivano dall’esperimento CREA-OF descritto in `assets/comuni/Scheda_esperimento.pdf`. Il protocollo fotografico è riportato in `assets/comuni/Tutorial_setup_sperimentale.pdf`.
+Le immagini derivano dall’esperimento CREA-OF descritto in `assets/14-16/Scheda_esperimento.pdf`. Il protocollo fotografico è riportato in `assets/14-16/Tutorial_setup_sperimentale.pdf`.

fastsam_shared.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+os.environ.setdefault("YOLO_CONFIG_DIR", "/tmp/Ultralytics")
+
+FASTSAM_REPO = "Uminosachi/FastSAM"
+FASTSAM_FILENAME = "FastSAM-s.pt"
+
+
+@lru_cache(maxsize=1)
+def load_fastsam_cpu():
+    """Carica una sola istanza FastSAM e la mantiene esplicitamente su CPU."""
+    from ultralytics import FastSAM
+
+    local_weight = Path(FASTSAM_FILENAME)
+    if local_weight.exists():
+        weight_path = local_weight
+    else:
+        weight_path = Path(hf_hub_download(repo_id=FASTSAM_REPO, filename=FASTSAM_FILENAME))
+    model = FastSAM(str(weight_path))
+    try:
+        model.model.to("cpu")
+    except Exception:
+        pass
+    return model