Upload app.py

app.py

@@ -9,11 +9,10 @@ import numpy as np
 REALTIME_MODELS = {
     "YOLOS Tiny (ultra-rapide)": "hustvl/yolos-tiny",
     "DETR ResNet-50": "facebook/detr-resnet-50",
-    "YOLOS Small": "hustvl/yolos-small",
-    "Conditional DETR": "microsoft/conditional-detr-resnet-50"
+    "YOLOS Small": "hustvl/yolos-small"
 }
 
-# Variables globales pour le cache
+# Variables globales
 current_detector = None
 current_model_name = None
 
@@ -36,26 +35,29 @@ def load_detector(model_name):
     return current_detector
 
 @spaces.GPU
-def detect_objects_live(image, model_choice, confidence_threshold):
-    """
-    Fonction principale de détection pour le streaming live
-    """
+def process_webcam(image, model_choice, confidence_threshold):
+    """Traite l'image de la webcam"""
+    print(f"🎥 Frame reçue - Type: {type(image)}")
+    
     if image is None:
+        print("❌ Image None reçue")
         return None
     
     try:
-        # Charger le détecteur
-        detector = load_detector(model_choice)
-        
-        # Convertir en PIL Image si c'est un array numpy
+        # S'assurer qu'on a une image PIL
         if isinstance(image, np.ndarray):
             pil_image = Image.fromarray(image)
         else:
             pil_image = image
+            
+        print(f"📏 Taille image: {pil_image.size}")
         
-        # Redimensionner pour optimiser la vitesse
+        # Charger le détecteur
+        detector = load_detector(model_choice)
+        
+        # Redimensionner pour la vitesse
+        max_size = 640
         original_size = pil_image.size
-        max_size = 480  # Taille réduite pour plus de vitesse
         
         if max(original_size) > max_size:
             ratio = max_size / max(original_size)
@@ -65,8 +67,11 @@ def detect_objects_live(image, model_choice, confidence_threshold):
             resized_image = pil_image
             ratio = 1.0
         
-        # Effectuer la détection
+        print(f"🔍 Lancement détection avec seuil: {confidence_threshold}")
+        
+        # Détection
         detections = detector(resized_image)
+        print(f"🎯 Détections brutes: {len(detections)}")
         
         # Filtrer par confiance
         filtered_detections = [
@@ -74,9 +79,11 @@ def detect_objects_live(image, model_choice, confidence_threshold):
             if det['score'] >= confidence_threshold
         ]
         
-        print(f"🎯 Détections trouvées: {len(filtered_detections)}")
+        print(f"✅ Détections filtrées: {len(filtered_detections)}")
+        for det in filtered_detections:
+            print(f"   - {det['label']}: {det['score']:.3f}")
         
-        # Ajuster les coordonnées à la taille originale
+        # Ajuster les coordonnées
         for det in filtered_detections:
             if ratio != 1.0:
                 det['box']['xmin'] = int(det['box']['xmin'] / ratio)
@@ -85,29 +92,28 @@ def detect_objects_live(image, model_choice, confidence_threshold):
                 det['box']['ymax'] = int(det['box']['ymax'] / ratio)
         
         # Dessiner les détections
-        annotated_image = draw_detections(pil_image, filtered_detections)
+        result_image = draw_detections(pil_image, filtered_detections)
         
-        return annotated_image
+        print(f"🎨 Image annotée créée")
+        return result_image
         
     except Exception as e:
-        print(f"❌ Erreur: {e}")
+        print(f"❌ Erreur dans process_webcam: {e}")
+        import traceback
+        traceback.print_exc()
         return image
 
 def draw_detections(image, detections):
-    """Dessine les boîtes de détection sur l'image"""
-    if not detections:
-        return image
-    
-    # Créer une copie pour dessiner
+    """Dessine les détections avec des couleurs vives"""
     img_copy = image.copy()
     draw = ImageDraw.Draw(img_copy)
     
-    # Couleurs vives pour les détections
-    colors = ["#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF"]
+    # Couleurs très visibles
+    colors = ["#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF"]
     
+    # Police par défaut
     try:
-        # Essayer de charger une police
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 20)
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 24)
     except:
         font = ImageFont.load_default()
     
@@ -116,76 +122,40 @@ def draw_detections(image, detections):
         label = detection['label']
         score = detection['score']
         
-        # Coordonnées de la boîte
         x1, y1 = box['xmin'], box['ymin']
         x2, y2 = box['xmax'], box['ymax']
         
-        # Couleur pour cette détection
         color = colors[i % len(colors)]
         
-        # Dessiner la boîte (plus épaisse pour être visible)
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
-        
-        # Texte du label
-        text = f"{label} ({score:.2f})"
+        # Boîte très visible
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=5)
         
-        # Fond du texte pour la lisibilité
-        bbox = draw.textbbox((x1, y1-30), text, font=font)
-        draw.rectangle([bbox[0]-2, bbox[1]-2, bbox[2]+2, bbox[3]+2], fill=color)
-        
-        # Texte en blanc
-        draw.text((x1, y1-30), text, fill="white", font=font)
+        # Texte avec fond
+        text = f"{label} {score:.2f}"
+        bbox = draw.textbbox((x1, y1-35), text, font=font)
+        draw.rectangle([bbox[0]-5, bbox[1]-5, bbox[2]+5, bbox[3]+5], fill=color)
+        draw.text((x1, y1-35), text, fill="white", font=font)
     
     return img_copy
 
-# Interface Gradio simplifiée
-with gr.Blocks(title="🎥 Détection Live", theme=gr.themes.Soft()) as demo:
-    
-    gr.Markdown("""
-    # 🎥 Détection d'Objets en Temps Réel
-    
-    **Autorisez l'accès à votre webcam** et la détection se fera automatiquement !
-    """)
-    
-    with gr.Row():
-        with gr.Column():
-            # Contrôles
-            model_dropdown = gr.Dropdown(
-                choices=list(REALTIME_MODELS.keys()),
-                value="YOLOS Tiny (ultra-rapide)",
-                label="🤖 Modèle de détection"
-            )
-            
-            confidence_slider = gr.Slider(
-                minimum=0.1,
-                maximum=1.0,
-                value=0.5,
-                step=0.1,
-                label="🎯 Seuil de confiance minimum"
-            )
-        
-        with gr.Column():
-            gr.Markdown("""
-            ### 📊 Info
-            - **Streaming automatique** activé
-            - **Détection en continu** sur chaque frame
-            - **Ajustements en temps réel**
-            """)
-    
-    # Interface de streaming principal
-    webcam_interface = gr.Interface(
-        fn=detect_objects_live,
-        inputs=[
-            gr.Image(sources=["webcam"], streaming=True, label="📹 Webcam Live"),
-            model_dropdown,
-            confidence_slider
-        ],
-        outputs=gr.Image(streaming=True, label="🎯 Détection en Temps Réel"),
-        live=True,
-        allow_flagging="never",
-        title=None,
-        description="La détection se fait automatiquement sur chaque frame de la webcam"
-    )
+# Interface simplifiée au maximum
+demo = gr.Interface(
+    fn=process_webcam,
+    inputs=[
+        gr.Image(sources=["webcam"], streaming=True, type="pil"),
+        gr.Dropdown(
+            choices=list(REALTIME_MODELS.keys()),
+            value="YOLOS Tiny (ultra-rapide)",
+            label="Modèle"
+        ),
+        gr.Slider(0.1, 1.0, 0.3, step=0.1, label="Confiance")
+    ],
+    outputs=gr.Image(streaming=True, type="pil"),
+    live=True,
+    title="🎥 Détection Live",
+    description="Autorisez la webcam pour voir la détection d'objets en temps réel",
+    allow_flagging="never"
+)
 
 if __name__ == "__main__":
     demo.launch()