Update app.py

app.py

@@ -8,6 +8,8 @@ from ultralytics import YOLO
 import threading
 from PIL import Image
 import torch
+import queue
+from streamlit.runtime.scriptrunner import add_script_run_ctx
 
 # --- FONCTIONS UTILES ---
 def draw_text_with_background(image, text, position, font=cv2.FONT_HERSHEY_SIMPLEX,
@@ -51,6 +53,10 @@ class YOLOVideoProcessor:
         
         # Préparer le tracker une seule fois
         self.tracker_config = "botsort.yaml" if self.tracker_method.lower() == "bot" else "bytetrack.yaml"
+        
+        # File d'attente pour la communication entre threads
+        self.frame_queue = queue.Queue(maxsize=1)
+        self.result_queue = queue.Queue(maxsize=1)
 
     def is_in_region(self, center, poly):
         poly_np = np.array(poly, dtype=np.int32)
@@ -185,14 +191,49 @@ class YOLOVideoProcessor:
 
         return display_frame
 
+    def process_webcam_frames(self):
+        """Thread de traitement qui analyse les frames et les met en file d'attente"""
+        while not self.stop_processing:
+            try:
+                # Récupérer le frame depuis la file d'attente
+                frame = self.frame_queue.get(timeout=1)
+                
+                # Mesurer le temps de traitement
+                start_time = time.time()
+                
+                # Traiter le frame
+                processed_frame = self.process_frame(frame)
+                
+                # Calculer le FPS
+                frame_time = time.time() - start_time
+                fps = 1 / frame_time
+                
+                # Ajouter info FPS
+                if processed_frame is not None:
+                    fps_text = f"FPS: {fps:.1f}"
+                    draw_text_with_background(processed_frame, fps_text, (10, 30))
+                
+                # Mettre le frame traité dans la file des résultats
+                self.result_queue.put((processed_frame, len(self.unique_region1_ids), len(self.unique_region2_ids)))
+                
+                # Marquer la tâche comme terminée
+                self.frame_queue.task_done()
+                
+            except queue.Empty:
+                # Aucun frame disponible, attendre un peu
+                time.sleep(0.01)
+            except Exception as e:
+                st.error(f"Erreur dans le thread de traitement: {e}")
+                break
+
     def process_webcam(self, camera_id=0, display_placeholder=None, count_placeholders=None):
-        """Traite la vidéo en temps réel depuis une webcam, optimisé pour la vitesse"""
+        """Traite la vidéo en temps réel depuis une webcam avec multi-threading"""
         cap = cv2.VideoCapture(camera_id)
         
-        # Configuration de la webcam - résolution plus petite pour plus de FPS
+        # Configuration de la webcam pour de meilleures performances
         cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
         cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
-        cap.set(cv2.CAP_PROP_FPS, 30)  # Essayer d'obtenir 30 FPS
+        cap.set(cv2.CAP_PROP_FPS, 30)
         
         if not cap.isOpened():
             st.error("⚠️ Erreur : Impossible d'ouvrir la webcam.")
@@ -202,114 +243,75 @@ class YOLOVideoProcessor:
         self.reset_counts()
         self.stop_processing = False
         frame_count = 0
-        fps_start_time = time.time()
-        fps = 0
         
-        while not self.stop_processing:
-            success, frame = cap.read()
-            if not success:
-                st.error("⚠️ Erreur lors de la lecture du flux vidéo.")
-                break
-                
-            # Ne traiter qu'une image sur N (frame_skip)
-            if frame_count % self.frame_skip == 0:
-                # Mesurer le temps de traitement
-                start_time = time.time()
+        # Démarrer le thread de traitement des frames
+        processing_thread = threading.Thread(target=self.process_webcam_frames)
+        processing_thread.daemon = True
+        processing_thread.start()
+        
+        # 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
+        
+        try:
+            while not self.stop_processing:
+                success, frame = cap.read()
+                if not success:
+                    st.error("⚠️ Erreur lors de la lecture du flux vidéo.")
+                    break
                 
-                processed_frame = self.process_frame(frame)
-                self.last_processed_frame = processed_frame
+                # 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
+                    self.frame_queue.put(frame)
                 
-                # Calculer et afficher le FPS
-                frame_time = time.time() - start_time
-                fps = 1 / (time.time() - fps_start_time)
-                fps_start_time = time.time()
+                # 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
                 
-                # Ajouter info FPS
-                if processed_frame is not None:
-                    fps_text = f"FPS: {fps:.1f}"
-                    draw_text_with_background(processed_frame, fps_text, (10, 30))
-            else:
-                # Utiliser le dernier frame traité pour économiser du temps de calcul
-                processed_frame = self.last_processed_frame if self.last_processed_frame is not None else frame
-            
-            # Convertir l'image OpenCV en format compatible avec Streamlit
-            if processed_frame is not None:
-                processed_frame_rgb = cv2.cvtColor(processed_frame, cv2.COLOR_BGR2RGB)
-                img = Image.fromarray(processed_frame_rgb)
+                frame_count += 1
                 
-                # Afficher l'image dans le placeholder Streamlit
-                if display_placeholder:
-                    display_placeholder.image(img, channels="RGB", use_column_width=True)
+                # Pause légère pour éviter d'utiliser 100% du CPU
+                time.sleep(0.001)
                 
-                # Mettre à jour les compteurs
-                if count_placeholders and len(count_placeholders) >= 2:
-                    count_placeholders[0].metric("Véhicules Sens 1 (Vert)", len(self.unique_region1_ids))
-                    count_placeholders[1].metric("Véhicules Sens 2 (Rouge)", len(self.unique_region2_ids))
-            
-            frame_count += 1
-            
-        cap.release()
-        st.success("✅ Flux vidéo arrêté.")
-
-
-# --- FONCTION CORRIGÉE POUR AFFICHER PRÉVISUALISATION DE LA WEBCAM ---
-def display_webcam_preview(camera_id, display_placeholder, poly1=None, poly2=None):
-    """Affiche une prévisualisation simple de la webcam sans détection"""
-    # Utiliser directement OpenCV au lieu d'un thread
-    cap = cv2.VideoCapture(camera_id)
-    
-    # Configuration de la webcam pour une bonne performance
-    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 False
-    
-    # Lecture d'une seule frame pour vérifier que tout fonctionne
-    success, frame = cap.read()
-    if not success:
-        st.error("⚠️ Erreur lors de la lecture du flux vidéo.")
-        cap.release()
-        return False
-    
-    # Initialiser st.session_state pour le contrôle de la prévisualisation
-    if 'preview_stop' not in st.session_state:
-        st.session_state.preview_stop = False
-    
-    # Boucle principale de la prévisualisation
-    st.session_state.preview_active = True
-    
-    try:
-        while st.session_state.preview_active and not st.session_state.preview_stop:
-            success, frame = cap.read()
-            if not success:
-                break
-            
-            # Dessiner les polygones si disponibles
-            if poly1 and len(poly1) >= 3:
-                cv2.polylines(frame, [np.array(poly1, np.int32)], isClosed=True, color=(0, 255, 0), thickness=2)
-            if poly2 and len(poly2) >= 3:
-                cv2.polylines(frame, [np.array(poly2, np.int32)], isClosed=True, color=(255, 0, 0), thickness=2)
-            
-            # Ajouter un texte explicatif
-            draw_text_with_background(frame, "Prévisualisation (sans détection)", (10, 30))
-            
-            # Convertir et afficher l'image
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            img = Image.fromarray(frame_rgb)
-            
-            # Afficher l'image dans le placeholder
-            display_placeholder.image(img, channels="RGB", use_column_width=True)
-            
-            # Court délai pour ne pas saturer Streamlit
-            time.sleep(0.1)
-    except Exception as e:
-        st.error(f"Erreur lors de la prévisualisation: {e}")
-    finally:
-        cap.release()
-    
-    return True
+        except Exception as e:
+            st.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)
+            st.success("✅ Flux vidéo arrêté.")
 
 
 # --- INTERFACE STREAMLIT ---
@@ -317,28 +319,28 @@ def main():
     st.set_page_config(
         page_title="Détecteur de Véhicules",
         page_icon="🚗",
-        layout="wide"
+        layout="wide",
+        menu_items={"About": "Détection de véhicules avec YOLOv8"}
     )
     
     st.title("🚗 Détection et comptage de Véhicules sur l'Autoroute de l'Avenir")
     
-    # Initialisation des variables d'état de session
+    # Session state pour gérer l'état de la webcam
     if 'webcam_active' not in st.session_state:
         st.session_state.webcam_active = False
-    if 'preview_active' not in st.session_state:
-        st.session_state.preview_active = False
-    if 'preview_stop' not in st.session_state:
-        st.session_state.preview_stop = False
     if 'processor' not in st.session_state:
         st.session_state.processor = None
+    if 'processing_thread' not in st.session_state:
+        st.session_state.processing_thread = None
     
     # Vérifier si le modèle existe déjà ou doit être téléchargé
     model_path = "best.pt"
     if not os.path.exists(model_path):
         with st.spinner("📥 Chargement du modèle YOLO... Cela peut prendre un moment."):
+            # Utilisez hub.load pour télécharger le modèle depuis Hugging Face Hub
             try:
                 from huggingface_hub import hf_hub_download
-                model_path = hf_hub_download(repo_id="ModuMLTECH/projet_trafic_2", filename="best.pt")
+                model_path = hf_hub_download(repo_id="ModuMLTECH/Trafic_congestion", filename="best.pt")
                 st.success("✅ Modèle chargé avec succès!")
             except Exception as e:
                 st.error(f"❌ Erreur lors du chargement du modèle: {e}")
@@ -368,6 +370,13 @@ def main():
         downsample = st.slider("Facteur d'échelle (plus petit = plus rapide)", 0.3, 1.0, 0.5, 0.1)
         conf_threshold = st.slider("Seuil de confiance", 0.1, 0.9, 0.35, 0.05)
         
+        # Informations système
+        st.subheader("💻 Informations système")
+        device_info = f"GPU: {'Disponible' if torch.cuda.is_available() else 'Non disponible'}"
+        if torch.cuda.is_available():
+            device_info += f" ({torch.cuda.get_device_name(0)})"
+        st.info(device_info)
+        
     def parse_polygon(input_text):
         try:
             return [tuple(map(int, point.split(','))) for point in input_text.split()]
@@ -448,7 +457,7 @@ def main():
         # Sélectionner la source vidéo
         camera_options = {"Webcam par défaut": 0}
         # Ajouter des options pour d'autres caméras si disponibles
-        for i in range(1, 3):  # Limiter à 3 caméras pour ne pas ralentir le chargement
+        for i in range(1, 5):  # Essayer de détecter jusqu'à 5 caméras
             try:
                 cap = cv2.VideoCapture(i)
                 if cap.isOpened():
@@ -460,98 +469,73 @@ def main():
         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_placeholder = st.empty()
-        col1, col2 = st.columns(2)
-        count_placeholders = [col1.empty(), col2.empty()]
+        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()]
         
-        # Nouvelle section pour la prévisualisation
-        st.subheader("1️⃣ Prévisualisation de la vidéo")
-        preview_col1, preview_col2 = st.columns(2)
+        # 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)
         
-        with preview_col1:
-            if st.button("👁️ Afficher la prévisualisation", key="start_preview"):
-                # Arrêter la détection si elle est active
-                if st.session_state.webcam_active and hasattr(st.session_state, 'processor'):
-                    st.session_state.processor.stop_processing = True
-                    st.session_state.webcam_active = False
-                    time.sleep(0.5)  # Attendre que le thread se termine
+        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:
+                # 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
                 
-                # Réinitialiser le flag d'arrêt
-                st.session_state.preview_stop = False
-                st.session_state.preview_active = True
+                st.session_state.processor = processor
+                st.session_state.webcam_active = True
                 
-                # Utiliser un thread pour la prévisualisation
-                preview_thread = threading.Thread(
-                    target=display_webcam_preview,
-                    args=(camera_id, video_placeholder, poly1, poly2)
+                # 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)
                 )
-                preview_thread.daemon = True
-                preview_thread.start()
+                processing_thread.daemon = True
                 
-                # Message de succès
-                st.success("📷 Prévisualisation démarrée")
-                    
-        with preview_col2:
-            if st.button("⏹️ Arrêter la prévisualisation", key="stop_preview"):
-                # Arrêter la prévisualisation
-                st.session_state.preview_stop = True
-                st.session_state.preview_active = False
-                time.sleep(0.5)  # Attendre que le thread se termine
-                video_placeholder.empty()  # Effacer l'affichage vidéo
-                st.success("🛑 Prévisualisation arrêtée")
+                # Ajouter le contexte Streamlit au thread pour éviter les erreurs
+                add_script_run_ctx(processing_thread)
                 
-        # Section de détection
-        st.subheader("2️⃣ Détection des véhicules")
-        
-        # Afficher les infos sur les performances
-        st.info("ℹ️ **Optimisations appliquées:** Redimensionnement des images, skip de frames, et utilisation de CUDA si disponible")
-        
-        # Boutons pour démarrer/arrêter la webcam
-        detect_col1, detect_col2 = st.columns(2)
-        
-        with detect_col1:
-            if st.button("▶️ Démarrer la détection", key="start_detection"):
-                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 détection est déjà active !")
-                else:
-                    # Arrêter la prévisualisation si elle est active
-                    if st.session_state.preview_active:
-                        st.session_state.preview_stop = True
-                        st.session_state.preview_active = False
-                        time.sleep(0.5)  # Attendre que le thread se termine
-                    
-                    # 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=processor.process_webcam,
-                        args=(camera_id, video_placeholder, count_placeholders)
-                    )
-                    processing_thread.daemon = True
-                    processing_thread.start()
-                    
-                    st.success("✅ Détection démarrée")
+                processing_thread.start()
+                st.session_state.processing_thread = processing_thread
                 
-        with detect_col2:
-            if st.button("⏹️ Arrêter la détection", key="stop_detection"):
-                if st.session_state.webcam_active and hasattr(st.session_state, 'processor'):
-                    st.session_state.processor.stop_processing = True
-                    st.session_state.webcam_active = False
-                    time.sleep(0.5)  # Attendre que le thread se termine
-                    video_placeholder.empty()  # Effacer l'affichage vidéo
-                    st.success("🛑 Détection arrêtée")
-                else:
-                    st.warning("⚠️ Aucune détection en cours !")
+        if col_stop.button("⏹️ Arrêter la détection"):
+            if st.session_state.webcam_active and st.session_state.processor:
+                st.session_state.processor.stop_processing = True
+                st.session_state.webcam_active = False
+                
+                # Attendre que le thread se termine
+                if st.session_state.processing_thread:
+                    st.session_state.processing_thread.join(timeout=2.0)
+                    st.session_state.processing_thread = None
+                
+                time.sleep(0.5)
+                video_placeholder.empty()  # Effacer l'affichage vidéo
+                
+                # Réinitialiser les compteurs
+                for placeholder in count_placeholders:
+                    placeholder.empty()
+            else:
+                st.warning("⚠️ Aucune détection en cours !")
 
 if __name__ == "__main__":
     main()