Update app.py

app.py

@@ -1,571 +1,550 @@
-import streamlit as st
-import cv2
 import os
 import time
-import numpy as np
-from ultralytics import YOLO
 import threading
+import queue
+
+import cv2
+import numpy as np
 from PIL import Image
+
+import streamlit as st
+from ultralytics import YOLO
 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,
-                              font_scale=1, font_thickness=2, text_color=(255, 255, 255), bg_color=(0, 0, 0), padding=5):
+# add_script_run_ctx peut ne pas exister selon la version de Streamlit ;
+# on le rend optionnel pour éviter un crash au démarrage.
+try:
+    from streamlit.runtime.scriptrunner import add_script_run_ctx
+except Exception:  # pragma: no cover
+    def add_script_run_ctx(_t):  # fallback no-op
+        return _t
+
+
+# =========================
+# === 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_size, _ = cv2.getTextSize(text, font, font_scale, font_thickness)
     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)
+    # Sécuriser les bornes d'affichage
+    tl_x = max(0, x)
+    tl_y = max(0, y - text_height - padding)
+    br_x = min(image.shape[1] - 1, x + text_width + padding * 2)
+    br_y = min(image.shape[0] - 1, 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)
+    cv2.rectangle(image, (tl_x, tl_y), (br_x, br_y), bg_color, -1)
+    cv2.putText(
+        image,
+        text,
+        (tl_x + padding, min(y, image.shape[0] - 1)),
+        font,
+        font_scale,
+        text_color,
+        font_thickness,
+        cv2.LINE_AA,
+    )
 
-def check_camera_availability():
-    """Fonction de diagnostic pour vérifier les caméras disponibles"""
-    available_cameras = []
-    for i in range(10):  # Vérifier les 10 premiers indices de caméra
+
+def check_camera_availability(max_idx=10):
+    """Diagnostic rapide pour lister des webcams locales disponibles."""
+    available = []
+    for i in range(max_idx):
         cap = cv2.VideoCapture(i)
         if cap.isOpened():
-            ret, frame = cap.read()
+            ret, _ = cap.read()
             if ret:
-                available_cameras.append(i)
-            cap.release()
-    
-    return available_cameras
+                available.append(i)
+        cap.release()
+    return available
+
+
+def _alpha_fill_poly(base_img, pts, color_bgr=(0, 255, 0), alpha=0.25, thickness=2):
+    """
+    Dessine un polygone 'transparent' en copiant sur overlay puis en blend.
+    OpenCV ne supporte pas l'alpha directement dans cv2.fillPoly.
+    """
+    overlay = base_img.copy()
+    pts_np = np.array(pts, np.int32)
+
+    cv2.fillPoly(overlay, [pts_np], color_bgr)
+    cv2.addWeighted(overlay, alpha, base_img, 1 - alpha, 0, dst=base_img)
+    cv2.polylines(base_img, [pts_np], isClosed=True, color=color_bgr, thickness=thickness)
+
 
 def preview_polygons(poly1, poly2):
-    """Crée une prévisualisation des polygones sur une image vide"""
-    # Créer une image noire de taille standard
-    preview_img = np.zeros((640, 1200, 3), dtype=np.uint8)
-    
-    # Dessiner le polygone 1 en vert
+    """Crée une prévisualisation des polygones sur une image noire."""
+    preview = np.zeros((640, 1200, 3), dtype=np.uint8)
+
+    # Zone 1 (vert)
     if len(poly1) >= 3:
-        cv2.polylines(preview_img, [np.array(poly1, np.int32)], isClosed=True, color=(0, 255, 0), thickness=2)
-        cv2.fillPoly(preview_img, [np.array(poly1, np.int32)], color=(0, 255, 0, 0.3))
-        
-        # Ajouter des points et des annotations
-        for i, point in enumerate(poly1):
-            cv2.circle(preview_img, point, 5, (255, 255, 255), -1)
-            draw_text_with_background(preview_img, f"P1-{i+1}: {point}", 
-                                    (point[0] + 10, point[1]), font_scale=0.5, bg_color=(0, 100, 0))
-    
-    # Dessiner le polygone 2 en rouge
+        _alpha_fill_poly(preview, poly1, (0, 200, 0), alpha=0.25)
+        for i, pt in enumerate(poly1):
+            cv2.circle(preview, pt, 5, (255, 255, 255), -1)
+            draw_text_with_background(
+                preview, f"P1-{i+1}: {pt}", (pt[0] + 10, pt[1]), font_scale=0.5, bg_color=(0, 100, 0)
+            )
+
+    # Zone 2 (rouge)
     if len(poly2) >= 3:
-        cv2.polylines(preview_img, [np.array(poly2, np.int32)], isClosed=True, color=(0, 0, 255), thickness=2)
-        cv2.fillPoly(preview_img, [np.array(poly2, np.int32)], color=(0, 0, 255, 0.3))
-        
-        # Ajouter des points et des annotations
-        for i, point in enumerate(poly2):
-            cv2.circle(preview_img, point, 5, (255, 255, 255), -1)
-            draw_text_with_background(preview_img, f"P2-{i+1}: {point}", 
-                                    (point[0] + 10, point[1]), font_scale=0.5, bg_color=(100, 0, 0))
-    
-    # Ajouter une légende
-    draw_text_with_background(preview_img, "Zone 1 (Vert)", (10, 30), font_scale=0.7, bg_color=(0, 100, 0))
-    draw_text_with_background(preview_img, "Zone 2 (Rouge)", (10, 60), font_scale=0.7, bg_color=(100, 0, 0))
-    
-    # Dessiner une grille pour aider à positionner
+        _alpha_fill_poly(preview, poly2, (0, 0, 200), alpha=0.25)
+        for i, pt in enumerate(poly2):
+            cv2.circle(preview, pt, 5, (255, 255, 255), -1)
+            draw_text_with_background(
+                preview, f"P2-{i+1}: {pt}", (pt[0] + 10, pt[1]), font_scale=0.5, bg_color=(100, 0, 0)
+            )
+
+    draw_text_with_background(preview, "Zone 1 (Vert)", (10, 30), font_scale=0.7, bg_color=(0, 100, 0))
+    draw_text_with_background(preview, "Zone 2 (Rouge)", (10, 60), font_scale=0.7, bg_color=(100, 0, 0))
+
+    # Grille
     grid_spacing = 100
     grid_color = (50, 50, 50)
-    
-    for x in range(0, preview_img.shape[1], grid_spacing):
-        cv2.line(preview_img, (x, 0), (x, preview_img.shape[0]), grid_color, 1)
-        # Ajouter le numéro de coordonnée X
-        draw_text_with_background(preview_img, str(x), (x, 20), font_scale=0.5, bg_color=(30, 30, 30))
-    
-    for y in range(0, preview_img.shape[0], grid_spacing):
-        cv2.line(preview_img, (0, y), (preview_img.shape[1], y), grid_color, 1)
-        # Ajouter le numéro de coordonnée Y
-        draw_text_with_background(preview_img, str(y), (5, y), font_scale=0.5, bg_color=(30, 30, 30))
-    
-    return preview_img
-
-# --- CLASSE YOLO OPTIMISÉE ---
+    for x in range(0, preview.shape[1], grid_spacing):
+        cv2.line(preview, (x, 0), (x, preview.shape[0]), grid_color, 1)
+        draw_text_with_background(preview, str(x), (x, 20), font_scale=0.5, bg_color=(30, 30, 30))
+    for y in range(0, preview.shape[0], grid_spacing):
+        cv2.line(preview, (0, y), (preview.shape[1], y), grid_color, 1)
+        draw_text_with_background(preview, str(y), (5, y), font_scale=0.5, bg_color=(30, 30, 30))
+
+    return preview
+
+
+# ================================
+# === CLASSE TRAITEMENT YOLOv8 ===
+# ================================
 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'
-            
-        # 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")
+        # Device
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # Paramètres par défaut (écrasés par l'UI ensuite)
+        self.frame_skip = 2
+        self.downsample_factor = 0.5
+        self.img_size = 640
+        self.conf_threshold = 0.35
+
+        # Chargement modèle
+        self.model = YOLO(model_path)  # 'task' n'est pas requis
         self.model.to(self.device)
-        
-        # Autres paramètres
+
+        # Tracking
         self.tracker_method = tracker_method
+        self.tracker_config = "botsort.yaml" if tracker_method.lower() == "bot" else "bytetrack.yaml"
+
+        # Compteurs d'IDs uniques par zone
         self.unique_region1_ids = set()
         self.unique_region2_ids = set()
+
+        # Polygones
         self.poly1 = poly1
         self.poly2 = poly2
+
+        # Threads/queues
         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):
+    @staticmethod
+    def is_in_region(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()
+        self.unique_region1_ids.clear()
+        self.unique_region2_ids.clear()
 
     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]
+
+        # Downscale contrôlé
+        orig_h, orig_w = frame.shape[:2]
+        resized_w = orig_w
+        resized_h = orig_h
         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)
+            resized_w = max(1, int(orig_w * self.downsample_factor))
+            resized_h = max(1, int(orig_h * self.downsample_factor))
+            resized_frame = cv2.resize(frame, (resized_w, resized_h), 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
+
+        # Inference + tracking
+        with torch.no_grad():
             results = self.model.track(
-                resized_frame, 
-                persist=True, 
-                tracker=self.tracker_config, 
+                resized_frame,
+                persist=True,
+                tracker=self.tracker_config,
                 conf=self.conf_threshold,
-                imgsz=self.img_size
+                imgsz=self.img_size,
+                device=self.device,
             )
 
-        # 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)
+        display = frame.copy()
 
-        # 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
+        # Dessiner polygones (transparent)
+        _alpha_fill_poly(display, self.poly1, (0, 200, 0), alpha=0.2, thickness=2)
+        _alpha_fill_poly(display, self.poly2, (0, 0, 200), alpha=0.2, thickness=2)
 
-        track_ids = []
-        if results and len(results) > 0 and len(results[0].boxes) > 0:
+        # Mise à l'échelle des boxes vers la taille originale
+        sx = orig_w / float(resized_w)
+        sy = orig_h / float(resized_h)
+
+        if results and len(results) > 0 and getattr(results[0], "boxes", None) is not None:
             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
+                boxes_xywh = results[0].boxes.xywh.cpu().numpy()
+                # track ids peuvent être None sur la première frame
+                ids_tensor = results[0].boxes.id
+                track_ids = ids_tensor.int().cpu().tolist() if ids_tensor is not None else [None] * len(boxes_xywh)
+
+                for (x, y, w, h), tid in zip(boxes_xywh, track_ids):
+                    # centre + bbox rescalés
+                    cx = int(x * sx)
+                    cy = int(y * sy)
+                    ww = int(w * sx)
+                    hh = int(h * sy)
 
-        # 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))
+                    # Comptage par centre de la bbox
+                    if tid is not None:
+                        if self.is_in_region((cx, cy), self.poly1):
+                            self.unique_region1_ids.add(tid)
+                        if self.is_in_region((cx, cy), self.poly2):
+                            self.unique_region2_ids.add(tid)
 
-        return display_frame
+                    # Dessin bbox
+                    tl = (max(0, cx - ww // 2), max(0, cy - hh // 2))
+                    br = (min(display.shape[1] - 1, cx + ww // 2), min(display.shape[0] - 1, cy + hh // 2))
+                    cv2.rectangle(display, tl, br, (0, 255, 0), 2)
+
+            except Exception as e:
+                # On ne casse pas l'affichage si une frame pose problème
+                draw_text_with_background(display, f"Tracking error: {e}", (10, 60), bg_color=(80, 0, 0))
+
+        # Affichage compteurs
+        h, w = display.shape[:2]
+        draw_text_with_background(display, f"Total Sens 1: {len(self.unique_region1_ids)}", (10, h - 50))
+        draw_text_with_background(display, f"Total Sens 2: {len(self.unique_region2_ids)}", (w - 300, h - 50))
+
+        return display
 
     def process_webcam_frames(self):
-        """Thread de traitement qui analyse les frames et les met en file d'attente"""
+        """Thread de traitement : lit les frames de frame_queue, pousse résultats dans result_queue."""
         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()
-                
+                frame = self.frame_queue.get(timeout=0.5)
             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
+                continue
+
+            start = time.time()
+            processed = self.process_frame(frame)
+            fps = 1.0 / max(1e-6, (time.time() - start))
+
+            if processed is not None:
+                draw_text_with_background(processed, f"FPS: {fps:.1f}", (10, 30))
+
+            # Remplacer l'ancien résultat si plein
+            try:
+                if self.result_queue.full():
+                    _ = self.result_queue.get_nowait()
+                self.result_queue.put_nowait(
+                    (processed, len(self.unique_region1_ids), len(self.unique_region2_ids))
+                )
+            except queue.Full:
+                pass
+            finally:
+                self.frame_queue.task_done()
 
     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"""
-        # Essayer différentes méthodes d'initialisation de la webcam
+        """Capture en direct avec multi-threading et rendu dans Streamlit."""
         cap = None
-        backends_to_try = [
-            cv2.CAP_ANY,         # Essayer le backend par défaut d'abord
-            cv2.CAP_DSHOW,       # DirectShow (Windows)
-            cv2.CAP_MSMF,        # Media Foundation (Windows)
-            cv2.CAP_V4L2,        # Video4Linux (Linux)
-            cv2.CAP_AVFOUNDATION # AVFoundation (macOS)
+        backends = [
+            cv2.CAP_ANY,
+            getattr(cv2, "CAP_DSHOW", cv2.CAP_ANY),
+            getattr(cv2, "CAP_MSMF", cv2.CAP_ANY),
+            getattr(cv2, "CAP_V4L2", cv2.CAP_ANY),
+            getattr(cv2, "CAP_AVFOUNDATION", cv2.CAP_ANY),
         ]
-        
-        for backend in backends_to_try:
+
+        # Ouverture
+        for backend in backends:
             try:
                 cap = cv2.VideoCapture(camera_id, backend)
                 if cap.isOpened():
                     if display_placeholder:
-                        display_placeholder.success(f"✅ Webcam connectée avec succès (backend: {backend})")
+                        display_placeholder.success(f"✅ Webcam connectée (backend: {backend})")
                     break
             except Exception as e:
                 if display_placeholder:
-                    display_placeholder.warning(f"Échec avec backend {backend}: {e}")
-                continue
-        
-        # Si aucun backend n'a fonctionné, essayer une dernière fois sans spécifier de backend
+                    display_placeholder.warning(f"Backend {backend} échec: {e}")
+
         if cap is None or not cap.isOpened():
-            try:
-                cap = cv2.VideoCapture(camera_id)
-            except Exception as e:
-                if display_placeholder:
-                    display_placeholder.error(f"Erreur finale: {e}")
-        
-        # Vérifier si la caméra est ouverte
+            # Dernière chance sans backend explicite
+            cap = cv2.VideoCapture(camera_id)
+
         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.")
+                display_placeholder.error("⚠️ Impossible d'ouvrir la source vidéo.")
             return
-        
-        # Configuration de la webcam pour de meilleures performances (avec gestion d'erreurs)
+
+        # Paramètres caméra (best-effort)
         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
+        except Exception:
             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
+                display_placeholder.warning("⚠️ Impossible de régler certains paramètres caméra.")
+
+        # Reset état 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
-        
+
+        # Thread de traitement
+        t = threading.Thread(target=self.process_webcam_frames, daemon=True)
         try:
-            # Attendre un peu pour que la webcam s'initialise
-            time.sleep(0.5)
-            
-            # Essayer de lire le premier frame pour s'assurer que la caméra fonctionne
-            success, first_frame = cap.read()
-            if not success:
-                if display_placeholder:
-                    display_placeholder.error("⚠️ Impossible de lire les images de la webcam. Vérifiez votre caméra et ses permissions.")
-                return
-            
-            # Afficher ce premier frame pour montrer que la connexion fonctionne
+            add_script_run_ctx(t)
+        except Exception:
+            pass
+        t.start()
+
+        # Premier frame pour valider
+        time.sleep(0.3)
+        ok, first = cap.read()
+        if not ok:
             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
+                display_placeholder.error("⚠️ Lecture impossible depuis la webcam (permissions ?).")
+            self.stop_processing = True
+            cap.release()
+            t.join(timeout=1.0)
+            return
+
+        if display_placeholder is not None:
+            display_placeholder.image(cv2.cvtColor(first, cv2.COLOR_BGR2RGB), channels="RGB", use_column_width=True,
+                                      caption="Webcam connectée !")
+
+        ui_update_interval = 0.03  # ~30 FPS
+        last_ui = 0.0
+        frame_idx = 0
+
+        try:
             while not self.stop_processing:
-                success, frame = cap.read()
-                if not success:
-                    # Essayer de reconnecter en cas d'erreur
-                    time.sleep(0.1)
+                ok, frame = cap.read()
+                if not ok:
+                    time.sleep(0.05)
                     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
+
+                # Envoi au thread de traitement (skip pour alléger)
+                if frame_idx % self.frame_skip == 0:
                     try:
-                        self.frame_queue.put(frame, block=False)
+                        if self.frame_queue.full():
+                            _ = self.frame_queue.get_nowait()
+                            self.frame_queue.task_done()
+                        self.frame_queue.put_nowait(frame)
                     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:
+                        pass
+
+                # Affichage si résultat dispo
+                now = time.time()
+                if now - last_ui >= 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
+                        processed, c1, c2 = self.result_queue.get_nowait()
+                        if processed is not None and display_placeholder is not None:
+                            rgb = cv2.cvtColor(processed, cv2.COLOR_BGR2RGB)
+                            display_placeholder.image(Image.fromarray(rgb), channels="RGB", use_column_width=True)
+                        if count_placeholders and len(count_placeholders) >= 2:
+                            count_placeholders[0].metric("Véhicules Sens 1 (Vert)", c1)
+                            count_placeholders[1].metric("Véhicules Sens 2 (Rouge)", c2)
                     except queue.Empty:
                         pass
-                    except Exception as e:
-                        if display_placeholder:
-                            display_placeholder.warning(f"Erreur lors de l'affichage: {e}")
-                
-                frame_count += 1
-                
-                # Pause légère pour éviter d'utiliser 100% du CPU
+                    last_ui = now
+
+                frame_idx += 1
                 time.sleep(0.001)
-                
+
         except Exception as e:
             if display_placeholder:
-                display_placeholder.error(f"Erreur dans la boucle principale: {e}")
+                display_placeholder.error(f"Erreur 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)
+            t.join(timeout=1.0)
             if display_placeholder:
                 display_placeholder.success("✅ Flux vidéo arrêté.")
 
 
-# --- INTERFACE STREAMLIT ---
+# ==========================
+# === INTERFACE STREAMLIT ===
+# ==========================
 def main():
     st.set_page_config(
         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"}
+        menu_items={"About": "Détection de véhicules avec YOLOv8"},
     )
-    
+
     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:
-        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é
+
+    # Session state
+    st.session_state.setdefault("webcam_active", False)
+    st.session_state.setdefault("processor", None)
+    st.session_state.setdefault("processing_thread", None)
+
+    # Chargement du modèle
     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
+        with st.spinner("📥 Téléchargement du modèle YOLO…"):
             try:
                 from huggingface_hub import hf_hub_download
-                model_path = hf_hub_download(repo_id="ModuMLTECH/projet_comptage_avance", filename="best.pt")
-                st.success("✅ Modèle chargé avec succès!")
+
+                model_path = hf_hub_download(
+                    repo_id="ModuMLTECH/projet_comptage_avance",
+                    filename="best.pt",
+                )
+                st.success("✅ Modèle chargé depuis Hugging Face Hub.")
             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")
+                st.error(f"❌ Erreur chargement modèle: {e}")
+                st.warning("⚠️ Fallback sur un modèle YOLO public (yolov8n.pt).")
                 model_path = "yolov8n.pt"
-    
-    # Paramètres dans la barre latérale
+
+    # === SIDEBAR ===
     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)
+
+        st.subheader("🚀 Optimisation")
+        frame_skip = st.slider("Skip de frames", 1, 5, 2)
+        downsample = st.slider("Facteur d'échelle", 0.3, 1.0, 0.5, 0.1)
         conf_threshold = st.slider("Seuil de confiance", 0.1, 0.9, 0.35, 0.05)
-        
-        # Informations système
-        st.subheader("💻 Informations système")
+
+        st.subheader("💻 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):
+
+    def parse_polygon(txt):
         try:
-            return [tuple(map(int, point.split(','))) for point in input_text.split()]
-        except:
+            pts = []
+            for token in txt.replace(";", " ").split():
+                x, y = token.split(",")
+                pts.append((int(x), int(y)))
+            return pts
+        except Exception:
             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
-    
-    # --- PRÉVISUALISATION DES MASQUES ---
+
+    # Prévisualisation
     st.header("🖼️ Prévisualisation des masques")
-    
     if valid_polygons:
-        preview_image = preview_polygons(poly1, poly2)
-        preview_image_rgb = cv2.cvtColor(preview_image, cv2.COLOR_BGR2RGB)
-        st.image(preview_image_rgb, use_column_width=True, caption="Prévisualisation des masques de détection")
-        st.success("✅ Les polygones sont correctement définis.")
+        prev = preview_polygons(poly1, poly2)
+        st.image(cv2.cvtColor(prev, cv2.COLOR_BGR2RGB), use_column_width=True, caption="Masques de détection")
+        st.success("✅ Polygones valides (4 points chacun).")
     else:
-        st.warning("⚠️ Veuillez définir des polygones valides avec exactement 4 points chacun.")
+        st.warning("⚠️ Définissez deux polygones valides de 4 points chacun.")
 
-    # Section principale de la détection en temps réel
+    # Section webcam
     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.")
+
+    available = check_camera_availability()
+    if not available:
+        st.warning("⚠️ Aucune caméra locale détectée (vous pouvez tester une caméra IP).")
     else:
-        st.success(f"✅ Caméras détectées aux indices: {available_cameras}")
-    
-    # Méthode améliorée de sélection de caméra
+        st.success(f"✅ Caméras détectées: {available}")
+
     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
+    for i in range(1, 8):
         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
+
+    selected = st.selectbox("Source vidéo", list(camera_options.keys()))
+    if camera_options[selected] == "ip":
+        camera_id = st.text_input("URL RTSP/HTTP", "http://adresse-ip:port/video")
     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
+        camera_id = camera_options[selected]
+
+    display_quality = st.select_slider("Qualité d'affichage", options=["Basse", "Moyenne", "Haute"], value="Moyenne")
+    # (placeholder pour gérer des resize/qualité plus tard si besoin)
+
     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
+    col1, col2 = st.columns(2)
+    count_placeholders = [col1.empty(), col2.empty()]
+
+    st.info("ℹ️ Optimisations: multi-threading, resize adaptatif, CUDA si dispo.")
+
     col_start, col_stop = st.columns(2)
-    
-    if col_start.button("▶️ Démarrer la détection en direct"):
+
+    if col_start.button("▶️ Démarrer la détection"):
         if not valid_polygons:
-            st.error("❌ Les coordonnées des polygones doivent contenir **exactement 4 points**.")
+            st.error("❌ Les polygones doivent avoir exactement 4 points chacun.")
         elif st.session_state.webcam_active:
-            st.warning("⚠️ La webcam est déjà 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
+            video_placeholder.info("🔄 Connexion à la source vidéo…")
+
             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(
+
+            thread = threading.Thread(
                 target=st.session_state.processor.process_webcam,
-                args=(camera_id, video_placeholder, count_placeholders)
+                args=(camera_id, video_placeholder, count_placeholders),
+                daemon=True,
             )
-            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
+                add_script_run_ctx(thread)
+            except Exception:
+                pass
+
+            try:
+                thread.start()
+                st.session_state.processing_thread = 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 col_stop.button("⏹️ Arrêter"):
         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()
+
+            time.sleep(0.3)
+            video_placeholder.empty()
+            for ph in count_placeholders:
+                ph.empty()
         else:
-            st.warning("⚠️ Aucune détection en cours !")
+            st.warning("⚠️ Aucune détection en cours.")
 
 if __name__ == "__main__":
     main()