Update app.py

app.py

@@ -45,7 +45,6 @@ def load_sam_mask_generator(points_per_side, pred_iou_thresh, stability_score_th
     Carica il modello SAM e crea un SamAutomaticMaskGenerator
     con parametri personalizzabili (passati da Streamlit).
     """
-    # Importa libreria dal repo segment_anything
     from segment_anything import SamAutomaticMaskGenerator, sam_model_registry
 
     # Scarichiamo il checkpoint
@@ -92,7 +91,7 @@ def analyze_mask_geometry(mask_bin):
     """Calcola bounding box e circolarità di una mask (0/255)."""
     contours, _ = cv2.findContours(mask_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     if not contours:
-        return {"bbox": (0,0,0,0), "circolarita": 0.0}
+        return {"bbox": (0, 0, 0, 0), "circolarita": 0.0}
     
     cnt = max(contours, key=cv2.contourArea)
     x, y, w, h = cv2.boundingRect(cnt)
@@ -125,7 +124,7 @@ def classify_mask(image_np, mask_bin, candidate_labels, clip_processor, clip_mod
         return_tensors="pt",
         padding=True
     )
-    # sposta i tensori su GPU
+    # Sposta i tensori su GPU
     inputs = {k: v.to(device) if hasattr(v, "to") else v for k, v in inputs.items()}
 
     # Inference CLIP
@@ -156,7 +155,7 @@ def overlay_masks_auto(image, masks_with_labels):
     import matplotlib.pyplot as plt
 
     image_np = np.array(image)
-    fig, ax = plt.subplots(figsize=(6,6))
+    fig, ax = plt.subplots(figsize=(6, 6))
     ax.imshow(image_np)
 
     color_map = {}
@@ -167,14 +166,14 @@ def overlay_masks_auto(image, masks_with_labels):
         
         # Assegna un colore a ogni label
         if label not in color_map:
-            color_map[label] = np.random.randint(0,255,(3,), dtype=np.uint8)/255.0
+            color_map[label] = np.random.randint(0, 255, (3,), dtype=np.uint8) / 255.0
         
         color = color_map[label]
         contours, _ = cv2.findContours(mask_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
         for cnt in contours:
             cnt = cnt.squeeze()
             if cnt.ndim == 2 and len(cnt) > 1:
-                ax.plot(cnt[:,0], cnt[:,1], color=color, linewidth=2, label=label)
+                ax.plot(cnt[:, 0], cnt[:, 1], color=color, linewidth=2, label=label)
 
     ax.axis("off")
     buf = BytesIO()
@@ -189,7 +188,7 @@ def overlay_masks_auto(image, masks_with_labels):
 ##############################################################
 def union_lamiera_masks(df, h, w, lamiera_label="lamiera"):
     """
-    Esempio: unisce tutte le maschere con etichetta 'lamiera' in una sola 
+    Unisce tutte le maschere con etichetta 'lamiera' in una sola 
     maschera, e sostituisce le righe multiple con una sola riga unificata.
     """
     df_lamiera = df[df["Label"] == lamiera_label]
@@ -197,9 +196,9 @@ def union_lamiera_masks(df, h, w, lamiera_label="lamiera"):
         return df  # niente da unire
     
     lamiera_mask_total = np.zeros((h, w), dtype=np.uint8)
-    for idx, row in df_lamiera.iterrows():
+    for _, row in df_lamiera.iterrows():
         segm = row["segmentation"]  # mask 0..1
-        segm_bin = (segm*255).astype(np.uint8)
+        segm_bin = (segm * 255).astype(np.uint8)
         lamiera_mask_total = cv2.bitwise_or(lamiera_mask_total, segm_bin)
     
     # Creiamo una riga unificata
@@ -212,9 +211,9 @@ def union_lamiera_masks(df, h, w, lamiera_label="lamiera"):
         "Area(px)": int(area_sum),
         "BoundingBox": str(geom_info["bbox"]),
         "Circolarita": round(geom_info["circolarita"], 3),
-        "segmentation": (lamiera_mask_total / 255.0).astype(np.float32) 
+        "segmentation": (lamiera_mask_total / 255.0).astype(np.float32)
     }
-    # Rimuoviamo le righe originali lamiera e aggiungiamo la riga unificata
+
     df_no_lam = df[df["Label"] != lamiera_label]
     df_final = pd.concat([df_no_lam, pd.DataFrame([new_row])], ignore_index=True)
     return df_final
@@ -230,31 +229,56 @@ def main():
     con pass di geometria. Se la GPU è disponibile, verrà usata per velocizzare i calcoli.
     """)
 
-    # Parametri SAM personalizzabili via Streamlit sidebar
+    # Parametri SAM personalizzabili via Streamlit sidebar, con tooltip (help).
     st.sidebar.header("Parametri SAM")
-    points_per_side = st.sidebar.slider("Points per side", 0, 128, 32)
-    pred_iou_thresh = st.sidebar.slider("Pred IoU Threshold", 0.0, 1.0, 0.8)
-    stability_score_thresh = st.sidebar.slider("Stability Score Threshold", 0.0, 1.0, 0.9)
+    points_per_side = st.sidebar.slider(
+        "Points per side", 0, 128, 32,
+        help="Numero di punti su ogni lato della bounding box di input usati come prompt. "
+             "Più punti => segmentazione più dettagliata e più lenta. (Default=32)"
+    )
+    pred_iou_thresh = st.sidebar.slider(
+        "Pred IoU Threshold", 0.0, 1.0, 0.8,
+        help="Soglia minima di confidenza IoU per le maschere. 0.8 è un buon compromesso."
+    )
+    stability_score_thresh = st.sidebar.slider(
+        "Stability Score Threshold", 0.0, 1.0, 0.9,
+        help="Soglia di stabilità della maschera. Valori alti filtrano maschere poco stabili. (Default=0.9)"
+    )
 
     # Filtraggio maschere in base all'area minima
     st.sidebar.header("Filtraggio Maschere")
-    min_area = st.sidebar.number_input("Area minima (px)", min_value=0, value=100)
+    min_area = st.sidebar.number_input(
+        "Area minima (px)", min_value=0, value=100,
+        help="Filtra via maschere con area (in pixel) inferiore a questa soglia."
+    )
 
-    # Carichiamo i modelli
+    # Caricamento e inizializzazione modelli
     mask_generator = load_sam_mask_generator(points_per_side, pred_iou_thresh, stability_score_thresh)
     clip_model, clip_processor = load_clip_model()
 
     # Upload immagini
-    uploaded_files = st.file_uploader("Carica immagini (JPG/PNG)", 
-                                      type=["jpg","jpeg","png"], 
-                                      accept_multiple_files=True)
-    do_geometry = st.checkbox("Calcolo circolarità e bounding box", value=True)
-    do_union_lamiera = st.checkbox("Unisci maschere lamiera in 1 sola maschera", value=True)
+    uploaded_files = st.file_uploader(
+        "Carica immagini (JPG/PNG)", 
+        type=["jpg", "jpeg", "png"], 
+        accept_multiple_files=True
+    )
+    do_geometry = st.checkbox(
+        "Calcolo circolarità e bounding box",
+        value=True,
+        help="Se spuntato, calcola parametri come circolarità e bounding box per ciascuna maschera."
+    )
+    do_union_lamiera = st.checkbox(
+        "Unisci maschere lamiera in 1 sola maschera",
+        value=True,
+        help="Se spuntato, tutte le maschere classificate come 'lamiera' vengono unite in un'unica maschera cumulativa."
+    )
 
     if "segmentations_auto" not in st.session_state:
         st.session_state["segmentations_auto"] = {}
 
-    # Generazione maschere (SAM)
+    ########################
+    #  A) Genera Maschere  #
+    ########################
     if uploaded_files:
         for file in uploaded_files:
             st.image(file, caption=file.name, use_column_width=True)
@@ -271,18 +295,24 @@ def main():
                 # Filtra maschere troppo piccole
                 filtered_masks_info = [m for m in masks_info if m["area"] >= min_area]
 
+                # Salviamo nel session_state
                 st.session_state["segmentations_auto"][file.name] = {
                     "image": image_pil,
                     "masks": filtered_masks_info
                 }
-                percent = int((i+1)/len(uploaded_files)*100)
+                percent = int((i + 1) / len(uploaded_files) * 100)
                 progress_seg.progress(percent)
             st.success("Maschere generate con successo!")
 
-    # Classificazione (CLIP)
+    ########################
+    #  B) Classifica SAM   #
+    ########################
     if st.session_state["segmentations_auto"]:
         st.header("Classificazione con CLIP")
-        st.markdown("Inserisci le etichette (es: 'lamiera, foro circolare, scanalatura rettangolare, albero')")
+        st.markdown("""
+            Inserisci le etichette di classificazione separate da virgola.
+            Esempio: "lamiera, foro circolare, scanalatura rettangolare, albero".
+        """)
         default_prompts = "lamiera, foro circolare, scanalatura rettangolare"
         label_prompts = st.text_input("Prompt Zero-Shot", value=default_prompts)
         candidate_labels = [lp.strip() for lp in label_prompts.split(",") if lp.strip()]
@@ -300,10 +330,11 @@ def main():
 
                 masks_with_labels = []
                 for idx_m, m_dict in enumerate(masks_info):
-                    segm = m_dict["segmentation"]  # 2D mask 0..1
+                    segm = m_dict["segmentation"]  # 2D mask (0..1)
                     area_px = m_dict["area"]
                     mask_bin = (segm * 255).astype(np.uint8)
 
+                    # Classifica con CLIP
                     label_pred, conf, geom_info = classify_mask(
                         image_np,
                         mask_bin,
@@ -312,6 +343,8 @@ def main():
                         clip_model,
                         do_geometry
                     )
+
+                    # Costruiamo la riga da aggiungere al DF
                     row = {
                         "Indice": idx_m,
                         "Label": label_pred,
@@ -326,33 +359,35 @@ def main():
                     results_rows.append(row)
                     masks_with_labels.append({"mask": segm, "label": label_pred})
 
-                # Generiamo l'overlay
+                # Generiamo l'overlay delle maschere
                 overlay_img = overlay_masks_auto(image_pil, masks_with_labels)
                 st.subheader(f"File: {fn}")
                 st.image(overlay_img, caption="Maschere colorate in base alle etichette")
 
-                progress_class.progress(int((idx_i+1)/len(seg_items)*100))
+                progress_class.progress(int((idx_i + 1) / len(seg_items) * 100))
 
             # Convertiamo in DataFrame
             df = pd.DataFrame(results_rows)
-            
-            # Opzionale: unione delle maschere lamiera
+
+            # Unione lamiera (opzionale)
             if do_union_lamiera and not df.empty:
                 df = union_lamiera_masks(df, H, W, lamiera_label="lamiera")
 
+            #################################
+            # Visualizzazione e Download CSV
+            #################################
             st.write("**Tabella Risultati**")
-            st.dataframe(df)
 
-            # Conteggio
-            st.write("**Conteggio**:")
             if not df.empty:
+                # Evitiamo l'errore ArrowInvalid rimuovendo la colonna "segmentation" dalla sola vista
+                df_display = df.drop(columns=["segmentation"]).copy()
+                st.dataframe(df_display)
+
+                st.write("**Conteggio**:")
                 count_labels = df["Label"].value_counts()
                 st.write(count_labels)
-            else:
-                st.write("Nessuna maschera valida trovata.")
 
-            # Scarica CSV con st.download_button
-            if not df.empty:
+                # Download CSV (includiamo anche "segmentation")
                 csv_buf = df.to_csv(index=False).encode("utf-8")
                 st.download_button(
                     label="Scarica CSV",
@@ -360,6 +395,8 @@ def main():
                     file_name="risultati_clip_automatic.csv",
                     mime="text/csv"
                 )
+            else:
+                st.write("Nessuna maschera valida trovata.")
 
 
 if __name__ == "__main__":