Upload app.py

app.py

@@ -13,10 +13,11 @@ REALTIME_MODELS = {
     "Conditional DETR": "microsoft/conditional-detr-resnet-50"
 }
 
-# Cache global pour le modèle
+# Variables globales pour le cache
 current_detector = None
 current_model_name = None
 
+@spaces.GPU
 def load_detector(model_name):
     """Charge le détecteur avec cache"""
     global current_detector, current_model_name
@@ -35,28 +36,26 @@ def load_detector(model_name):
     return current_detector
 
 @spaces.GPU
-def process_webcam_frame(frame, model_choice, confidence_threshold):
+def detect_objects_live(image, model_choice, confidence_threshold):
     """
-    Traite chaque frame de la webcam en temps réel
-    Cette fonction est appelée automatiquement pour chaque frame
+    Fonction principale de détection pour le streaming live
     """
-    if frame is None:
-        return frame
+    if image is None:
+        return None
     
     try:
         # Charger le détecteur
         detector = load_detector(model_choice)
         
-        # Convertir numpy array en PIL Image si nécessaire
-        if isinstance(frame, np.ndarray):
-            # Gradio webcam donne du RGB
-            pil_image = Image.fromarray(frame)
+        # Convertir en PIL Image si c'est un array numpy
+        if isinstance(image, np.ndarray):
+            pil_image = Image.fromarray(image)
         else:
-            pil_image = frame
+            pil_image = image
         
-        # Redimensionner pour accélérer le traitement
+        # Redimensionner pour optimiser la vitesse
         original_size = pil_image.size
-        max_size = 640  # Réduire la taille pour plus de vitesse
+        max_size = 480  # Taille réduite pour plus de vitesse
         
         if max(original_size) > max_size:
             ratio = max_size / max(original_size)
@@ -66,7 +65,7 @@ def process_webcam_frame(frame, model_choice, confidence_threshold):
             resized_image = pil_image
             ratio = 1.0
         
-        # Détection sur l'image redimensionnée
+        # Effectuer la détection
         detections = detector(resized_image)
         
         # Filtrer par confiance
@@ -75,7 +74,9 @@ def process_webcam_frame(frame, model_choice, confidence_threshold):
             if det['score'] >= confidence_threshold
         ]
         
-        # Redimensionner les coordonnées vers la taille originale
+        print(f"🎯 Détections trouvées: {len(filtered_detections)}")
+        
+        # Ajuster les coordonnées à la taille originale
         for det in filtered_detections:
             if ratio != 1.0:
                 det['box']['xmin'] = int(det['box']['xmin'] / ratio)
@@ -83,133 +84,107 @@ def process_webcam_frame(frame, model_choice, confidence_threshold):
                 det['box']['xmax'] = int(det['box']['xmax'] / ratio)
                 det['box']['ymax'] = int(det['box']['ymax'] / ratio)
         
-        # Dessiner les détections sur l'image originale
-        annotated_image = draw_detections_fast(pil_image, filtered_detections)
+        # Dessiner les détections
+        annotated_image = draw_detections(pil_image, filtered_detections)
         
-        # Convertir back en numpy pour Gradio
-        return np.array(annotated_image)
+        return annotated_image
         
     except Exception as e:
-        print(f"❌ Erreur de traitement: {e}")
-        return frame
+        print(f"❌ Erreur: {e}")
+        return image
 
-def draw_detections_fast(image, detections):
-    """Version optimisée pour dessiner les détections"""
+def draw_detections(image, detections):
+    """Dessine les boîtes de détection sur l'image"""
     if not detections:
         return image
     
-    draw = ImageDraw.Draw(image)
+    # Créer une copie pour dessiner
+    img_copy = image.copy()
+    draw = ImageDraw.Draw(img_copy)
+    
+    # Couleurs vives pour les détections
+    colors = ["#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF"]
     
-    # Police par défaut pour la vitesse
     try:
-        font = ImageFont.load_default()
+        # Essayer de charger une police
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 20)
     except:
-        font = None
-    
-    colors = ["#FF6B6B", "#4ECDC4", "#45B7D1", "#96CEB4", "#FECA57"]
+        font = ImageFont.load_default()
     
     for i, detection in enumerate(detections):
         box = detection['box']
         label = detection['label']
         score = detection['score']
         
-        # Coordonnées
+        # Coordonnées de la boîte
         x1, y1 = box['xmin'], box['ymin']
         x2, y2 = box['xmax'], box['ymax']
         
-        # Couleur
+        # Couleur pour cette détection
         color = colors[i % len(colors)]
         
-        # Boîte
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=2)
+        # Dessiner la boîte (plus épaisse pour être visible)
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
         
-        # Label avec score
-        text = f"{label} {score:.2f}"
+        # Texte du label
+        text = f"{label} ({score:.2f})"
         
-        # Fond du texte (simplifié)
-        if font:
-            bbox = draw.textbbox((x1, y1-20), text, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1-20), text, fill="white", font=font)
-        else:
-            draw.text((x1, y1-15), text, fill=color)
+        # 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)
     
-    return image
+    return img_copy
 
-# Interface Gradio avec streaming
+# 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
     
-    **Activez votre webcam** et voyez la détection se faire en direct !
-    
-    ⚡ **Optimisé pour la vitesse** avec des modèles légers
+    **Autorisez l'accès à votre webcam** et la détection se fera automatiquement !
     """)
     
     with gr.Row():
-        with gr.Column(scale=2):
-            # Composant webcam avec streaming
-            webcam = gr.Interface(
-                fn=process_webcam_frame,
-                inputs=[
-                    gr.Image(sources=["webcam"], streaming=True, type="numpy"),
-                    gr.Dropdown(
-                        choices=list(REALTIME_MODELS.keys()),
-                        value="YOLOS Tiny (ultra-rapide)",
-                        label="🤖 Modèle (changement en direct)"
-                    ),
-                    gr.Slider(
-                        minimum=0.1,
-                        maximum=1.0,
-                        value=0.5,
-                        step=0.1,
-                        label="🎯 Seuil de confiance"
-                    )
-                ],
-                outputs=gr.Image(type="numpy", streaming=True),
-                live=True,  # ⭐ CRUCIAL: Active le mode live
-                title=None
+        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(scale=1):
+        with gr.Column():
             gr.Markdown("""
-            ## 📊 Informations Live
-            
-            ### 🎛️ Contrôles en temps réel:
-            - **Modèle**: Change instantanément
-            - **Confiance**: Ajuste le filtrage
-            - **Streaming**: Traitement frame par frame
-            
-            ### ⚡ Optimisations:
-            - Images redimensionnées à 640px
-            - Modèles légers prioritaires
-            - Cache intelligent des modèles
-            - Dessin optimisé
-            
-            ### 🎯 Modèles recommandés:
-            - **YOLOS Tiny**: Maximum de vitesse
-            - **DETR ResNet-50**: Bon équilibre
+            ### 📊 Info
+            - **Streaming automatique** activé
+            - **Détection en continu** sur chaque frame
+            - **Ajustements en temps réel**
             """)
     
-    # Version alternative avec Interface simple
-    gr.Markdown("---")
-    gr.Markdown("## 🎥 Version Alternative (Interface Simple)")
-    
-    alternative_interface = gr.Interface(
-        fn=process_webcam_frame,
+    # Interface de streaming principal
+    webcam_interface = gr.Interface(
+        fn=detect_objects_live,
         inputs=[
-            gr.Image(sources=["webcam"], streaming=True),
-            gr.Dropdown(
-                choices=list(REALTIME_MODELS.keys()),
-                value="YOLOS Tiny (ultra-rapide)"
-            ),
-            gr.Slider(0.1, 1.0, 0.5, step=0.1)
+            gr.Image(sources=["webcam"], streaming=True, label="📹 Webcam Live"),
+            model_dropdown,
+            confidence_slider
         ],
-        outputs=gr.Image(streaming=True),
-        live=True,  # ⭐ Mode live activé
-        title="Détection Webcam Live",
-        description="Cliquez sur la webcam pour démarrer le streaming live!"
+        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"
     )
 
 if __name__ == "__main__":