Update app.py

app.py

@@ -1,111 +1,209 @@
-import streamlit as st
-import cv2
-import tempfile
-import os
-import time
-import numpy as np
-from ultralytics import YOLO
-import threading
-from PIL import Image
-import torch
-import queue
-from streamlit.runtime.scriptrunner import add_script_run_ctx
+# Modifier la partie de détection des caméras dans la fonction main() (onglet 2)
 
-# --- FONCTIONS UTILES ---
-def draw_text_with_background(image, text, position, font=cv2.FONT_HERSHEY_SIMPLEX,
-                              font_scale=1, font_thickness=2, text_color=(255, 255, 255), bg_color=(0, 0, 0), padding=5):
-    """Ajoute du texte avec un fond sur une image OpenCV."""
-    text_size = cv2.getTextSize(text, font, font_scale, font_thickness)[0]
-    text_width, text_height = text_size
-
-    x, y = position
-    top_left = (x, y - text_height - padding)
-    bottom_right = (x + text_width + padding * 2, y + padding)
-
-    cv2.rectangle(image, top_left, bottom_right, bg_color, -1)
-    cv2.putText(image, text, (x + padding, y), font, font_scale, text_color, font_thickness, cv2.LINE_AA)
+# Dans l'onglet 2: Détection en Temps Réel, remplacer le code de sélection de caméra par:
+with tab2:
+    st.header("Détection en Temps Réel avec Webcam")
+    
+    # Simplified camera selection - focusing on reliability
+    camera_options = {"Webcam par défaut (0)": 0}
+    # Ajout de quelques options supplémentaires sans test préalable
+    for i in range(1, 4):
+        camera_options[f"Caméra alternative ({i})"] = i
+            
+    selected_camera = st.selectbox("Sélectionnez la source vidéo", list(camera_options.keys()))
+    camera_id = camera_options[selected_camera]
+    
+    # Paramètres d'affichage
+    display_quality = st.select_slider(
+        "Qualité d'affichage",
+        options=["Basse", "Moyenne", "Haute"],
+        value="Moyenne"
+    )
+    
+    # Affichage des placeholders
+    video_container = st.container()
+    video_placeholder = video_container.empty()
+    
+    # Crée une ligne pour les compteurs
+    count_col1, count_col2 = st.columns(2)
+    count_placeholders = [count_col1.empty(), count_col2.empty()]
+    
+    # Afficher les infos sur les performances
+    st.info("ℹ️ **Optimisations appliquées:** Multi-threading, redimensionnement des images, et utilisation de CUDA si disponible")
+    
+    # Boutons pour démarrer/arrêter la webcam
+    col_start, col_stop = st.columns(2)
+    
+    if col_start.button("▶️ Démarrer la détection en direct"):
+        if not valid_polygons:
+            st.error("❌ Les coordonnées des polygones doivent contenir **exactement 4 points**.")
+        elif st.session_state.webcam_active:
+            st.warning("⚠️ La webcam est déjà active !")
+        else:
+            # Tester l'ouverture de la webcam avant de démarrer le traitement
+            test_cap = cv2.VideoCapture(camera_id)
+            if not test_cap.isOpened():
+                st.error(f"⚠️ Impossible d'ouvrir la caméra {camera_id}. Essayez une autre source vidéo.")
+                test_cap.release()
+            else:
+                test_cap.release()  # Libérer la caméra pour le traitement réel
+                
+                # Créer le processeur YOLO avec les paramètres d'optimisation
+                processor = YOLOVideoProcessor(model_path, poly1, poly2, tracker_method)
+                processor.frame_skip = frame_skip
+                processor.downsample_factor = downsample
+                processor.conf_threshold = conf_threshold
+                
+                st.session_state.processor = processor
+                st.session_state.webcam_active = True
+                
+                # Démarrer le traitement dans un thread séparé
+                processing_thread = threading.Thread(
+                    target=st.session_state.processor.process_webcam,
+                    args=(camera_id, video_placeholder, count_placeholders)
+                )
+                processing_thread.daemon = True
+                
+                # Ajouter le contexte Streamlit au thread pour éviter les erreurs
+                add_script_run_ctx(processing_thread)
+                
+                try:
+                    processing_thread.start()
+                    st.session_state.processing_thread = processing_thread
+                    st.success("✅ Webcam démarrée avec succès!")
+                except Exception as e:
+                    st.error(f"Erreur au démarrage du thread: {e}")
+                    st.session_state.webcam_active = False
 
-# --- CLASSE YOLO OPTIMISÉE ---
-class YOLOVideoProcessor:
-    def __init__(self, model_path, tracker_method="bot"):
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.frame_skip = 2
-        self.downsample_factor = 0.5
-        self.img_size = 640
-        self.conf_threshold = 0.35
-        self.model = YOLO(model_path, task="detect").to(self.device)
-        self.tracker_method = tracker_method
-        self.stop_processing = False
+# Maintenant, modifions la méthode process_webcam dans la classe YOLOVideoProcessor pour améliorer la gestion de la webcam:
 
-    def process_webcam(self, camera_id=0, display_placeholder=None):
+def process_webcam(self, camera_id=0, display_placeholder=None, count_placeholders=None):
+    """Traite la vidéo en temps réel depuis une webcam avec multi-threading"""
+    # Tentative d'ouverture avec plusieurs backends dans OpenCV
+    for backend_pref in [cv2.CAP_ANY, cv2.CAP_DSHOW, cv2.CAP_MSMF, cv2.CAP_V4L2]:
+        try:
+            # Essayer différents backends de capture
+            cap = cv2.VideoCapture(camera_id, backend_pref)
+            if cap.isOpened():
+                break
+        except:
+            continue
+    
+    # Si aucun backend n'a fonctionné, essayer une dernière fois avec le backend par défaut
+    if not cap.isOpened():
         cap = cv2.VideoCapture(camera_id)
+    
+    # Vérifier si la caméra est ouverte
+    if not cap.isOpened():
+        if display_placeholder:
+            display_placeholder.error("⚠️ Erreur : Impossible d'ouvrir la webcam. Essayez de redémarrer l'application ou utiliser une autre source vidéo.")
+        return
+    
+    # Configuration de la webcam pour de meilleures performances (avec gestion d'erreurs)
+    try:
         cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
         cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
-        if not cap.isOpened():
-            st.error("⚠️ Erreur : Impossible d'ouvrir la webcam.")
-            return
-        self.stop_processing = False
-        
-        while not self.stop_processing:
-            success, frame = cap.read()
-            if not success:
-                break
-            display_placeholder.image(frame, channels="BGR", use_column_width=True)
-        cap.release()
-        st.success("✅ Flux vidéo arrêté.")
-
-# --- INTERFACE STREAMLIT ---
-def main():
-    st.set_page_config(page_title="Détecteur de Véhicules", page_icon="🚗", layout="wide")
-    st.title("🚗 Détection et comptage de Véhicules sur l'Autoroute de l'Avenir")
+        cap.set(cv2.CAP_PROP_FPS, 30)
+    except:
+        # En cas d'échec, continuer sans erreur
+        if display_placeholder:
+            display_placeholder.warning("⚠️ Impossible de configurer certains paramètres de la webcam. Utilisation des paramètres par défaut.")
     
-    model_path = "best.pt"
-    if not os.path.exists(model_path):
-        st.error("❌ Modèle YOLO introuvable!")
-        return
+    # Réinitialiser les compteurs pour la nouvelle session
+    self.reset_counts()
+    self.stop_processing = False
+    frame_count = 0
     
-    tab1, tab2 = st.tabs(["🎥 Détection en Temps Réel", "📹 Analyse de Vidéo"])
+    # Démarrer le thread de traitement des frames
+    processing_thread = threading.Thread(target=self.process_webcam_frames)
+    processing_thread.daemon = True
+    processing_thread.start()
     
-    with st.sidebar:
-        st.header("🔹 Paramètres")
-        tracker_method = st.selectbox("Méthode de tracking", ["bot", "byte"], index=0)
-        frame_skip = st.slider("Frames Skip", 1, 5, 2)
-        downsample = st.slider("Facteur d'échelle", 0.3, 1.0, 0.5, 0.1)
-        conf_threshold = st.slider("Seuil de confiance", 0.1, 0.9, 0.35, 0.05)
+    # Horodatage pour limiter la fréquence de rafraîchissement de l'interface
+    last_ui_update_time = time.time()
+    ui_update_interval = 0.03  # ~30 FPS pour l'interface
     
-    with tab1:
-        st.header("Détection en Temps Réel avec Webcam")
-        camera_id = 0
-        video_placeholder = st.empty()
+    try:
+        # Attendre un peu pour que la webcam s'initialise
+        time.sleep(0.5)
+        
+        # Essayer de lire le premier frame pour s'assurer que la caméra fonctionne
+        success, first_frame = cap.read()
+        if not success:
+            if display_placeholder:
+                display_placeholder.error("⚠️ Impossible de lire les images de la webcam. Vérifiez votre caméra et ses permissions.")
+            return
         
-        start_detection = st.button("▶️ Lancer la détection en temps réel")
-        stop_detection = st.button("⏹️ Arrêter la détection")
+        # Afficher ce premier frame pour montrer que la connexion fonctionne
+        if display_placeholder:
+            first_frame_rgb = cv2.cvtColor(first_frame, cv2.COLOR_BGR2RGB)
+            display_placeholder.image(first_frame_rgb, channels="RGB", use_column_width=True, caption="Webcam connectée avec succès!")
         
-        if start_detection:
-            processor = YOLOVideoProcessor(model_path, tracker_method)
-            processor.frame_skip = frame_skip
-            processor.downsample_factor = downsample
-            processor.conf_threshold = conf_threshold
-            processing_thread = threading.Thread(
-                target=processor.process_webcam, args=(camera_id, video_placeholder))
-            processing_thread.daemon = True
-            add_script_run_ctx(processing_thread)
-            processing_thread.start()
-            st.success("✅ Détection en cours...")
+        # Boucle principale de capture
+        while not self.stop_processing:
+            success, frame = cap.read()
+            if not success:
+                # Essayer de reconnecter en cas d'erreur
+                time.sleep(0.1)
+                continue
             
-        if stop_detection:
-            st.success("✅ Détection arrêtée.")
-    
-    with tab2:
-        st.header("Analyse de Vidéo")
-        uploaded_file = st.file_uploader("📂 Upload une vidéo", type=["mp4", "avi", "mov"])
-        if uploaded_file is not None:
-            temp_dir = tempfile.mkdtemp()
-            input_video_path = os.path.join(temp_dir, "input_video.mp4")
-            with open(input_video_path, "wb") as f:
-                f.write(uploaded_file.getbuffer())
-            st.video(input_video_path)
-            st.success("Vidéo chargée avec succès.")
-
-if __name__ == "__main__":
-    main()
+            # Ne traiter qu'une image sur N (frame_skip)
+            if frame_count % self.frame_skip == 0:
+                # Vider la file si elle est pleine pour éviter le retard
+                if self.frame_queue.full():
+                    try:
+                        self.frame_queue.get_nowait()
+                        self.frame_queue.task_done()
+                    except:
+                        pass
+                
+                # Mettre le frame dans la file pour traitement
+                try:
+                    self.frame_queue.put(frame, block=False)
+                except queue.Full:
+                    pass  # Ignorer si la file est pleine
+            
+            # Mise à jour de l'interface à fréquence limitée
+            current_time = time.time()
+            if current_time - last_ui_update_time >= ui_update_interval:
+                try:
+                    # Récupérer le dernier résultat disponible sans bloquer
+                    if not self.result_queue.empty():
+                        processed_frame, count1, count2 = self.result_queue.get_nowait()
+                        
+                        # Convertir l'image OpenCV en format compatible avec Streamlit
+                        processed_frame_rgb = cv2.cvtColor(processed_frame, cv2.COLOR_BGR2RGB)
+                        img = Image.fromarray(processed_frame_rgb)
+                        
+                        # Afficher l'image dans le placeholder Streamlit
+                        if display_placeholder:
+                            display_placeholder.image(img, channels="RGB", use_column_width=True)
+                        
+                        # Mettre à jour les compteurs
+                        if count_placeholders and len(count_placeholders) >= 2:
+                            count_placeholders[0].metric("Véhicules Sens 1 (Vert)", count1)
+                            count_placeholders[1].metric("Véhicules Sens 2 (Rouge)", count2)
+                        
+                        last_ui_update_time = current_time
+                except queue.Empty:
+                    pass
+                except Exception as e:
+                    if display_placeholder:
+                        display_placeholder.warning(f"Erreur lors de l'affichage: {e}")
+            
+            frame_count += 1
+            
+            # Pause légère pour éviter d'utiliser 100% du CPU
+            time.sleep(0.001)
+            
+    except Exception as e:
+        if display_placeholder:
+            display_placeholder.error(f"Erreur dans la boucle principale: {e}")
+    finally:
+        # Nettoyage
+        self.stop_processing = True
+        cap.release()
+        # Attendre que le thread de traitement se termine
+        processing_thread.join(timeout=1.0)
+        if display_placeholder:
+            display_placeholder.success("✅ Flux vidéo arrêté.")