Update app.py

app.py

@@ -119,24 +119,20 @@ def cattura_colore(image, evt: gr.SelectData, s_main, s_alt):
     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)
@@ -147,7 +143,6 @@ def disegna_etichetta_pianta(img, mask, quad_vertices, input_area_rif):
 
     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)
 
@@ -158,7 +153,7 @@ def disegna_etichetta_pianta(img, mask, quad_vertices, input_area_rif):
 # ==========================================
 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):
+def elabora_riferimento(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)
 
     spazio = get_spazio_attivo(s_main, s_alt)
@@ -261,7 +256,6 @@ def elabora_pianta(image, s_main, s_alt, c1_min, c1_max, c2_min, c2_max, c3_min,
 
     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)
@@ -296,33 +290,40 @@ def segmenta_ai_manuale(image, evt: gr.SelectData, quad_vertices, input_area_rif
 
 def segmenta_ai_automatico(image, quad_vertices, input_area_rif):
     if image is None or quad_vertices is None: 
-        return image, "Errore: Calibra il quadrilatero in Fase 1."
+        return image, "Errore: Calibra l'area di riferimento in Fase 1."
 
     h, w = image.shape[:2]
     valid_area = np.zeros((h, w), dtype=np.uint8)
     cv2.fillPoly(valid_area, [quad_vertices], 255)
+    quad_area_px = np.sum(valid_area == 255)
     
-    # exclude_mask tiene traccia di tutto ciò che NON deve essere cliccato
-    exclude_mask = cv2.bitwise_not(valid_area)
+    if quad_area_px == 0:
+        return image, "Errore: Area di riferimento nulla."
     
+    exclude_mask = cv2.bitwise_not(valid_area)
     instances = []
     model = carica_fastsam()
 
     for step in range(5):
+        allowed_area = cv2.bitwise_not(exclude_mask)
+        remaining_px = np.sum(allowed_area == 255)
+        
+        # SCUDO 1: Fallback se l'area rimanente è < 10% del totale (Richiesta Utente)
+        if (remaining_px / quad_area_px) < 0.10:
+            break
+
         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
+            # SCUDO 2: Fallback Topografico (spazi troppo stretti)
+            if max_val < 5: 
+                break 
             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:
@@ -331,23 +332,21 @@ def segmenta_ai_automatico(image, quad_vertices, input_area_rif):
             mask = (mask * 255).astype(np.uint8)
             mask = cv2.bitwise_and(mask, valid_area) 
             
-            # Controllo anti-loop infinito
             new_pixels = cv2.bitwise_and(mask, cv2.bitwise_not(exclude_mask))
+            
+            # SCUDO 3: Anti-Loop Infinito. Disegna zona morta se SAM ripete l'output.
             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)
+                cv2.circle(exclude_mask, (cx, cy), max(15, int(max_val if step > 0 else 20)), 255, -1)
                 continue 
             
             instances.append(mask)
-            exclude_mask = cv2.bitwise_or(exclude_mask, mask) # Aggiungi la foglia alle zone da non cliccare
+            exclude_mask = cv2.bitwise_or(exclude_mask, mask) 
         else:
-            # Se SAM fallisce su quel punto, non cliccarlo più
             cv2.circle(exclude_mask, (cx, cy), 20, 255, -1)
 
     if not instances:
         return cv2.bitwise_and(image, image, mask=valid_area), "Nessuna segmentazione AI riuscita."
 
-    # 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)
@@ -358,13 +357,12 @@ def segmenta_ai_automatico(image, quad_vertices, input_area_rif):
         if mean_exg > max_exg:
             max_exg, plant_idx = mean_exg, i
 
-    # 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)."
+    return final_output, f"Esplorazione AI completata in {step+1} steps. Pianta isolata ({final_px} px)."
 
 # ==========================================
 # 5. INTERFACCIA UTENTE (UI)
@@ -386,7 +384,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
     with gr.Tabs():
         # --- TAB 1: GEOMETRIA ---
         with gr.Tab("📐 Fase 1: Calibrazione Riferimento"):
-            gr.Markdown("**Isola il nastro**. L'algoritmo calcolerà il quadrilatero interno per contenere la pianta.")
+            gr.Markdown("**Isola l'area di riferimento**. 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")
@@ -424,7 +422,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
             
             for s in sliders_r + [sp_main_r, sp_altri_r]:
                 s.change(
-                    fn=elabora_nastro,
+                    fn=elabora_riferimento,
                     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]
                 )
@@ -463,7 +461,6 @@ 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, quad_state, input_area_rif], 
@@ -473,7 +470,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green")) as app:
         with gr.Tab("🧠 Fase 3: AI (FastSAM)"):
             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)
+            btn_auto_sam = gr.Button("🤖 Segmenta Automaticamente l'interno dell'Area", variant="primary", visible=False)
             
             with gr.Row():
                 img_ai_in = gr.Image(label="Clicca sull'oggetto", interactive=True, height=350)