Rename pages/OR1_Riconoscimento.py to pages/OR1_visual_classification.py

pages/OR1_Riconoscimento.py

@@ -1,80 +0,0 @@
-import streamlit as st, torch, cv2, numpy as np
-from PIL import Image
-from huggingface_hub import hf_hub_download
-from groundingdino.util.inference import load_model, predict
-from segment_anything import sam_model_registry, SamPredictor
-
-# ---------- MODELLI -----------------------------------------------------------
-@st.cache_resource(show_spinner=False)
-def load_grounding():
-    cfg  = "GroundingDINO_SwinT_OGC.py"
-    ckpt = hf_hub_download("IDEA-Research/grounding-dino-swint-ogc",
-                           filename="groundingdino_swint_ogc.pth")
-    return load_model(cfg, ckpt)
-
-@st.cache_resource(show_spinner=False)
-def load_sam():
-    ckpt = hf_hub_download("facebook/sam-vit-base",
-                           filename="sam_vit_b_01ec64.pth")
-    sam = sam_model_registry["vit_b"](checkpoint=ckpt)
-    return SamPredictor(sam).to("cuda" if torch.cuda.is_available() else "cpu")
-
-dino = load_grounding()
-sam  = load_sam()
-
-# ---------- UI ---------------------------------------------------------------
-st.header("OR1 – Riconoscimento zero‑shot (GroundingDINO + SAM)")
-
-img_file = st.file_uploader("Carica immagine", type=["jpg","jpeg","png","webp"])
-prompt   = st.text_input("Classi da cercare (separate da virgola)",
-                         "lamiera, foro circolare, foro rettangolare, vite, bullone")
-box_th   = st.slider("Soglia box (DINO)", 0.0,1.0,0.35,0.01)
-text_th  = st.slider("Soglia testo (DINO)",0.0,1.0,0.25,0.01)
-
-if img_file:
-    img = Image.open(img_file).convert("RGB")
-    im_np = np.array(img)
-    H,W   = im_np.shape[:2]
-
-    # 1. GroundingDINO
-    boxes, labels = predict(
-        model         = dino,
-        image         = im_np,
-        caption       = prompt,
-        box_threshold = box_th,
-        text_threshold= text_th
-    )
-
-    if not len(boxes):
-        st.warning("Nessun oggetto trovato – alza le soglie oppure modifica il prompt.")
-        st.image(img, caption="Input")
-        st.stop()
-
-    # 2. SAM per maschere dettagliate
-    boxes_xyxy = boxes * torch.tensor([W,H,W,H])
-    sam.set_image(im_np)
-
-    vis      = im_np.copy()
-    counter  = {}
-    for box,label in zip(boxes_xyxy, labels):
-        m,_,_ = sam.predict(box=box.cpu().numpy(), multimask_output=False)
-        if m[0].mean() < .005:             # scarta blob minuscoli
-            continue
-        counter[label] = counter.get(label,0)+1
-        # disegna contorni e label (preview)
-        cnt,_ = cv2.findContours(m[0].astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        color = tuple(int(x) for x in np.random.randint(0,255,3))
-        cv2.drawContours(vis, cnt, -1, color, 2)
-        x1,y1,x2,y2 = map(int, box)
-        cv2.putText(vis, label, (x1, max(y1-5,10)), cv2.FONT_HERSHEY_SIMPLEX, .5, color,2)
-
-    # 3. Output
-    st.subheader("📊 Conteggio feature riconosciute")
-    for k,v in counter.items():
-        st.write(f"**{k}** : {v}")
-
-    st.subheader("👁️‍🗨️ Preview")
-    st.image(vis, caption="Mask outline + label")
-    st.caption("Per GPU: Settings → Hardware → T4 small (o superiore)")
-
-

pages/OR1_visual_classification.py

@@ -0,0 +1,109 @@
+import streamlit as st
+import numpy as np
+import cv2
+from PIL import Image
+import pandas as pd
+
+from utils import get_device, download_checkpoint
+from segment_anything import sam_model_registry, SamAutomaticMaskGenerator
+from transformers import CLIPProcessor, CLIPModel
+
+st.set_page_config(page_title="OR1 – Riconoscimento", layout="wide")
+st.title("🧩 OR1 – Riconoscimento visivo e classificazione funzionale")
+
+device = get_device()
+st.sidebar.success(f"Device: **{device}**")
+
+# Parametri SAM
+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 Thresh", 0.0, 1.0, 0.8)
+stability_score_thresh = st.sidebar.slider("Stability Score Thresh", 0.0, 1.0, 0.9)
+
+@st.cache_resource
+def load_sam():
+    url = "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth"
+    fname = "sam_vit_h_4b8939.pth"
+    download_checkpoint(url, fname)
+    sam = sam_model_registry["vit_h"](checkpoint=fname).to(device).eval()
+    return SamAutomaticMaskGenerator(
+        sam,
+        points_per_side=points_per_side,
+        pred_iou_thresh=pred_iou_thresh,
+        stability_score_thresh=stability_score_thresh
+    )
+
+@st.cache_resource
+def load_clip():
+    model_name = "laion/CLIP-ViT-L-14-laion2B-s32B-b82K"
+    clip_model = CLIPModel.from_pretrained(model_name).to(device)
+    clip_processor = CLIPProcessor.from_pretrained(model_name)
+    return clip_model, clip_processor
+
+mask_generator, clip_model, clip_processor = load_sam(), *load_clip()
+
+# Caricamento immagini
+st.markdown("**1️⃣ Carica immagini** (JPG/PNG)")
+uploaded = st.file_uploader("", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+
+# Etichette
+st.markdown("**2️⃣ Inserisci etichette (es. lamiera, foro…)**")
+default_labels = "lamiera, foro circolare, scanalatura rettangolare"
+labels = [l.strip() for l in st.text_input("", default_labels).split(",") if l.strip()]
+
+# Analisi
+if uploaded and st.button("🔎 Analizza immagini"):
+    all_results = []
+    for file in uploaded:
+        img_pil = Image.open(file).convert("RGB")
+        img_np = np.array(img_pil)
+        st.subheader(f"📎 {file.name}")
+        st.image(img_pil, caption="Immagine originale", use_column_width=True)
+
+        with st.spinner("Segmentazione in corso…"):
+            masks = mask_generator.generate(img_np)
+        st.write(f"→ Segmenti trovati: {len(masks)}")
+
+        masks_info = []
+        for idx, m in enumerate(masks):
+            segm = m["segmentation"]
+            mask_bin = (segm * 255).astype(np.uint8)
+
+            inputs = clip_processor(text=labels, images=Image.fromarray(img_np), return_tensors="pt", padding=True)
+            inputs = {k: v.to(device) for k, v in inputs.items()}
+            out = clip_model(**inputs)
+            probs = out.logits_per_image.softmax(dim=1)
+            best_i = int(probs.argmax())
+            label = labels[best_i]
+            conf = float(probs[0, best_i])
+
+            masks_info.append({
+                "Indice": idx,
+                "Label": label,
+                "Confidence": round(conf, 3),
+                "Area(px)": int(m["area"])
+            })
+
+        df = pd.DataFrame(masks_info)
+        st.dataframe(df, use_container_width=True)
+
+        annotated = img_np.copy()
+        for info in masks_info:
+            segm_bin = (masks[info["Indice"]]["segmentation"] > 0.5).astype(np.uint8) * 255
+            contours, _ = cv2.findContours(segm_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            color = tuple(np.random.randint(0, 255, 3).tolist())
+            for cnt in contours:
+                cv2.drawContours(annotated, [cnt], -1, color, 2)
+                x, y, w, h = cv2.boundingRect(cnt)
+                cv2.putText(annotated, info["Label"], (x, y - 5),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+        st.image(annotated, caption="Overlay con etichette", use_column_width=True)
+
+        for r in masks_info:
+            r["File"] = file.name
+        all_results += masks_info
+
+    if all_results:
+        df_all = pd.DataFrame(all_results)
+        csv = df_all.to_csv(index=False).encode("utf-8")
+        st.download_button("📥 Scarica risultati (CSV)", csv, "or1_results.csv", "text/csv")