Update app.py

app.py

@@ -1,209 +1,592 @@
-# Modifier la partie de détection des caméras dans la fonction main() (onglet 2)
+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
 
-# 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
+# --- 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)
+
+# --- CLASSE YOLO OPTIMISÉE ---
+class YOLOVideoProcessor:
+    def __init__(self, model_path, poly1, poly2, tracker_method="bot"):
+        # Déterminer le meilleur device disponible
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
             
-    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()
+        # Paramètres d'optimisation
+        self.frame_skip = 2  # Traiter une image sur N
+        self.downsample_factor = 0.5  # Réduire la taille des images de 50%
+        self.img_size = 640  # Taille d'entrée fixe pour YOLO
+        self.conf_threshold = 0.35  # Seuil de confiance plus élevé
+        
+        # Charger le modèle une seule fois et avec les bons paramètres
+        self.model = YOLO(model_path, task="detect")
+        self.model.to(self.device)
+        
+        # Autres paramètres
+        self.tracker_method = tracker_method
+        self.unique_region1_ids = set()
+        self.unique_region2_ids = set()
+        self.poly1 = poly1
+        self.poly2 = poly2
+        self.stop_processing = False
+        self.last_processed_frame = None
+        self.current_frame = 0
+        
+        # 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)
+        return cv2.pointPolygonTest(poly_np, center, False) >= 0
+
+    def reset_counts(self):
+        """Réinitialiser les compteurs"""
+        self.unique_region1_ids = set()
+        self.unique_region2_ids = set()
+
+    def process_video(self, video_path, output_path, progress_bar=None):
+        """Traite une vidéo enregistrée avec optimisations"""
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            st.error("⚠️ Erreur : Impossible d'ouvrir la vidéo.")
+            return
+
+        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+
+        if fps == 0:
+            fps = 30  # Valeur par défaut si FPS est invalide
+
+        # Utiliser XVID qui est généralement mieux supporté
+        fourcc = cv2.VideoWriter_fourcc(*'XVID') 
+        out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))  
+
+        processed_frames = 0
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        frame_count = 0
+
+        while cap.isOpened():
+            success, frame = cap.read()
+            if not success:
+                break
+
+            # Mise à jour de la barre de progression
+            if progress_bar is not None:
+                progress_bar.progress(processed_frames / total_frames)
+
+            # Ne traiter qu'une image sur N pour accélérer le traitement
+            if frame_count % self.frame_skip == 0:
+                processed_frame = self.process_frame(frame)
+                self.last_processed_frame = processed_frame
             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
-
-# 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, 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():
+                # Réutiliser le dernier frame traité, mais mettre à jour juste les compteurs
+                processed_frame = self.last_processed_frame if self.last_processed_frame is not None else frame
+            
+            out.write(processed_frame)
+            processed_frames += 1
+            frame_count += 1
+
+        cap.release()
+        out.release()
+        cv2.destroyAllWindows()
+
+        if processed_frames == 0:
+            st.error("⚠️ Aucune image n'a été écrite dans la vidéo de sortie !")
+        
+        return len(self.unique_region1_ids), len(self.unique_region2_ids)
+
+    def process_frame(self, frame):
+        """Traite une image individuelle avec YOLO et le tracking, avec optimisations"""
+        if frame is None:
+            return None
+        
+        # Redimensionner l'image pour accélérer le traitement
+        orig_height, orig_width = frame.shape[:2]
+        if self.downsample_factor < 1.0:
+            resized_width = int(orig_width * self.downsample_factor)
+            resized_height = int(orig_height * self.downsample_factor)
+            resized_frame = cv2.resize(frame, (resized_width, resized_height), interpolation=cv2.INTER_AREA)
+        else:
+            resized_frame = frame
+            
+        # Processus de détection avec YOLO
+        with torch.no_grad():  # Désactiver le calcul des gradients pour économiser de la mémoire
+            results = self.model.track(
+                resized_frame, 
+                persist=True, 
+                tracker=self.tracker_config, 
+                conf=self.conf_threshold,
+                imgsz=self.img_size
+            )
+
+        # Créer une copie du frame original pour l'affichage
+        display_frame = frame.copy()
+        frame_height, frame_width = display_frame.shape[:2]
+        
+        # Dessiner les polygones
+        cv2.polylines(display_frame, [np.array(self.poly1, np.int32)], isClosed=True, color=(0, 255, 0), thickness=2)
+        cv2.polylines(display_frame, [np.array(self.poly2, np.int32)], isClosed=True, color=(255, 0, 0), thickness=2)
+
+        # Facteur d'échelle pour ajuster les coordonnées si on a redimensionné l'image
+        scale_x = orig_width / resized_width if self.downsample_factor < 1.0 else 1.0
+        scale_y = orig_height / resized_height if self.downsample_factor < 1.0 else 1.0
+
+        track_ids = []
+        if results and len(results) > 0 and len(results[0].boxes) > 0:
+            try:
+                boxes = results[0].boxes.xywh.cpu().numpy()
+                track_ids = results[0].boxes.id.int().cpu().tolist()
+                
+                # Dessiner les détections et mettre à jour les compteurs
+                for i, (box, track_id) in enumerate(zip(boxes, track_ids)):
+                    x, y, w, h = box
+                    # Ajuster les coordonnées au frame original
+                    center_x = int(x * scale_x)
+                    center_y = int(y * scale_y)
+                    center_point = (center_x, center_y)
+                    
+                    # Vérifier les régions
+                    if self.is_in_region(center_point, self.poly1):
+                        self.unique_region1_ids.add(track_id)
+                    if self.is_in_region(center_point, self.poly2):
+                        self.unique_region2_ids.add(track_id)
+                    
+                    # Optionnel: dessiner les boîtes de détection
+                    width = int(w * scale_x)
+                    height = int(h * scale_y)
+                    top_left = (center_x - width // 2, center_y - height // 2)
+                    bottom_right = (center_x + width // 2, center_y + height // 2)
+                    cv2.rectangle(display_frame, top_left, bottom_right, (0, 255, 0), 2)
+                    
+            except AttributeError:
+                pass
+
+        # Affichage du comptage des véhicules
+        draw_text_with_background(display_frame, f'Total Sens 1: {len(self.unique_region1_ids)}', (10, frame_height - 50))
+        draw_text_with_background(display_frame, f'Total Sens 2: {len(self.unique_region2_ids)}', (frame_width - 300, frame_height - 50))
+
+        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
-        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)
-        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.")
-    
-    # Réinitialiser les compteurs pour la nouvelle session
-    self.reset_counts()
-    self.stop_processing = False
-    frame_count = 0
-    
-    # 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:
-        # Attendre un peu pour que la webcam s'initialise
-        time.sleep(0.5)
+
+    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)
         
-        # Essayer de lire le premier frame pour s'assurer que la caméra fonctionne
-        success, first_frame = cap.read()
-        if not success:
+        # Vérifier si la caméra est ouverte
+        if not cap.isOpened():
             if display_placeholder:
-                display_placeholder.error("⚠️ Impossible de lire les images de la webcam. Vérifiez votre caméra et ses permissions.")
+                display_placeholder.error("⚠️ Erreur : Impossible d'ouvrir la webcam. Essayez de redémarrer l'application ou utiliser une autre source vidéo.")
             return
         
-        # 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!")
+        # 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)
+            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.")
         
-        # Boucle principale de capture
-        while not self.stop_processing:
-            success, frame = cap.read()
+        # Réinitialiser les compteurs pour la nouvelle session
+        self.reset_counts()
+        self.stop_processing = False
+        frame_count = 0
+        
+        # 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:
+            # 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:
-                # Essayer de reconnecter en cas d'erreur
-                time.sleep(0.1)
-                continue
+                if display_placeholder:
+                    display_placeholder.error("⚠️ Impossible de lire les images de la webcam. Vérifiez votre caméra et ses permissions.")
+                return
             
-            # 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():
+            # 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!")
+            
+            # 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
+                
+                # 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.get_nowait()
-                        self.frame_queue.task_done()
-                    except:
-                        pass
+                        self.frame_queue.put(frame, block=False)
+                    except queue.Full:
+                        pass  # Ignorer si la file est pleine
                 
-                # 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
+                # 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.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}")
+                            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é.")
+
+
+# --- INTERFACE STREAMLIT ---
+def main():
+    st.set_page_config(
+        page_title="Détecteur de Véhicules",
+        page_icon="🚗",
+        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")
+    
+    # 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 '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/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}")
+                # Fallback: utiliser un modèle YOLO standard
+                st.warning("⚠️ Utilisation du modèle YOLO standard à la place")
+                model_path = "yolov8n.pt"
+    
+    # Onglets pour séparer les modes vidéo et webcam
+    tab1, tab2 = st.tabs(["📹 Analyse de Vidéo", "🎥 Détection en Temps Réel"])
+    
+    # Paramètres communs entre les onglets
+    with st.sidebar:
+        st.header("🔹 Paramètres")
+        
+        # Entrée utilisateur pour les polygones
+        st.subheader("📍 Polygone 1 (vert)")
+        poly1_input = st.text_area("Entrez 4 points (x,y) séparés par des espaces", "465,350 609,350 520,630 3,630")
+        
+        st.subheader("📍 Polygone 2 (rouge)")
+        poly2_input = st.text_area("Entrez 4 points (x,y) séparés par des espaces", "678,350 815,350 1203,630 743,630")
+        
+        tracker_method = st.selectbox("Méthode de tracking", ["bot", "byte"], index=0)
+        
+        # Paramètres d'optimisation
+        st.subheader("🚀 Paramètres d'optimisation")
+        frame_skip = st.slider("Skip de frames (plus élevé = plus rapide)", 1, 5, 2)
+        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()]
+        except:
+            return []
+    
+    poly1 = parse_polygon(poly1_input)
+    poly2 = parse_polygon(poly2_input)
+
+    # Vérifier que les polygones sont valides
+    valid_polygons = len(poly1) == 4 and len(poly2) == 4
+
+    # Onglet 1: Analyse de Vidéo
+    with tab1:
+        uploaded_file = st.file_uploader("📂 Upload une vidéo", type=["mp4", "avi", "mov"])
+        
+        if uploaded_file is not None:
+            # Créer un dossier temporaire si nécessaire
+            temp_dir = tempfile.mkdtemp()
+            input_video_path = os.path.join(temp_dir, "input_video.mp4")
+            output_video_path = os.path.join(temp_dir, "output_video.mp4")
             
-            frame_count += 1
+            # Écrire le fichier téléchargé dans un fichier temporaire
+            with open(input_video_path, "wb") as f:
+                f.write(uploaded_file.getbuffer())
             
-            # Pause légère pour éviter d'utiliser 100% du CPU
-            time.sleep(0.001)
+            st.video(input_video_path)  # Afficher la vidéo d'entrée
             
-    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é.")
+            if st.button("▶️ Lancer la détection"):
+                if valid_polygons:
+                    # Afficher la barre de progression
+                    progress_text = "🔄 Traitement de la vidéo en cours..."
+                    progress_bar = st.progress(0)
+                    
+                    # Traitement de la vidéo 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
+                    
+                    # Démarrer le traitement
+                    start_time = time.time()
+                    count1, count2 = processor.process_video(input_video_path, output_video_path, progress_bar=progress_bar)
+                    end_time = time.time()
+                    
+                    # Calcul du temps de traitement
+                    processing_time = end_time - start_time
+                    
+                    progress_bar.progress(1.0)  # Compléter la barre de progression
+                    st.success(f"✅ Traitement terminé en {processing_time:.2f} secondes!")
+                    
+                    # Afficher les résultats
+                    col_result1, col_result2 = st.columns(2)
+                    with col_result1:
+                        st.metric("Véhicules Sens 1 (Vert)", count1)
+                    with col_result2:
+                        st.metric("Véhicules Sens 2 (Rouge)", count2)
+                    
+                    # Afficher la vidéo traitée
+                    st.subheader("Vidéo traitée")
+                    st.video(output_video_path)
+                    
+                    # Option de téléchargement
+                    with open(output_video_path, "rb") as file:
+                        st.download_button(
+                            label="⬇️ Télécharger la vidéo",
+                            data=file,
+                            file_name="video_traitee.mp4",
+                            mime="video/mp4"
+                        )
+                else:
+                    st.error("❌ Les coordonnées des polygones doivent contenir **exactement 4 points**.")
+
+    # Onglet 2: Détection en Temps Réel
+    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
+                
+        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()