Update app.py

app.py

@@ -70,27 +70,26 @@ def carica_da_dataset(condizione: str, campione: str, dat: str):
     return blank, blank, blank, f"❌ Errore: File mancante."
 
 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 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)
     
+    # FIX: Gestione corretta HUE (0-179) e visibilità
     if spazio == "HSV":
-        return (gr.update(label="Tinta (H) Min", value=20, visible=True), gr.update(label="Tinta (H) Max", value=80, visible=True),
+        return (gr.update(label="Tinta (H) Min", value=20, maximum=179, visible=True), gr.update(label="Tinta (H) Max", value=80, maximum=179, 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),
+        return (gr.update(label="Soglia Minima ExG", value=40, maximum=255, 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))
+        return (gr.update(label="Luminanza (L) Min", value=0, maximum=255, visible=True), gr.update(label="Luminanza (L) Max", value=255, maximum=255, visible=True),
+                gr.update(label="Asse A Min", value=0, visible=True), gr.update(label="Asse A Max", value=110, visible=True),
+                gr.update(label="Asse B Min", value=130, visible=True), gr.update(label="Asse B 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),
+        return (gr.update(label="Rosso (R) Min", value=0, maximum=255, visible=True), gr.update(label="Rosso (R) Max", value=100, maximum=255, 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))
 
@@ -111,14 +110,15 @@ def cattura_colore(image, evt: gr.SelectData, s_main, s_alt):
     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
+        return (max(0, exg-20), 255, 0, 255, 0, 255)
     
     pixel_img = np.uint8([[pixel_rgb]])
     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))
+    
+    # FIX: Limite HUE nel contagocce
+    max_v1 = 179 if spazio == "HSV" else 255
+    return (max(0, v1-25), min(max_v1, v1+25), max(0, v2-25), min(255, v2+25), max(0, v3-25), min(255, v3+25))
 
 # ==========================================
 # 2. MOTORE GEOMETRICO (FASE 1)
@@ -126,7 +126,8 @@ def cattura_colore(image, evt: gr.SelectData, s_main, s_alt):
 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)
+    # FIX: Tolto l'output fantasma che causava il Ghost Button
+    if image is None: return None, None, "0", "In attesa...", None, gr.update(visible=False)
 
     spazio = get_spazio_attivo(s_main, s_alt)
     min1, max1 = ordina_min_max(c1_min, c1_max)
@@ -154,7 +155,6 @@ def elabora_nastro(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min,
     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 = [], []
@@ -191,12 +191,11 @@ def elabora_nastro(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min,
                 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, quad_state_val, mostra_area, mostra_btn_auto
+    return mask_visiva, debug_img, str(area_pixel), log_msg, quad_state_val, mostra_area
 
 # ==========================================
 # 3. MOTORE SEGMENTAZIONE PIANTA (FASE 2)
@@ -214,7 +213,6 @@ def applica_morfologia(mask, tipo, intensita):
 
 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)
 
@@ -222,7 +220,7 @@ def elabora_pianta(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min,
         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) # Usa solo il Minimo
+        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)
@@ -235,7 +233,7 @@ def elabora_pianta(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min,
     return segmented, f"{pixel_count} px"
 
 # ==========================================
-# 4. MOTORE AI FASTSAM (FASE 3 - MANUALE E AUTO)
+# 4. MOTORE AI FASTSAM (FASE 3)
 # ==========================================
 @lru_cache(maxsize=1)
 def carica_fastsam():
@@ -259,59 +257,98 @@ def segmenta_ai_manuale(image, evt: gr.SelectData):
         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."
+def segmenta_ai_automatico(image, quad_vertices, input_area_rif):
+    # FIX: Motore iterativo riprogettato con calcolo ExG e Grafica Avanzata
+    if image is None or quad_vertices is None: 
+        return image, "Errore: Calibra il quadrilatero in Fase 1."
 
     h, w = image.shape[:2]
-    # 1. Crea la maschera del quadrilatero per isolare l'interno
+    
+    # 1. Maschera del quadrilatero per annerire l'esterno
     valid_area = np.zeros((h, w), dtype=np.uint8)
     cv2.fillPoly(valid_area, [quad_vertices], 255)
+    
+    # Immagine di base (Nera fuori dal nastro)
+    base_img = cv2.bitwise_and(image, image, mask=valid_area)
+    final_output = base_img.copy()
 
     segmented_mask_total = np.zeros((h, w), dtype=np.uint8)
+    instances = []
     model = carica_fastsam()
 
-    iterazioni = 0
-    max_iter = 5
-
-    for _ in range(max_iter):
-        # 2. Trova l'area valida ANCORA NON segmentata
+    # 2. Loop Iterativo SAM
+    for _ in range(5):
         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
+        if cv2.contourArea(largest_contour) < 500: break # Ignora rimasugli troppo piccoli
+
+        # Baricentro per il prompt
         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]
+        cx = int(M["m10"] / M["m00"]) if M["m00"] != 0 else largest_contour[0][0][0]
+        cy = int(M["m01"] / M["m00"]) if M["m00"] != 0 else 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)
+            mask = cv2.bitwise_and(mask, valid_area) # Non sbordare mai dal nastro
             
-            # Limita la maschera AI per non sbordare mai fuori dal quadrilatero
-            mask = cv2.bitwise_and(mask, valid_area)
+            # Sicurezza: se SAM trova un pezzo già esplorato per errore, interrompi per evitare loop infiniti
+            new_pixels = cv2.bitwise_and(mask, cv2.bitwise_not(segmented_mask_total))
+            if np.sum(new_pixels == 255) < 100: break 
+            
+            instances.append(mask)
             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 final_output, f"Auto-Completato in {iterazioni} step AI. Totale: {pixel_count} px"
+    if not instances:
+        return final_output, "Nessuna segmentazione AI riuscita."
+
+    # 3. Calcolo Excess Green per trovare la PIANTA VERA tra i segmenti trovati
+    img_float = image.astype(np.float32)
+    exg_img = 2 * img_float[:,:,1] - img_float[:,:,0] - img_float[:,:,2]
+    exg_img = np.clip(exg_img, 0, 255).astype(np.uint8)
+
+    max_exg, plant_idx = -1, -1
+    for i, mask in enumerate(instances):
+        mean_exg = cv2.mean(exg_img, mask=mask)[0]
+        if mean_exg > max_exg:
+            max_exg, plant_idx = mean_exg, i
+
+    # 4. Disegno bordi e grafiche
+    plant_px_area = 0
+    for i, mask in enumerate(instances):
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        # Bordo netto per TUTTE le istanze (Magenta)
+        cv2.drawContours(final_output, contours, -1, (255, 0, 255), 2)
+
+        if i == plant_idx:
+            plant_px_area = int(np.sum(mask == 255))
+            if contours:
+                c = max(contours, key=cv2.contourArea)
+                # Trova il punto più alto del contorno per agganciare la freccia senza coprire la foglia
+                topmost = tuple(c[c[:, :, 1].argmin()][0]) 
+                tail = (max(0, topmost[0] - 60), max(0, topmost[1] - 80)) # Coda esterna in alto a sx
+
+                # Freccia Gialla verso la pianta
+                cv2.arrowedLine(final_output, tail, topmost, (0, 255, 255), 3, tipLength=0.2)
+
+                # Testo Dati
+                text = f"Pianta, Area: {plant_px_area} px"
+                if input_area_rif and input_area_rif > 0:
+                    quad_px_area = np.sum(valid_area == 255)
+                    cm2 = (input_area_rif / quad_px_area) * plant_px_area
+                    text += f" | {cm2:.2f} cm2"
+
+                cv2.putText(final_output, text, (max(0, tail[0]-40), max(0, tail[1]-10)), 
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
+
+    return final_output, f"Elaborazione completata. {len(instances)} aree trovate."
 
 # ==========================================
 # 5. INTERFACCIA UTENTE (UI)
@@ -319,7 +356,6 @@ def segmenta_ai_automatico(image, quad_vertices):
 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():
@@ -343,8 +379,8 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
                 
                 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")
+                        r1_min = gr.Slider(0, 179, 20, label="Tinta (H) Min")
+                        r1_max = gr.Slider(0, 179, 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")
@@ -361,22 +397,21 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
                 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]:
+                # FIX: Rimossa l'ultima variabile (bottone fantasma)
                 s.change(
                     fn=elabora_nastro,
                     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
+                    outputs=[img_mask_out, img_geom_out, pixel_rif_out, log_geom, quad_state, box_area_rif]
                 )
 
         # --- TAB 2: COLORE PIANTA ---
@@ -409,7 +444,6 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
 
             sliders_l = [l1_min, l1_max, l2_min, l2_max, l3_min, l3_max]
             
-            # 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)
@@ -428,21 +462,16 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
                 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])
+            # L'evento Auto-SAM ora riceve anche input_area_rif per il calcolo in cm2
+            btn_auto_sam.click(fn=segmenta_ai_automatico, inputs=[img_ai_in, quad_state, input_area_rif], 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
+            img_rif_in.change(lambda: gr.update(visible=False), None, btn_auto_sam) 
 
-            # Collegamento tra Tab 1 e bottone Tab 3
-            def aggiorna_btn_auto(quad):
-                return gr.update(visible=(quad is not None))
+            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],