Update app.py

app.py

@@ -75,7 +75,6 @@ def get_spazio_attivo(main_space, alt_space):
 def aggiorna_sliders(spazio_principale, spazio_altri):
     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, 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),
@@ -116,17 +115,50 @@ def cattura_colore(image, evt: gr.SelectData, s_main, s_alt):
     pixel_conv = converti_spazio_colore(pixel_img, spazio)[0][0]
     v1, v2, v3 = [int(v) for v in pixel_conv]
     
-    # 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))
 
+def disegna_etichetta_pianta(img, mask, quad_vertices, input_area_rif):
+    """Funzione universale per disegnare contorni, freccia ed etichetta testuale."""
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours: return img
+
+    # Bordo Magenta
+    cv2.drawContours(img, contours, -1, (255, 0, 255), 2)
+
+    c = max(contours, key=cv2.contourArea)
+    topmost = tuple(c[c[:, :, 1].argmin()][0])
+    
+    # Calcola coordinate coda della freccia (in alto a sinistra rispetto al top)
+    tail = (max(20, topmost[0] - 120), max(40, topmost[1] - 80))
+    cv2.arrowedLine(img, tail, topmost, (0, 255, 255), 3, tipLength=0.2)
+
+    px_area = int(np.sum(mask == 255))
+    text = f"Pianta: {px_area} px"
+
+    # Se abbiamo il quadrilatero e l'area di riferimento, calcola in cm2
+    if quad_vertices is not None and input_area_rif and input_area_rif > 0:
+        valid_area = np.zeros(img.shape[:2], dtype=np.uint8)
+        cv2.fillPoly(valid_area, [quad_vertices], 255)
+        quad_px_area = np.sum(valid_area == 255)
+        if quad_px_area > 0:
+            cm2 = (input_area_rif / quad_px_area) * px_area
+            text += f" | {cm2:.2f} cm2"
+
+    text_pos = (max(10, tail[0] - 50), max(20, tail[1] - 15))
+    
+    # Testo con Outline nero per massima leggibilità
+    cv2.putText(img, text, text_pos, cv2.FONT_HERSHEY_SIMPLEX, 1.1, (0, 0, 0), 6)
+    cv2.putText(img, text, text_pos, cv2.FONT_HERSHEY_SIMPLEX, 1.1, (0, 255, 255), 3)
+
+    return img
+
 # ==========================================
 # 2. MOTORE GEOMETRICO (FASE 1)
 # ==========================================
 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):
-    # 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)
@@ -211,7 +243,7 @@ def applica_morfologia(mask, tipo, intensita):
         return cv2.morphologyEx(m, cv2.MORPH_CLOSE, kernel)
     return mask
 
-def elabora_pianta(image, s_main, s_alt, 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, quad_state, input_area_rif):
     if image is None: return None, "0"
     spazio = get_spazio_attivo(s_main, s_alt)
     min1, max1 = ordina_min_max(c1_min, c1_max)
@@ -228,7 +260,12 @@ def elabora_pianta(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min,
         mask = cv2.inRange(img_conv, np.array([min1, min2, min3]), np.array([max1, max2, max3]))
 
     mask_pulita = applica_morfologia(mask, morfo_tipo, morfo_int)
+    
+    # Se abbiamo isolato correttamente un oggetto e abbiamo dati, mettiamo l'etichetta grossa
     segmented = cv2.bitwise_and(image, image, mask=mask_pulita)
+    if np.sum(mask_pulita == 255) > 500:
+        segmented = disegna_etichetta_pianta(segmented, mask_pulita, quad_state, input_area_rif)
+
     pixel_count = int(np.sum(mask_pulita == 255))
     return segmented, f"{pixel_count} px"
 
@@ -240,7 +277,7 @@ def carica_fastsam():
     from ultralytics import FastSAM
     return FastSAM("FastSAM-s.pt")
 
-def segmenta_ai_manuale(image, evt: gr.SelectData):
+def segmenta_ai_manuale(image, evt: gr.SelectData, quad_vertices, input_area_rif):
     if image is None: return None, "Nessuna immagine"
     x, y = evt.index
     model = carica_fastsam()
@@ -252,64 +289,65 @@ def segmenta_ai_manuale(image, evt: gr.SelectData):
         mask = (mask * 255).astype(np.uint8)
         
         segmented = cv2.bitwise_and(image, image, mask=mask)
-        cv2.drawMarker(segmented, (x, y), (255, 0, 0), cv2.MARKER_CROSS, 20, 3)
+        segmented = disegna_etichetta_pianta(segmented, mask, quad_vertices, input_area_rif)
         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, 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. 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)
+    # exclude_mask tiene traccia di tutto ciò che NON deve essere cliccato
+    exclude_mask = cv2.bitwise_not(valid_area)
+    
     instances = []
     model = carica_fastsam()
 
-    # 2. Loop Iterativo SAM
-    for _ in range(5):
-        remaining = cv2.bitwise_and(valid_area, cv2.bitwise_not(segmented_mask_total))
-        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) < 500: break # Ignora rimasugli troppo piccoli
-
-        # Baricentro per il prompt
-        M = cv2.moments(largest_contour)
-        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]
+    for step in range(5):
+        if step == 0:
+            # Step 1: Click esatto nel baricentro del nastro
+            M = cv2.moments(valid_area)
+            cx, cy = int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])
+        else:
+            # Step 2-5: Distance Transform per trovare il "Polo dell'inaccessibilità"
+            allowed_area = cv2.bitwise_not(exclude_mask)
+            dist = cv2.distanceTransform(allowed_area, cv2.DIST_L2, 5)
+            _, max_val, _, max_loc = cv2.minMaxLoc(dist)
+            
+            if max_val < 5: break # Se il punto più lontano è a meno di 5 pixel dal bordo, abbiamo esplorato tutto
+            cx, cy = max_loc
 
+        # Inferenza
         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
+            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 
+            # Controllo anti-loop infinito
+            new_pixels = cv2.bitwise_and(mask, cv2.bitwise_not(exclude_mask))
+            if np.sum(new_pixels == 255) < 100: 
+                # Se la maschera non porta nulla di nuovo, marca il punto esplorato e riprova
+                cv2.circle(exclude_mask, (cx, cy), 20, 255, -1)
+                continue 
             
             instances.append(mask)
-            segmented_mask_total = cv2.bitwise_or(segmented_mask_total, mask)
-        else: break
+            exclude_mask = cv2.bitwise_or(exclude_mask, mask) # Aggiungi la foglia alle zone da non cliccare
+        else:
+            # Se SAM fallisce su quel punto, non cliccarlo più
+            cv2.circle(exclude_mask, (cx, cy), 20, 255, -1)
 
     if not instances:
-        return final_output, "Nessuna segmentazione AI riuscita."
+        return cv2.bitwise_and(image, image, mask=valid_area), "Nessuna segmentazione AI riuscita."
 
-    # 3. Calcolo Excess Green per trovare la PIANTA VERA tra i segmenti trovati
+    # Seleziona la vera pianta usando l'ExG medio
     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)
@@ -320,35 +358,13 @@ def segmenta_ai_automatico(image, quad_vertices, input_area_rif):
         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."
+    # Produci l'output ESCLUSIVO per la pianta vincitrice
+    best_mask = instances[plant_idx]
+    final_output = cv2.bitwise_and(image, image, mask=best_mask)
+    final_output = disegna_etichetta_pianta(final_output, best_mask, quad_vertices, input_area_rif)
+    
+    final_px = int(np.sum(best_mask == 255))
+    return final_output, f"Esplorazione AI completata. Pianta isolata ({final_px} px)."
 
 # ==========================================
 # 5. INTERFACCIA UTENTE (UI)
@@ -407,7 +423,6 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
             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,
@@ -440,7 +455,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
             with gr.Row():
                 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)")
+            pixel_lat_out = gr.Textbox(label="Dati Segmentazione")
 
             sliders_l = [l1_min, l1_max, l2_min, l2_max, l3_min, l3_max]
             
@@ -448,8 +463,11 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
                 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)
             
+            # Aggiunti quad_state e input_area_rif per generare l'etichetta in cm2
             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])
+                s.change(fn=elabora_pianta, 
+                         inputs=[img_lat_in, sp_main_l, sp_altri_l] + sliders_l + [morfo_tipo, morfo_int, quad_state, input_area_rif], 
+                         outputs=[img_lat_out, pixel_lat_out])
 
         # --- TAB 3: AI FASTSAM ---
         with gr.Tab("🧠 Fase 3: AI (FastSAM)"):
@@ -460,11 +478,10 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
             with gr.Row():
                 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)")
+            pixel_ai_out = gr.Textbox(label="Dati Segmentazione AI")
 
-            img_ai_in.select(fn=segmenta_ai_manuale, inputs=[img_ai_in], outputs=[img_ai_out, pixel_ai_out])
+            img_ai_in.select(fn=segmenta_ai_manuale, inputs=[img_ai_in, quad_state, input_area_rif], 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])
             
             img_rif_in.change(lambda: gr.update(visible=False), None, btn_auto_sam)