app.py

import gradio as gr
import cv2
import numpy as np
import torch
from pathlib import Path
import shutil

print(" Avvio applicazione...")

def load_model():
    try:
        from ultralytics import YOLO
        import torch
        import torch.nn as nn
        print("\n📱 Controllo modello personalizzato...")
        
        # Cerca il modello personalizzato
        model_pth = Path('model.pth')
        
        # Se esiste .pth, prova a caricarlo
        if model_pth.exists():
            try:
                print("🔄 Caricamento modello PyTorch...")
                # Carica il modello PyTorch
                state_dict = torch.load(str(model_pth), map_location='cpu')
                
                print("📦 Contenuto del modello:")
                if isinstance(state_dict, dict):
                    print("Trovato ResNet model. È necessario esportare il modello in formato YOLO.")
                    print("Per convertire il modello ResNet in formato YOLO:")
                    print("1. Usa il comando 'yolo export model=model.pth format=onnx'")
                    print("2. Poi 'yolo export model=model.onnx format=pt'")
                    print("3. Infine, rinomina il file esportato in 'model.pt'")
                
                print("⚠️ Per ora uso YOLOv8n come fallback...")
                
            except Exception as e:
                print(f"⚠️ Errore caricamento modello: {e}")
                print("💡 Dettagli errore per debug:")
                import traceback
                print(traceback.format_exc())
        
        # Usa YOLOv8n
        print("🔄 Carico modello YOLOv8n...")
        model = YOLO('yolov8n.pt', task='detect')
        print("✅ Modello YOLOv8n caricato!")
        return model
        
    except Exception as e:
        print(f"❌ ERRORE CRITICO: {e}")
        return None

print("\n Inizializzazione modello...")
model = load_model()
print(" Inizializzazione completata!")

def process_webcam(img):
    """Processa il frame della webcam per il rilevamento oggetti."""
    try:
        if img is None:
            print(" Frame vuoto ricevuto")
            return None, "Camera non attiva", 0
        
        print("\n Nuovo frame ricevuto")
        print(f" Dimensioni frame: {img.shape}")
        print(f" Tipo frame: {type(img)}")
        print(f" Range valori: {img.min()}-{img.max()}")
        
        # Verifica formato immagine
        if not isinstance(img, np.ndarray):
            print(" Frame non è un array numpy")
            return img, "Errore formato", 0
            
        if len(img.shape) != 3 or img.shape[2] != 3:
            print(f" Formato frame non valido: {img.shape}")
            return img, "Formato non valido", 0
            
        # Converti colori
        print(" Conversione colori BGR->RGB...")
        frame_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        print(" Conversione colori completata")
        
        # Verifica modello
        if model is None:
            print(" Modello non caricato")
            return img, "Modello non disponibile", 0
            
        # Rilevamento
        print(" Inizio rilevamento...")
        results = model(frame_rgb, conf=0.25)
        print(" Rilevamento completato")
        
        # Analisi risultati
        output_image = frame_rgb.copy()
        detected_objects = []
        
        print("\n Analisi risultati...")
        for r in results:
            boxes = r.boxes
            print(f" Trovati {len(boxes)} oggetti")
            
            for box in boxes:
                # Estrai dati
                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
                conf = float(box.conf[0])
                cls = int(box.cls[0])
                name = model.names[cls]
                
                print(f"- {name}: {conf:.2f} at [{int(x1)},{int(y1)},{int(x2)},{int(y2)}]")
                detected_objects.append(f"{name} ({conf:.2f})")
                
                # Colore basato su confidenza
                color = (
                    int(255 * (1 - conf)),  # R
                    int(255 * conf),        # G
                    0                       # B
                )
                
                # Disegna box
                cv2.rectangle(output_image, 
                            (int(x1), int(y1)), 
                            (int(x2), int(y2)), 
                            color, 2)
                
                # Aggiungi label
                label = f"{name} {conf:.2f}"
                (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
                
                cv2.rectangle(output_image, 
                            (int(x1), int(y1-h-10)), 
                            (int(x1+w), int(y1)), 
                            color, -1)
                
                cv2.putText(output_image, label, 
                          (int(x1), int(y1-5)),
                          cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
        
        # Prepara output
        if detected_objects:
            text = " Rilevati:\n" + "\n".join(detected_objects)
            count = len(detected_objects)
            print(f" Completato: {count} oggetti")
        else:
            text = " Nessun oggetto"
            count = 0
            print(" Nessun oggetto rilevato")
            
        return output_image, text, count
        
    except Exception as e:
        print(f"\n ERRORE: {e}")
        import traceback
        print(traceback.format_exc())
        return img, f"Errore: {str(e)}", 0

print("\n Creazione interfaccia...")

# Interfaccia semplificata
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🔍 Object Detection")
    
    with gr.Column():
        # Camera con rilevamento automatico
        webcam = gr.Image(
            sources=["webcam"],
            streaming=True,
            type="numpy",
            label="📸 Camera Live + Rilevamento",
            height=480,
            width=640
        )
        
        # Info rilevamento
        with gr.Row():
            info = gr.Textbox(label="📝 Dettagli")
            count = gr.Number(label="🔢 Oggetti", value=0)
            
        gr.Markdown("""
        ### 📱 Istruzioni:
        1. Clicca su "Start" per avviare la camera
        2. Usa 🔄 per cambiare camera
        """)
    
    # Aggiorna ad ogni frame
    webcam.stream(
        fn=process_webcam,
        inputs=webcam,
        outputs=[webcam, info, count],
        show_progress=False
    )

print("🌟 Avvio server...")
demo.queue()
demo.launch(share=False, server_name="0.0.0.0", show_error=True)