Update app.py

app.py

@@ -38,7 +38,7 @@ def calcola_dats_disponibili(dataset_dir=DATASET_DIR, samples=SAMPLES, expected_
 AVAILABLE_DATS = calcola_dats_disponibili()
 
 # ==========================================
-# 1. FUNZIONI DI UTILITÀ (CON PROTEZIONE RAM)
+# 1. FUNZIONI DI UTILITÀ
 # ==========================================
 @lru_cache(maxsize=16)
 def _load_rgb(filepath: str) -> np.ndarray | None:
@@ -63,45 +63,84 @@ def carica_da_dataset(condizione: str, campione: str, dat: str):
         filepath = os.path.join(DATASET_DIR, filename)
         if os.path.exists(filepath):
             img = _load_rgb(filepath)
-            # Restituisce l'immagine alle 3 tab
             return img, img, img, f"✅ Caricato: {filename}"
             
-    blank = np.zeros((600, 900, 3), dtype=np.uint8)
-    cv2.putText(blank, f"Non trovato: {candidates[0]}", (30, 300), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
+    blank = np.zeros((350, 700, 3), dtype=np.uint8)
+    cv2.putText(blank, f"Non trovato: {candidates[0]}", (30, 175), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
     return blank, blank, blank, f"❌ Errore: File mancante."
 
-def ordina_min_max(v1, v2):
-    return int(min(v1, v2)), int(max(v1, v2))
+def get_spazio_attivo(main_space, alt_space):
+    """Sceglie lo spazio colore attivo gestendo la priorità della tendina avanzata."""
+    return alt_space if alt_space != "Nessuno" else main_space
 
-def converti_spazio_colore(image: np.ndarray, color_space: str) -> np.ndarray:
+def aggiorna_sliders(spazio_principale, spazio_altri):
+    """Resetta etichette, valori ottimali e visibilità in base allo spazio colore selezionato."""
+    spazio = get_spazio_attivo(spazio_principale, spazio_altri)
+    
+    if spazio == "HSV":
+        return (gr.update(label="Tinta (H) Min", value=20, visible=True), gr.update(label="Tinta (H) Max", value=80, visible=True),
+                gr.update(label="Saturazione (S) Min", value=40, visible=True), gr.update(label="Saturazione (S) Max", value=255, visible=True),
+                gr.update(label="Valore (V) Min", value=40, visible=True), gr.update(label="Valore (V) Max", value=255, visible=True))
+    elif spazio == "ExG":
+        return (gr.update(label="Soglia Minima ExG", value=40, visible=True), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False),
+                gr.update(visible=False), gr.update(visible=False))
+    elif spazio == "LAB":
+        return (gr.update(label="Luminanza (L) Min", value=0, visible=True), gr.update(label="Luminanza (L) Max", value=255, visible=True),
+                gr.update(label="Asse A (Verde-Rosso) Min", value=0, visible=True), gr.update(label="Asse A (Verde-Rosso) Max", value=110, visible=True),
+                gr.update(label="Asse B (Blu-Giallo) Min", value=130, visible=True), gr.update(label="Asse B (Blu-Giallo) Max", value=255, visible=True))
+    else: # RGB
+        return (gr.update(label="Rosso (R) Min", value=0, visible=True), gr.update(label="Rosso (R) Max", value=100, visible=True),
+                gr.update(label="Verde (G) Min", value=100, visible=True), gr.update(label="Verde (G) Max", value=255, visible=True),
+                gr.update(label="Blu (B) Min", value=0, visible=True), gr.update(label="Blu (B) Max", value=100, visible=True))
+
+def converti_spazio_colore(image, color_space):
     if color_space == "HSV": return cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
     elif color_space == "LAB": return cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
     return image.copy()
 
-def cattura_colore(image: np.ndarray, evt: gr.SelectData, color_space: str):
+def cattura_colore(image, evt: gr.SelectData, s_main, s_alt):
     if image is None: return (0, 255, 0, 255, 0, 255)
     x, y = evt.index
     h, w = image.shape[:2]
     if not (0 <= x < w and 0 <= y < h): return (0, 255, 0, 255, 0, 255)
+    
+    spazio = get_spazio_attivo(s_main, s_alt)
     pixel_rgb = image[y, x]
+    
+    if spazio == "ExG":
+        r, g, b = float(pixel_rgb[0]), float(pixel_rgb[1]), float(pixel_rgb[2])
+        exg = int(np.clip(2 * g - r - b, 0, 255))
+        delta = 20
+        return (max(0, exg-delta), 255, 0, 255, 0, 255) # Modifica solo la soglia min
+    
     pixel_img = np.uint8([[pixel_rgb]])
-    pixel_conv = converti_spazio_colore(pixel_img, color_space)[0][0]
+    pixel_conv = converti_spazio_colore(pixel_img, spazio)[0][0]
     v1, v2, v3 = [int(v) for v in pixel_conv]
     delta = 25
     return (max(0, v1-delta), min(255, v1+delta), max(0, v2-delta), min(255, v2+delta), max(0, v3-delta), min(255, v3+delta))
 
 # ==========================================
-# 2. MOTORE GEOMETRICO (FASE 1 - NASTRO)
+# 2. MOTORE GEOMETRICO (FASE 1)
 # ==========================================
-def elabora_nastro(image, color_space, c1_min, c1_max, c2_min, c2_max, c3_min, c3_max):
-    if image is None: return None, None, "0", "In attesa..."
+def ordina_min_max(v1, v2): return int(min(v1, v2)), int(max(v1, v2))
+
+def elabora_nastro(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min, c3_max):
+    if image is None: return None, None, "0", "In attesa...", None, gr.update(visible=False), gr.update(visible=False)
 
+    spazio = get_spazio_attivo(s_main, s_alt)
     min1, max1 = ordina_min_max(c1_min, c1_max)
-    min2, max2 = ordina_min_max(c2_min, c2_max)
-    min3, max3 = ordina_min_max(c3_min, c3_max)
 
-    img_conv = converti_spazio_colore(image, color_space)
-    mask = cv2.inRange(img_conv, np.array([min1, min2, min3]), np.array([max1, max2, max3]))
+    if spazio == "ExG":
+        img_float = image.astype(np.float32)
+        r, g, b = img_float[:,:,0], img_float[:,:,1], img_float[:,:,2]
+        exg = np.clip(2 * g - r - b, 0, 255).astype(np.uint8)
+        mask = cv2.inRange(exg, min1, 255)
+    else:
+        min2, max2 = ordina_min_max(c2_min, c2_max)
+        min3, max3 = ordina_min_max(c3_min, c3_max)
+        img_conv = converti_spazio_colore(image, spazio)
+        mask = cv2.inRange(img_conv, np.array([min1, min2, min3]), np.array([max1, max2, max3]))
 
     kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))
     mask_closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
@@ -113,6 +152,9 @@ def elabora_nastro(image, color_space, c1_min, c1_max, c2_min, c2_max, c3_min, c
 
     area_pixel = 0
     log_msg = "Linee trovate. "
+    quad_state_val = None
+    mostra_area = gr.update(visible=False)
+    mostra_btn_auto = gr.update(visible=False)
 
     if lines is not None:
         orizzontali, verticali = [], []
@@ -137,45 +179,28 @@ def elabora_nastro(image, color_space, c1_min, c1_max, c2_min, c2_max, c3_min, c
             def intersezione(l1, l2):
                 A = np.array([[np.cos(l1[1]), np.sin(l1[1])], [np.cos(l2[1]), np.sin(l2[1])]])
                 b = np.array([l1[0], l2[0]])
-                try:
-                    inter = np.linalg.solve(A, b)
-                    return (int(round(inter[0])), int(round(inter[1])))
-                except Exception: return None
+                try: return (int(round(np.linalg.solve(A, b)[0])), int(round(np.linalg.solve(A, b)[1])))
+                except: return None
 
             vertici = [intersezione(top, left), intersezione(top, right), intersezione(bottom, right), intersezione(bottom, left)]
 
             if None not in vertici:
-                vertici_np = np.array(vertici, dtype=np.int32).reshape((-1, 1, 2))
+                quad_state_val = np.array(vertici, dtype=np.int32).reshape((-1, 1, 2))
                 for v in vertici: cv2.circle(debug_img, v, 15, (255, 0, 0), -1)
-                cv2.polylines(debug_img, [vertici_np], isClosed=True, color=(0, 255, 0), thickness=4)
-                area_pixel = int(abs(cv2.contourArea(vertici_np)))
+                cv2.polylines(debug_img, [quad_state_val], isClosed=True, color=(0, 255, 0), thickness=4)
+                area_pixel = int(abs(cv2.contourArea(quad_state_val)))
                 log_msg += "Poligono chiuso."
+                mostra_area = gr.update(visible=True)
+                mostra_btn_auto = gr.update(visible=True)
             else: log_msg += "Poligono aperto."
         else: log_msg += "Lati mancanti."
     else: log_msg += "Nessuna linea rilevata."
 
-    return mask_visiva, debug_img, str(area_pixel), log_msg
+    return mask_visiva, debug_img, str(area_pixel), log_msg, quad_state_val, mostra_area, mostra_btn_auto
 
 # ==========================================
-# 3. MOTORE LATTUGA (TRADIZIONALE & ExG)
+# 3. MOTORE SEGMENTAZIONE PIANTA (FASE 2)
 # ==========================================
-def aggiorna_ui_spazio_colore(spazio):
-    if spazio == "HSV":
-        return (gr.update(label="Tinta (H) Min", visible=True), gr.update(label="Tinta (H) Max", visible=True),
-                gr.update(label="Saturazione (S) Min", visible=True), gr.update(label="Saturazione (S) Max", visible=True),
-                gr.update(label="Valore (V) Min", visible=True), gr.update(label="Valore (V) Max", visible=True))
-    elif spazio == "LAB":
-        return (gr.update(label="Luminanza (L) Min", visible=True), gr.update(label="Luminanza (L) Max", visible=True),
-                gr.update(label="Asse a (Verde-Rosso) Min", visible=True), gr.update(label="Asse a (Verde-Rosso) Max", visible=True),
-                gr.update(label="Asse b (Blu-Giallo) Min", visible=True), gr.update(label="Asse b (Blu-Giallo) Max", visible=True))
-    elif spazio == "ExG":
-        return (gr.update(label="Soglia ExG Min", visible=True), gr.update(visible=False),
-                gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False))
-    else:
-        return (gr.update(label="Rosso (R) Min", visible=True), gr.update(label="Rosso (R) Max", visible=True),
-                gr.update(label="Verde (G) Min", visible=True), gr.update(label="Verde (G) Max", visible=True),
-                gr.update(label="Blu (B) Min", visible=True), gr.update(label="Blu (B) Max", visible=True))
-
 def applica_morfologia(mask, tipo, intensita):
     if tipo == "Nessuna" or intensita == 0: return mask
     kernel_size = (intensita * 2) + 1
@@ -187,21 +212,21 @@ def applica_morfologia(mask, tipo, intensita):
         return cv2.morphologyEx(m, cv2.MORPH_CLOSE, kernel)
     return mask
 
-def elabora_lattuga_classica(image, color_space, c1_min, c1_max, c2_min, c2_max, c3_min, c3_max, morfo_tipo, morfo_int):
+def elabora_pianta(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min, c3_max, morfo_tipo, morfo_int):
     if image is None: return None, "0"
 
+    spazio = get_spazio_attivo(s_main, s_alt)
     min1, max1 = ordina_min_max(c1_min, c1_max)
 
-    if color_space == "ExG":
+    if spazio == "ExG":
         img_float = image.astype(np.float32)
         r, g, b = img_float[:,:,0], img_float[:,:,1], img_float[:,:,2]
-        exg = 2 * g - r - b
-        exg = np.clip(exg, 0, 255).astype(np.uint8)
-        mask = cv2.inRange(exg, min1, max1)
+        exg = np.clip(2 * g - r - b, 0, 255).astype(np.uint8)
+        mask = cv2.inRange(exg, min1, 255) # Usa solo il Minimo
     else:
         min2, max2 = ordina_min_max(c2_min, c2_max)
         min3, max3 = ordina_min_max(c3_min, c3_max)
-        img_conv = converti_spazio_colore(image, color_space)
+        img_conv = converti_spazio_colore(image, spazio)
         mask = cv2.inRange(img_conv, np.array([min1, min2, min3]), np.array([max1, max2, max3]))
 
     mask_pulita = applica_morfologia(mask, morfo_tipo, morfo_int)
@@ -210,42 +235,92 @@ def elabora_lattuga_classica(image, color_space, c1_min, c1_max, c2_min, c2_max,
     return segmented, f"{pixel_count} px"
 
 # ==========================================
-# 4. MOTORE AI (FASTSAM)
+# 4. MOTORE AI FASTSAM (FASE 3 - MANUALE E AUTO)
 # ==========================================
 @lru_cache(maxsize=1)
 def carica_fastsam():
-    """Scarica e carica FastSAM in RAM una sola volta."""
     from ultralytics import FastSAM
     return FastSAM("FastSAM-s.pt")
 
-def segmenta_ai(image, evt: gr.SelectData):
+def segmenta_ai_manuale(image, evt: gr.SelectData):
     if image is None: return None, "Nessuna immagine"
-    
     x, y = evt.index
     model = carica_fastsam()
     
-    # Inferenza AI
     results = model.predict(image, points=[[x, y]], labels=[1], device="cpu", verbose=False)
-    
     if len(results) > 0 and results[0].masks is not None:
         mask = results[0].masks.data[0].cpu().numpy()
         mask = cv2.resize(mask, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_NEAREST)
         mask = (mask * 255).astype(np.uint8)
         
         segmented = cv2.bitwise_and(image, image, mask=mask)
-        pixel_count = int(np.sum(mask == 255))
-        
-        # Disegna un mirino (crosshair) per mostrare dove ha cliccato lo studente
         cv2.drawMarker(segmented, (x, y), (255, 0, 0), cv2.MARKER_CROSS, 20, 3)
+        pixel_count = int(np.sum(mask == 255))
         return segmented, f"{pixel_count} px"
+    return image, "Nessun oggetto trovato."
+
+def segmenta_ai_automatico(image, quad_vertices):
+    if image is None: return None, "Immagine mancante."
+    if quad_vertices is None: return image, "Calibra il quadrilatero in Fase 1 prima di usare questa funzione."
+
+    h, w = image.shape[:2]
+    # 1. Crea la maschera del quadrilatero per isolare l'interno
+    valid_area = np.zeros((h, w), dtype=np.uint8)
+    cv2.fillPoly(valid_area, [quad_vertices], 255)
+
+    segmented_mask_total = np.zeros((h, w), dtype=np.uint8)
+    model = carica_fastsam()
+
+    iterazioni = 0
+    max_iter = 5
+
+    for _ in range(max_iter):
+        # 2. Trova l'area valida ANCORA NON segmentata
+        remaining = cv2.bitwise_and(valid_area, cv2.bitwise_not(segmented_mask_total))
+        
+        # 3. Trova il "pezzo" più grande rimasto
+        contours, _ = cv2.findContours(remaining, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours: break
+        
+        largest_contour = max(contours, key=cv2.contourArea)
+        if cv2.contourArea(largest_contour) < 300: break # Se è rimasto solo rumore, fermati
+        
+        # 4. Calcola il centro di massa del pezzo per usarlo come prompt SAM
+        M = cv2.moments(largest_contour)
+        if M["m00"] != 0:
+            cx = int(M["m10"] / M["m00"])
+            cy = int(M["m01"] / M["m00"])
+        else:
+            cx, cy = largest_contour[0][0][0], largest_contour[0][0][1]
+
+        # 5. Spara il punto a FastSAM
+        results = model.predict(image, points=[[cx, cy]], labels=[1], device="cpu", verbose=False)
+        
+        if len(results) > 0 and results[0].masks is not None:
+            mask = results[0].masks.data[0].cpu().numpy()
+            mask = cv2.resize(mask, (w, h), interpolation=cv2.INTER_NEAREST)
+            mask = (mask * 255).astype(np.uint8)
+            
+            # Limita la maschera AI per non sbordare mai fuori dal quadrilatero
+            mask = cv2.bitwise_and(mask, valid_area)
+            segmented_mask_total = cv2.bitwise_or(segmented_mask_total, mask)
+            iterazioni += 1
+        else: break
+
+    # 6. Genera l'immagine finale (Nera fuori, RGB segmentato dentro)
+    final_output = cv2.bitwise_and(image, image, mask=segmented_mask_total)
+    pixel_count = int(np.sum(segmented_mask_total == 255))
     
-    return image, "Nessun oggetto trovato in quel punto."
+    return final_output, f"Auto-Completato in {iterazioni} step AI. Totale: {pixel_count} px"
 
 # ==========================================
 # 5. INTERFACCIA UTENTE (UI)
 # ==========================================
 with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
     gr.Markdown("# 🥬 Computer Vision in Agricoltura: segmentazione")
+    
+    # Variabile invisibile per passare i dati del nastro dalla Fase 1 alla Fase 3
+    quad_state = gr.State(None)
 
     with gr.Group():
         gr.Markdown("### 📂 1. Usa il Dataset fornito o carica la tua immagine")
@@ -253,96 +328,121 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
             ui_cond = gr.Dropdown(UI_CONDITIONS, label="Condizione", value="No Stress")
             ui_camp = gr.Dropdown(SAMPLES, label="Campione", value="A")
             ui_dat = gr.Dropdown(AVAILABLE_DATS, label="Giorni (DAT)", value=AVAILABLE_DATS[0])
-            btn_carica = gr.Button("⬇️ Carica Foto dal dataset", variant="primary")
-            stato_db = gr.Textbox(label="Stato", interactive=False)
+            btn_carica = gr.Button("⬇️ Carica Foto", variant="primary")
+            stato_db = gr.Textbox(label="Stato Sistema", interactive=False)
 
     with gr.Tabs():
-        
-        # TAB 1: CALIBRAZIONE NASTRO
+        # --- TAB 1: GEOMETRIA ---
         with gr.Tab("📐 Fase 1: Calibrazione Riferimento"):
-            gr.Markdown("**Isola il riferimento**. L'algoritmo chiuderà i buchi, cercherà le rette e calcolerà le intersezioni.")
+            gr.Markdown("**Isola il nastro**. L'algoritmo calcolerà il quadrilatero interno per contenere la pianta.")
+            with gr.Group():
+                with gr.Row():
+                    sp_main_r = gr.Radio(["HSV", "ExG"], value="HSV", label="Spazio Colore Consigliato")
+                    with gr.Accordion("Altri Spazi di Colore (Avanzato)", open=False):
+                        sp_altri_r = gr.Radio(["Nessuno", "RGB", "LAB"], value="Nessuno", label="Override Spazio Colore")
+                
+                with gr.Row():
+                    with gr.Column():
+                        r1_min = gr.Slider(0, 255, 20, label="Tinta (H) Min")
+                        r1_max = gr.Slider(0, 255, 80, label="Tinta (H) Max")
+                    with gr.Column():
+                        r2_min = gr.Slider(0, 255, 40, label="Saturazione (S) Min")
+                        r2_max = gr.Slider(0, 255, 255, label="Saturazione (S) Max")
+                    with gr.Column():
+                        r3_min = gr.Slider(0, 255, 40, label="Valore (V) Min")
+                        r3_max = gr.Slider(0, 255, 255, label="Valore (V) Max")
+
             with gr.Row():
-                with gr.Column(scale=1):
-                    img_rif_in = gr.Image(label="Foto Operativa", interactive=True)
-                    spazio_colore_rif = gr.Radio(["RGB", "HSV", "LAB"], value="HSV", label="Analisi del riferimento")
-
-                    r1_min, r1_max = gr.Slider(0, 255, 0, label="C1 Min"), gr.Slider(0, 255, 255, label="C1 Max")
-                    r2_min, r2_max = gr.Slider(0, 255, 0, label="C2 Min"), gr.Slider(0, 255, 255, label="C2 Max")
-                    r3_min, r3_max = gr.Slider(0, 255, 0, label="C3 Min"), gr.Slider(0, 255, 255, label="C3 Max")
-                    sliders_r = [r1_min, r1_max, r2_min, r2_max, r3_min, r3_max]
-
-                with gr.Column(scale=1):
-                    img_mask_out = gr.Image(label="Step 1: Maschera Morfologica")
-                    img_geom_out = gr.Image(label="Step 2: Geometria (Rette e Angoli)")
-                    pixel_rif_out = gr.Textbox(label="🔥 AREA CORNICE (Pixel²)")
-                    log_geom = gr.Textbox(label="Log di Sistema")
-
-            img_rif_in.select(fn=cattura_colore, inputs=[img_rif_in, spazio_colore_rif], outputs=sliders_r)
-            for s in sliders_r + [spazio_colore_rif]:
+                img_rif_in = gr.Image(label="Foto Operativa", interactive=True, height=350)
+                img_mask_out = gr.Image(label="Step 1: Maschera Morfologica", height=350)
+                img_geom_out = gr.Image(label="Step 2: Geometria (Rette e Angoli)", height=350)
+
+            with gr.Row():
+                pixel_rif_out = gr.Textbox(label="🔥 AREA CORNICE (Pixel²)")
+                log_geom = gr.Textbox(label="Log di Sistema")
+                
+            # Area opzionale (visibile solo a quadrilatero chiuso)
+            with gr.Group(visible=False) as box_area_rif:
+                input_area_rif = gr.Number(label="Inserisci Area Reale Riferimento (opzionale)")
+
+            sliders_r = [r1_min, r1_max, r2_min, r2_max, r3_min, r3_max]
+            
+            # Gestione Eventi Tab 1
+            for sp in [sp_main_r, sp_altri_r]:
+                sp.change(fn=aggiorna_sliders, inputs=[sp_main_r, sp_altri_r], outputs=sliders_r)
+            img_rif_in.select(fn=cattura_colore, inputs=[img_rif_in, sp_main_r, sp_altri_r], outputs=sliders_r)
+            
+            for s in sliders_r + [sp_main_r, sp_altri_r]:
                 s.change(
                     fn=elabora_nastro,
-                    inputs=[img_rif_in, spazio_colore_rif] + sliders_r,
-                    outputs=[img_mask_out, img_geom_out, pixel_rif_out, log_geom],
+                    inputs=[img_rif_in, sp_main_r, sp_altri_r] + sliders_r,
+                    outputs=[img_mask_out, img_geom_out, pixel_rif_out, log_geom, quad_state, box_area_rif, gr.Button(visible=False)] # Il button triggera quello in tab 3
                 )
 
-        # TAB 2: SEGMENTAZIONE PIANTA
+        # --- TAB 2: COLORE PIANTA ---
         with gr.Tab("🌱 Fase 2: Segmentazione Colore e ExG"):
-            gr.Markdown("**Regola gli slider per isolare la pianta.** Usa l'indice ExG per un taglio rapido o HSV per un controllo preciso.")
-            
             with gr.Group():
                 with gr.Row():
-                    spazio_colore_lat = gr.Radio(["RGB", "HSV", "LAB", "ExG"], value="HSV", label="Spazio Colore / Indice")
+                    sp_main_l = gr.Radio(["HSV", "ExG"], value="ExG", label="Spazio Colore Consigliato")
+                    with gr.Accordion("Altri Spazi di Colore (Avanzato)", open=False):
+                        sp_altri_l = gr.Radio(["Nessuno", "RGB", "LAB"], value="Nessuno", label="Override Spazio Colore")
                 
                 with gr.Row():
                     with gr.Column():
-                        l1_min = gr.Slider(0, 255, 0, label="Tinta (H) Min")
-                        l1_max = gr.Slider(0, 255, 255, label="Tinta (H) Max")
+                        l1_min = gr.Slider(0, 255, 40, label="Soglia Minima ExG")
+                        l1_max = gr.Slider(0, 255, 255, label="Tinta (H) Max", visible=False)
                     with gr.Column():
-                        l2_min = gr.Slider(0, 255, 0, label="Saturazione (S) Min")
-                        l2_max = gr.Slider(0, 255, 255, label="Saturazione (S) Max")
+                        l2_min = gr.Slider(0, 255, 40, label="Saturazione (S) Min", visible=False)
+                        l2_max = gr.Slider(0, 255, 255, label="Saturazione (S) Max", visible=False)
                     with gr.Column():
-                        l3_min = gr.Slider(0, 255, 0, label="Valore (V) Min")
-                        l3_max = gr.Slider(0, 255, 255, label="Valore (V) Max")
+                        l3_min = gr.Slider(0, 255, 40, label="Valore (V) Min", visible=False)
+                        l3_max = gr.Slider(0, 255, 255, label="Valore (V) Max", visible=False)
                 
                 with gr.Row():
                     morfo_tipo = gr.Radio(["Nessuna", "Opening (Rimuove Rumore)", "Closing (Chiude Buchi)", "Open + Close"], value="Nessuna", label="Pulizia Morfologica")
                     morfo_int = gr.Slider(1, 10, value=3, step=1, label="Intensità Pulizia (Kernel Size)")
 
             with gr.Row():
-                img_lat_in = gr.Image(label="Immagine Originale", interactive=True)
-                with gr.Column():
-                    img_lat_out = gr.Image(label="Pianta Segmentata")
-                    pixel_lat_out = gr.Textbox(label="Pixel Lattuga Rilevati (Area)")
+                img_lat_in = gr.Image(label="Immagine Originale", interactive=True, height=350)
+                img_lat_out = gr.Image(label="Pianta Segmentata", height=350)
+            pixel_lat_out = gr.Textbox(label="Pixel Pianta Rilevati (Area)")
 
             sliders_l = [l1_min, l1_max, l2_min, l2_max, l3_min, l3_max]
             
-            img_lat_in.select(fn=cattura_colore, inputs=[img_lat_in, spazio_colore_lat], outputs=sliders_l)
-            spazio_colore_lat.change(fn=aggiorna_ui_spazio_colore, inputs=spazio_colore_lat, outputs=sliders_l)
+            # Gestione Eventi Tab 2
+            for sp in [sp_main_l, sp_altri_l]:
+                sp.change(fn=aggiorna_sliders, inputs=[sp_main_l, sp_altri_l], outputs=sliders_l)
+            img_lat_in.select(fn=cattura_colore, inputs=[img_lat_in, sp_main_l, sp_altri_l], outputs=sliders_l)
             
-            for s in sliders_l + [spazio_colore_lat, morfo_tipo, morfo_int]:
-                s.change(
-                    fn=elabora_lattuga_classica,
-                    inputs=[img_lat_in, spazio_colore_lat] + sliders_l + [morfo_tipo, morfo_int],
-                    outputs=[img_lat_out, pixel_lat_out],
-                )
+            for s in sliders_l + [sp_main_l, sp_altri_l, morfo_tipo, morfo_int]:
+                s.change(fn=elabora_pianta, inputs=[img_lat_in, sp_main_l, sp_altri_l] + sliders_l + [morfo_tipo, morfo_int], outputs=[img_lat_out, pixel_lat_out])
 
-        # TAB 3: AI (FASTSAM)
+        # --- TAB 3: AI FASTSAM ---
         with gr.Tab("🧠 Fase 3: AI (FastSAM)"):
-            gr.Markdown("**Segmentazione Automatica Zero-Shot.** Clicca direttamente su una foglia per isolare la pianta.")
+            gr.Markdown("**Clicca sulla pianta** per estrarla, oppure usa l'Auto-Segmentatore basato sulla cornice elaborata in Fase 1.")
+            
+            btn_auto_sam = gr.Button("🤖 Segmenta Automaticamente l'interno del Nastro", variant="primary", visible=False)
             
             with gr.Row():
-                img_ai_in = gr.Image(label="Clicca sulla pianta in questa finestra", interactive=True)
-                with gr.Column():
-                    img_ai_out = gr.Image(label="Risultato Rete Neurale")
-                    pixel_ai_out = gr.Textbox(label="Pixel Lattuga Rilevati (Area)")
-
-            img_ai_in.select(
-                fn=segmenta_ai,
-                inputs=[img_ai_in],
-                outputs=[img_ai_out, pixel_ai_out]
-            )
-
-    # Il pulsante di caricamento spara l'immagine in tutte e tre le tab!
+                img_ai_in = gr.Image(label="Clicca sull'oggetto", interactive=True, height=350)
+                img_ai_out = gr.Image(label="Risultato Rete Neurale", height=350)
+            pixel_ai_out = gr.Textbox(label="Pixel Pianta Rilevati (Area)")
+
+            # Evento Manuale
+            img_ai_in.select(fn=segmenta_ai_manuale, inputs=[img_ai_in], outputs=[img_ai_out, pixel_ai_out])
+            
+            # Evento Automatico (Iterativo)
+            btn_auto_sam.click(fn=segmenta_ai_automatico, inputs=[img_ai_in, quad_state], outputs=[img_ai_out, pixel_ai_out])
+            
+            # Il pulsante Auto-SAM si attiva solo se la Fase 1 calcola i vertici
+            img_rif_in.change(lambda: gr.update(visible=False), None, btn_auto_sam) # Nasconde se cambi foto
+
+            # Collegamento tra Tab 1 e bottone Tab 3
+            def aggiorna_btn_auto(quad):
+                return gr.update(visible=(quad is not None))
+            quad_state.change(fn=aggiorna_btn_auto, inputs=quad_state, outputs=btn_auto_sam)
+
+    # Caricamento Globale (Spara la foto a tutte le tab)
     btn_carica.click(
         fn=carica_da_dataset,
         inputs=[ui_cond, ui_camp, ui_dat],