Update app.py

app.py

@@ -1,6 +1,5 @@
 import streamlit as st
 import cv2
-import tempfile
 import os
 import time
 import numpy as np
@@ -80,58 +79,6 @@ class YOLOVideoProcessor:
         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:
-                # 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:
@@ -390,13 +337,13 @@ class YOLOVideoProcessor:
 # --- INTERFACE STREAMLIT ---
 def main():
     st.set_page_config(
-        page_title="Détecteur de Véhicules",
+        page_title="Détecteur de Véhicules en Temps Réel",
         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")
+    st.title("🚗 Détection et comptage de Véhicules en Temps Réel")
     
     # Session state pour gérer l'état de la webcam
     if 'webcam_active' not in st.session_state:
@@ -421,10 +368,7 @@ def main():
                 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
+    # Paramètres dans la barre latérale
     with st.sidebar:
         st.header("🔹 Paramètres")
         
@@ -462,170 +406,108 @@ def main():
     # 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")
+    # Section principale de la détection en temps réel
+    st.header("Détection en Temps Réel avec Webcam")
+    
+    # Vérifier les caméras disponibles
+    available_cameras = check_camera_availability()
+    if not available_cameras:
+        st.warning("⚠️ Aucune caméra détectée automatiquement sur votre système. Vous pouvez toujours essayer les options ci-dessous.")
+    else:
+        st.success(f"✅ Caméras détectées aux indices: {available_cameras}")
+    
+    # Méthode améliorée de sélection de caméra
+    camera_options = {"Webcam par défaut (0)": 0}
+    
+    # Ajouter plus d'options pour les caméras alternatives
+    for i in range(1, 8):  # Essayer jusqu'à 8 caméras différentes
+        camera_options[f"Caméra alternative ({i})"] = i
+    
+    # Ajouter aussi des options pour les caméras virtuelles ou IP
+    camera_options["Caméra IP (entrez l'URL)"] = "ip"
+    
+    selected_camera = st.selectbox("Sélectionnez la source vidéo", list(camera_options.keys()))
+    
+    # Permettre d'entrer une URL de caméra IP
+    if camera_options[selected_camera] == "ip":
+        ip_camera_url = st.text_input("URL de la caméra IP (RTSP, HTTP)", "http://adresse-ip:port/video")
+        camera_id = ip_camera_url
+    else:
+        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:
+            video_placeholder.info("🔄 Tentative de connexion à la caméra... Veuillez patienter.")
             
-            # Écrire le fichier téléchargé dans un fichier temporaire
-            with open(input_video_path, "wb") as f:
-                f.write(uploaded_file.getbuffer())
+            # 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.video(input_video_path)  # Afficher la vidéo d'entrée
+            st.session_state.processor = processor
+            st.session_state.webcam_active = True
             
-            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")
-        
-        # Vérifier les caméras disponibles
-        available_cameras = check_camera_availability()
-        if not available_cameras:
-            st.warning("⚠️ Aucune caméra détectée automatiquement sur votre système. Vous pouvez toujours essayer les options ci-dessous.")
-        else:
-            st.success(f"✅ Caméras détectées aux indices: {available_cameras}")
-        
-        # Méthode améliorée de sélection de caméra
-        camera_options = {"Webcam par défaut (0)": 0}
-        
-        # Ajouter plus d'options pour les caméras alternatives
-        for i in range(1, 8):  # Essayer jusqu'à 8 caméras différentes
-            camera_options[f"Caméra alternative ({i})"] = i
-        
-        # Ajouter aussi des options pour les caméras virtuelles ou IP
-        camera_options["Caméra IP (entrez l'URL)"] = "ip"
-        
-        selected_camera = st.selectbox("Sélectionnez la source vidéo", list(camera_options.keys()))
-        
-        # Permettre d'entrer une URL de caméra IP
-        if camera_options[selected_camera] == "ip":
-            ip_camera_url = st.text_input("URL de la caméra IP (RTSP, HTTP)", "http://adresse-ip:port/video")
-            camera_id = ip_camera_url
-        else:
-            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:
-                video_placeholder.info("🔄 Tentative de connexion à la caméra... Veuillez patienter.")
-                
-                # 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
-                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
+            # 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
+            except Exception as e:
+                st.error(f"Erreur au démarrage du thread: {e}")
                 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 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()