Upload 2 files

app and weights

app.py

@@ -0,0 +1,207 @@
+
+#"/home/mclm/phd/best.pt"
+
+import os
+import cv2
+import numpy as np
+import gradio as gr
+
+from sahi import AutoDetectionModel
+from sahi.predict import get_sliced_prediction
+
+# Soglia massima consentita per il lato della bbox (in pixel)
+MAX_SIDE_PX = 70
+
+
+def _draw_boxes_rgb(image_rgb: np.ndarray, result, target_class: str):
+    """
+    Disegna solo le bbox sul frame RGB (niente etichette testuali).
+    - Evidenzia in rosso la classe target
+    - Le altre classi in verde
+    - Scarta le bbox con lato (max tra width e height) > MAX_SIDE_PX
+    Restituisce (immagine_annotata_RGB, counts_text)
+    """
+    # Garantisci 3 canali
+    if image_rgb.ndim == 2:
+        image_rgb = cv2.cvtColor(image_rgb, cv2.COLOR_GRAY2RGB)
+    elif image_rgb.shape[2] == 4:
+        image_rgb = cv2.cvtColor(image_rgb, cv2.COLOR_RGBA2RGB)
+
+    H, W = image_rgb.shape[:2]
+
+    # OpenCV disegna in BGR
+    vis_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+    target_count = 0
+    total_count = 0
+
+    object_predictions = getattr(result, "object_prediction_list", []) or []
+
+    for item in object_predictions:
+        # bbox
+        try:
+            x1, y1, x2, y2 = map(int, item.bbox.to_xyxy())
+        except Exception:
+            x1, y1 = int(getattr(item.bbox, "minx", 0)), int(getattr(item.bbox, "miny", 0))
+            x2, y2 = int(getattr(item.bbox, "maxx", 0)), int(getattr(item.bbox, "maxy", 0))
+
+        # Clamp ai bordi immagine
+        x1 = max(0, min(x1, W - 1))
+        y1 = max(0, min(y1, H - 1))
+        x2 = max(0, min(x2, W - 1))
+        y2 = max(0, min(y2, H - 1))
+
+        # Normalizza coordinate in caso invertite
+        if x2 < x1:
+            x1, x2 = x2, x1
+        if y2 < y1:
+            y1, y2 = y2, y1
+
+        # Scarta bbox non valide
+        w = max(0, x2 - x1)
+        h = max(0, y2 - y1)
+        if w == 0 or h == 0:
+            continue
+
+        # Scarta le bbox con lato maggiore della soglia
+        if max(w, h) > MAX_SIDE_PX:
+            continue
+
+        # Scarta bbox con area non positiva (per sicurezza)
+        area = getattr(item.bbox, "area", w * h)
+        try:
+            area_val = float(area() if callable(area) else area)
+        except Exception:
+            area_val = float(w * h)
+        if area_val <= 0:
+            continue
+
+        cls = getattr(item.category, "name", "unknown")
+        is_target = (cls == target_class)
+
+        color_bgr = (0, 0, 255) if is_target else (0, 200, 0)  # rosso per target, verde per altre
+        cv2.rectangle(vis_bgr, (x1, y1), (x2, y2), color_bgr, 2)
+        # Niente label testuali
+
+        total_count += 1
+        if is_target:
+            target_count += 1
+
+    vis_rgb = cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB)
+    counts_text = f"target='{target_class}': {target_count} | totale: {total_count}"
+    return vis_rgb, counts_text
+
+
+def infer_single_image(
+    image: np.ndarray,
+    weights_path: str,
+    conf: float = 0.35,
+    slice_h: int = 640,
+    slice_w: int = 640,
+    overlap_h: float = 0.10,
+    overlap_w: float = 0.10,
+    device: str = "cuda:0",
+    target_class: str = "berry",
+):
+    """
+    Inferenzia una singola immagine usando SAHI come slicing/merging,
+    con pesi YOLOv11 di instance segmentation ma trattati come detection:
+    - SAHI usa AutoDetectionModel 'yolov8' (wrapper Ultralytics detection)
+    - Le mask sono ignorate, si usano i bounding box (come da .boxes)
+    - Si disegnano solo le bbox (senza label) e si riporta il conteggio per la classe target
+
+    Ritorna: (immagine_annotata_RGB, testo_contatori)
+    """
+    if image is None:
+        raise gr.Error("Devi caricare un'immagine.")
+
+    if not weights_path or not os.path.exists(weights_path):
+        raise gr.Error(f"File pesi non trovato: {weights_path}")
+
+    image_rgb = image.copy()
+
+    # SAHI accetta solo detection; usiamo il wrapper Ultralytics
+    model_type = "yolov8"
+
+    try:
+        detection_model = AutoDetectionModel.from_pretrained(
+            model_type=model_type,
+            model_path=weights_path,
+            confidence_threshold=conf,
+            device=device,
+        )
+    except Exception:
+        detection_model = AutoDetectionModel.from_pretrained(
+            model_type=model_type,
+            model_path=weights_path,
+            confidence_threshold=conf,
+            device="cpu",
+        )
+
+    result = get_sliced_prediction(
+        image_rgb,
+        detection_model,
+        slice_height=int(slice_h),
+        slice_width=int(slice_w),
+        overlap_height_ratio=float(overlap_h),
+        overlap_width_ratio=float(overlap_w),
+        postprocess_class_agnostic=False,
+        verbose=0,
+    )
+
+    vis_rgb, counts_text = _draw_boxes_rgb(image_rgb, result, target_class)
+    return vis_rgb, counts_text
+
+
+def build_app():
+    with gr.Blocks(title="YOLOv11 SEG as Detection + SAHI - Owl-Nest") as demo:
+        gr.Markdown(
+            "## YOLOv11 Instance Segmentation usata come Detection con SAHI\n"
+            "- Carica un'immagine e lancia l'inferenza con pesi .pt Ultralytics (YOLOv11 segment).\n"
+            "- SAHI effettua slicing/merging ma tratta il modello come detection: vengono usati i bounding box (le mask sono ignorate).\n"
+            "- Plot: solo box, senza etichette; scarta box con lato > 70 px."
+        )
+
+        with gr.Row():
+            with gr.Column():
+                img_in = gr.Image(label="Immagine", type="numpy")
+                weights = gr.Textbox(
+                    label="Percorso pesi (.pt)",
+                    value="/home/mclm/phd/best.pt",
+                    placeholder="es. src/scripts/best.pt",
+                )
+                target = gr.Textbox(label="Classe target", value="berry")
+
+                with gr.Row():
+                    conf = gr.Slider(0.0, 1.0, value=0.35, step=0.01, label="Confidence")
+                    device = gr.Dropdown(
+                        ["cuda:0", "cpu"],
+                        value="cuda:0",
+                        label="Device",
+                    )
+
+                with gr.Row():
+                    slice_h = gr.Slider(64, 2048, value=640, step=32, label="Slice H")
+                    slice_w = gr.Slider(64, 2048, value=640, step=32, label="Slice W")
+
+                with gr.Row():
+                    overlap_h = gr.Slider(0.0, 0.9, value=0.10, step=0.01, label="Overlap H ratio")
+                    overlap_w = gr.Slider(0.0, 0.9, value=0.10, step=0.01, label="Overlap W ratio")
+
+                run_btn = gr.Button("Esegui inferenza", variant="primary")
+
+            with gr.Column():
+                img_out = gr.Image(label="Risultato", type="numpy")
+                counts_out = gr.Textbox(label="Conteggi", interactive=False)
+
+        run_btn.click(
+            infer_single_image,
+            inputs=[img_in, weights, conf, slice_h, slice_w, overlap_h, overlap_w, device, target],
+            outputs=[img_out, counts_out],
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    app = build_app()
+    app.launch(server_name="0.0.0.0", server_port=7860, inbrowser=False, show_api=False)

best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd1ebf826a25ef9bdf4ae299fc7a0f398f2688c9e00fc045a4cd50d2e5db480f
+size 5487827