Update app.py

app.py

@@ -4,9 +4,10 @@ import tempfile
 import os
 import time
 import numpy as np
-import pandas as pd
-from collections import defaultdict
 from ultralytics import YOLO
+import threading
+from PIL import Image
+import torch
 
 # --- FONCTIONS UTILES ---
 def draw_text_with_background(image, text, position, font=cv2.FONT_HERSHEY_SIMPLEX,
@@ -22,25 +23,47 @@ def draw_text_with_background(image, text, position, font=cv2.FONT_HERSHEY_SIMPL
     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 ---
+# --- CLASSE YOLO OPTIMISÉE ---
 class YOLOVideoProcessor:
-    def __init__(self, model_path, video_path, output_path, poly1, poly2, tracker_method="bot"):
+    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'
+            
+        # 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.video_path = video_path
-        self.output_path = output_path 
-
         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"
 
     def is_in_region(self, center, poly):
         poly_np = np.array(poly, dtype=np.int32)
         return cv2.pointPolygonTest(poly_np, center, False) >= 0
 
-    def process_video(self, progress_bar=None):
-        cap = cv2.VideoCapture(self.video_path)
+    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
@@ -54,10 +77,11 @@ class YOLOVideoProcessor:
 
         # Utiliser XVID qui est généralement mieux supporté
         fourcc = cv2.VideoWriter_fourcc(*'XVID') 
-        out = cv2.VideoWriter(self.output_path, fourcc, fps, (frame_width, frame_height))  
+        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()
@@ -68,35 +92,17 @@ class YOLOVideoProcessor:
             if progress_bar is not None:
                 progress_bar.progress(processed_frames / total_frames)
 
-            tracker = "botsort.yaml" if self.tracker_method.lower() == "bot" else "bytetrack.yaml"
-            results = self.model.track(frame, persist=True, tracker=tracker, conf=0.25)
-
-            track_ids = []
-            if results and len(results) > 0 and len(results[0].boxes) > 0:
-                try:
-                    track_ids = results[0].boxes.id.int().cpu().tolist()
-                except AttributeError:
-                    track_ids = [i for i in range(len(results[0].boxes.xywh.cpu().numpy()))]
-
-            # Dessiner les polygones
-            cv2.polylines(frame, [np.array(self.poly1, np.int32)], isClosed=True, color=(0, 255, 0), thickness=2)
-            cv2.polylines(frame, [np.array(self.poly2, np.int32)], isClosed=True, color=(255, 0, 0), thickness=2)
-
-            for box, track_id in zip(results[0].boxes.xywh.cpu().numpy(), track_ids):
-                x, y, w, h = box
-                center_point = (int(x), int(y))
-
-                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)
-
-            # Affichage du comptage des véhicules
-            draw_text_with_background(frame, f'Total Sens 1: {len(self.unique_region1_ids)}', (10, frame_height - 50))
-            draw_text_with_background(frame, f'Total Sens 2: {len(self.unique_region2_ids)}', (frame_width - 300, frame_height - 50))
-
-            out.write(frame)
+            # 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()
@@ -107,6 +113,191 @@ class YOLOVideoProcessor:
         
         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(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"""
+        cap = cv2.VideoCapture(camera_id)
+        
+        # Configuration de la webcam - résolution plus petite pour plus de FPS
+        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
+        
+        if not cap.isOpened():
+            st.error("⚠️ Erreur : Impossible d'ouvrir la webcam.")
+            return
+        
+        # Réinitialiser les compteurs pour la nouvelle session
+        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()
+                
+                processed_frame = self.process_frame(frame)
+                self.last_processed_frame = processed_frame
+                
+                # Calculer et afficher le FPS
+                frame_time = time.time() - start_time
+                fps = 1 / (time.time() - fps_start_time)
+                fps_start_time = time.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))
+            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)
+                
+                # 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)", len(self.unique_region1_ids))
+                    count_placeholders[1].metric("Véhicules Sens 2 (Rouge)", len(self.unique_region2_ids))
+            
+            frame_count += 1
+            
+            # Attendre un peu moins pour augmenter le FPS
+            time.sleep(0.01)
+        
+        cap.release()
+        st.success("✅ Flux vidéo arrêté.")
+
+
+# --- NOUVELLE FONCTION 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"""
+    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)
+    cap.set(cv2.CAP_PROP_FPS, 30)
+    
+    if not cap.isOpened():
+        st.error("⚠️ Erreur : Impossible d'ouvrir la webcam.")
+        return False
+    
+    stop_preview = False
+    st.session_state.preview_active = True
+    
+    while st.session_state.preview_active and not stop_preview:
+        success, frame = cap.read()
+        if not success:
+            st.error("⚠️ Erreur lors de la lecture du flux vidéo.")
+            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)
+        display_placeholder.image(img, channels="RGB", use_column_width=True)
+        
+        # Petit délai pour ne pas surcharger l'interface
+        time.sleep(0.03)
+    
+    cap.release()
+    return True
+
 
 # --- INTERFACE STREAMLIT ---
 def main():
@@ -118,6 +309,16 @@ def main():
     
     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 et de la prévisualisation
+    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 'processor' not in st.session_state:
+        st.session_state.processor = None
+    if 'preview_thread' not in st.session_state:
+        st.session_state.preview_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):
@@ -133,10 +334,11 @@ def main():
                 st.warning("⚠️ Utilisation du modèle YOLO standard à la place")
                 model_path = "yolov8n.pt"
     
-    # Colonnes pour l'organisation de l'interface
-    col1, col2 = st.columns([3, 1])
+    # Onglets pour séparer les modes vidéo et webcam
+    tab1, tab2 = st.tabs(["📹 Analyse de Vidéo", "🎥 Détection en Temps Réel"])
     
-    with col2:
+    # Paramètres communs entre les onglets
+    with st.sidebar:
         st.header("🔹 Paramètres")
         
         # Entrée utilisateur pour les polygones
@@ -147,18 +349,28 @@ def main():
         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)
-    
-    with col1:
-        uploaded_file = st.file_uploader("📂 Upload une vidéo", type=["mp4", "avi", "mov"])
         
-        def parse_polygon(input_text):
-            try:
-                return [tuple(map(int, point.split(','))) for point in input_text.split()]
-            except:
-                return []
+        # 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)
         
-        poly1 = parse_polygon(poly1_input)
-        poly2 = parse_polygon(poly2_input)
+    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
@@ -173,17 +385,20 @@ def main():
             st.video(input_video_path)  # Afficher la vidéo d'entrée
             
             if st.button("▶️ Lancer la détection"):
-                if len(poly1) == 4 and len(poly2) == 4:
+                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
-                    processor = YOLOVideoProcessor(model_path, input_video_path, output_video_path, poly1, poly2, tracker_method)
+                    # 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(progress_bar=progress_bar)
+                    count1, count2 = processor.process_video(input_video_path, output_video_path, progress_bar=progress_bar)
                     end_time = time.time()
                     
                     # Calcul du temps de traitement
@@ -214,5 +429,106 @@ def main():
                 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")
+        
+        # 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, 5):  # Essayer de détecter jusqu'à 5 caméras
+            try:
+                cap = cv2.VideoCapture(i)
+                if cap.isOpened():
+                    camera_options[f"Caméra {i}"] = i
+                cap.release()
+            except:
+                pass
+                
+        selected_camera = st.selectbox("Sélectionnez la source vidéo", list(camera_options.keys()))
+        camera_id = camera_options[selected_camera]
+        
+        # Affichage des placeholders
+        video_placeholder = st.empty()
+        col1, col2 = st.columns(2)
+        count_placeholders = [col1.empty(), col2.empty()]
+        
+        # Nouvelle section pour la prévisualisation
+        st.subheader("1️⃣ Prévisualisation de la vidéo")
+        preview_col1, preview_col2 = st.columns(2)
+        
+        with preview_col1:
+            if st.button("👁️ Afficher la prévisualisation"):
+                # Arrêter la détection si elle est active
+                if st.session_state.webcam_active:
+                    st.session_state.processor.stop_processing = True
+                    st.session_state.webcam_active = False
+                    time.sleep(0.5)  # Attendre que le thread se termine
+                
+                # Démarrer la prévisualisation
+                if not st.session_state.preview_active:
+                    st.session_state.preview_active = True
+                    # Démarrer la prévisualisation dans un thread séparé
+                    st.session_state.preview_thread = threading.Thread(
+                        target=display_webcam_preview,
+                        args=(camera_id, video_placeholder, poly1, poly2)
+                    )
+                    st.session_state.preview_thread.daemon = True
+                    st.session_state.preview_thread.start()
+                    
+        with preview_col2:
+            if st.button("⏹️ Arrêter la prévisualisation"):
+                st.session_state.preview_active = False
+                time.sleep(0.5)  # Attendre que le thread se termine
+                video_placeholder.empty()  # Effacer l'affichage vidéo
+                
+        # 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"):
+                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_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=st.session_state.processor.process_webcam,
+                        args=(camera_id, video_placeholder, count_placeholders)
+                    )
+                    processing_thread.daemon = True
+                    processing_thread.start()
+                
+        with detect_col2:
+            if st.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
+                    time.sleep(0.5)  # Attendre que le thread se termine
+                    video_placeholder.empty()  # Effacer l'affichage vidéo
+                else:
+                    st.warning("⚠️ Aucune détection en cours !")
+
 if __name__ == "__main__":
     main()