Update app.py

app.py

@@ -9,13 +9,6 @@ import threading
 from PIL import Image
 import torch
 
-# ---- Contexte Streamlit pour threads (safe fallback) ----
-try:
-    from streamlit.runtime.scriptrunner import add_script_run_ctx
-except Exception:
-    def add_script_run_ctx(t):
-        return t
-
 # --- FONCTIONS UTILES ---
 def draw_text_with_background(
     image,
@@ -56,10 +49,10 @@ class YOLOVideoProcessor:
         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
+        self.frame_skip = 2
+        self.downsample_factor = 0.5
         self.img_size = 640
-        self.conf_threshold = 0.5   # plus strict par défaut
+        self.conf_threshold = 0.35
 
         # Modèle
         self.model = YOLO(model_path)
@@ -78,19 +71,24 @@ class YOLOVideoProcessor:
         self.last_processed_frame = None
         self.current_frame = 0
 
-        # Filtres anti-roues (valeurs relatives à l'image d'affichage)
-        self.min_w_ratio = 0.04     # largeur >= 4% de la largeur du frame
-        self.min_h_ratio = 0.05     # hauteur >= 5% de la hauteur du frame
-        self.min_area_ratio = 0.0025  # aire >= 0.25% de l'aire du frame
+        # Paramètres anti-duplicata pour camions longs
+        self.iou_threshold = 0.3  # Seuil IoU pour fusionner les détections proches
+        self.min_box_area = 500   # Surface minimale pour être considéré comme véhicule
+        self.max_aspect_ratio = 5.0  # Ratio hauteur/largeur max pour éviter détections étirées
+        
+        # Historique des détections pour filtrage temporel
+        self.detection_history = {}  # {track_id: {'boxes': [], 'frames': []}}
+        self.history_length = 5  # Nombre de frames à garder en mémoire
 
     @staticmethod
-    def is_in_region(point, poly):
+    def is_in_region(center, poly):
         poly_np = np.array(poly, dtype=np.int32)
-        return cv2.pointPolygonTest(poly_np, point, False) >= 0
+        return cv2.pointPolygonTest(poly_np, center, False) >= 0
 
     def reset_counts(self):
         self.unique_region1_ids.clear()
         self.unique_region2_ids.clear()
+        self.detection_history.clear()
 
     def _pick_fourcc(self, output_path):
         ext = os.path.splitext(output_path)[1].lower()
@@ -98,26 +96,117 @@ class YOLOVideoProcessor:
             return cv2.VideoWriter_fourcc(*"mp4v")
         return cv2.VideoWriter_fourcc(*"XVID")
 
-    # ---------- TRAITEMENT VIDEO (thread principal) ----------
-    def process_video(self, video_path, output_path, progress_bar=None, status_placeholder=None):
-        """Traite une vidéo enregistrée avec optimisations (aucun st.* ici)."""
+    def calculate_iou(self, box1, box2):
+        """Calcule l'IoU (Intersection over Union) entre deux boîtes"""
+        x1_min, y1_min, x1_max, y1_max = box1
+        x2_min, y2_min, x2_max, y2_max = box2
+        
+        # Intersection
+        inter_x_min = max(x1_min, x2_min)
+        inter_y_min = max(y1_min, y2_min)
+        inter_x_max = min(x1_max, x2_max)
+        inter_y_max = min(y1_max, y2_max)
+        
+        inter_area = max(0, inter_x_max - inter_x_min) * max(0, inter_y_max - inter_y_min)
+        
+        # Union
+        box1_area = (x1_max - x1_min) * (y1_max - y1_min)
+        box2_area = (x2_max - x2_min) * (y2_max - y2_min)
+        union_area = box1_area + box2_area - inter_area
+        
+        if union_area == 0:
+            return 0
+        
+        return inter_area / union_area
+
+    def filter_overlapping_detections(self, boxes_coords, track_ids, confidences):
+        """Filtre les détections qui se chevauchent (ex: plusieurs détections sur un camion)"""
+        if len(boxes_coords) == 0:
+            return [], [], []
+        
+        # Créer une liste de détections avec leurs indices
+        detections = []
+        for i, (box, tid, conf) in enumerate(zip(boxes_coords, track_ids, confidences)):
+            x_min, y_min, x_max, y_max = box
+            area = (x_max - x_min) * (y_max - y_min)
+            aspect_ratio = (y_max - y_min) / max(1, x_max - x_min)
+            
+            # Filtrer les détections trop petites ou avec un aspect ratio bizarre
+            if area < self.min_box_area or aspect_ratio > self.max_aspect_ratio:
+                continue
+                
+            detections.append({
+                'index': i,
+                'box': box,
+                'track_id': tid,
+                'conf': conf,
+                'area': area
+            })
+        
+        # Trier par confiance décroissante
+        detections.sort(key=lambda x: x['conf'], reverse=True)
+        
+        # Non-Maximum Suppression manuel
+        keep_indices = []
+        while len(detections) > 0:
+            # Garder la détection avec la plus haute confiance
+            best = detections.pop(0)
+            keep_indices.append(best['index'])
+            
+            # Supprimer les détections qui se chevauchent trop avec la meilleure
+            filtered_detections = []
+            for det in detections:
+                iou = self.calculate_iou(best['box'], det['box'])
+                if iou < self.iou_threshold:  # Garder si IoU faible (pas de chevauchement)
+                    filtered_detections.append(det)
+            
+            detections = filtered_detections
+        
+        # Retourner les détections filtrées
+        filtered_boxes = [boxes_coords[i] for i in keep_indices]
+        filtered_ids = [track_ids[i] for i in keep_indices]
+        filtered_confs = [confidences[i] for i in keep_indices]
+        
+        return filtered_boxes, filtered_ids, filtered_confs
+
+    def update_detection_history(self, track_id, box, frame_num):
+        """Met à jour l'historique des détections pour un véhicule"""
+        if track_id not in self.detection_history:
+            self.detection_history[track_id] = {'boxes': [], 'frames': []}
+        
+        self.detection_history[track_id]['boxes'].append(box)
+        self.detection_history[track_id]['frames'].append(frame_num)
+        
+        # Garder seulement les N dernières frames
+        if len(self.detection_history[track_id]['boxes']) > self.history_length:
+            self.detection_history[track_id]['boxes'].pop(0)
+            self.detection_history[track_id]['frames'].pop(0)
+
+    def is_stable_detection(self, track_id):
+        """Vérifie si une détection est stable (pas un faux positif temporaire)"""
+        if track_id not in self.detection_history:
+            return False
+        
+        # Considérer stable si détecté sur au moins 3 frames
+        return len(self.detection_history[track_id]['boxes']) >= 3
+
+    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():
-            if status_placeholder:
-                status_placeholder.error("⚠️ Impossible d'ouvrir la vidéo.")
+            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 = cap.get(cv2.CAP_PROP_FPS)
         if not fps or fps <= 1e-3:
-            fps = 30.0  # défaut
+            fps = 30.0
 
         fourcc = self._pick_fourcc(output_path)
         out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
         if not out.isOpened():
-            if status_placeholder:
-                status_placeholder.error("⚠️ Impossible d'ouvrir la vidéo de sortie (codec).")
+            st.error("⚠️ Erreur : Impossible d'ouvrir la vidéo de sortie (codec).")
             cap.release()
             return
 
@@ -131,11 +220,14 @@ class YOLOVideoProcessor:
             if not success:
                 break
 
+            # Progression
             if progress_bar is not None and total_frames > 0:
-                progress_bar.progress(min(1.0, processed_frames / float(total_frames)))
+                progress = min(1.0, processed_frames / float(total_frames))
+                progress_bar.progress(progress)
 
+            # Skip de frames
             if frame_count % self.frame_skip == 0:
-                processed_frame = self.process_frame(frame)
+                processed_frame = self.process_frame(frame, frame_count)
                 self.last_processed_frame = processed_frame
             else:
                 processed_frame = self.last_processed_frame if self.last_processed_frame is not None else frame
@@ -143,6 +235,7 @@ class YOLOVideoProcessor:
             if processed_frame is None:
                 processed_frame = frame
 
+            # S'assurer de la taille attendue
             if processed_frame.shape[1] != frame_width or processed_frame.shape[0] != frame_height:
                 processed_frame = cv2.resize(processed_frame, (frame_width, frame_height), interpolation=cv2.INTER_AREA)
 
@@ -154,101 +247,122 @@ class YOLOVideoProcessor:
         out.release()
         cv2.destroyAllWindows()
 
-        if processed_frames == 0 and status_placeholder:
-            status_placeholder.error("⚠️ Aucune image n'a été écrite dans la vidéo de sortie !")
+        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)
 
-    # ---------- TRAITEMENT PAR IMAGE ----------
-    def process_frame(self, frame):
-        """Traite une image individuelle avec YOLO + tracking, optimisé et filtré anti-roues."""
+    def process_frame(self, frame, frame_num=0):
+        """Traite une image individuelle avec YOLO et le tracking, avec filtrage anti-duplicata"""
         if frame is None:
             return None
 
-        # Downscale pour accélérer
-        orig_h, orig_w = frame.shape[:2]
-        resized_w, resized_h = orig_w, orig_h
+        # Redimensionner l'image pour accélérer le traitement
+        orig_height, orig_width = frame.shape[:2]
+        resized_width, resized_height = orig_width, orig_height
         if self.downsample_factor < 1.0:
-            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)
+            resized_width = max(1, int(orig_width * self.downsample_factor))
+            resized_height = max(1, int(orig_height * self.downsample_factor))
+            resized_frame = cv2.resize(frame, (resized_width, resized_height), interpolation=cv2.INTER_AREA)
         else:
             resized_frame = frame
 
-        # Détection + tracking (avec classes & iou)
+        # Détection + tracking
         with torch.no_grad():
             results = self.model.track(
                 resized_frame,
                 persist=True,
                 tracker=self.tracker_config,
                 conf=self.conf_threshold,
-                iou=0.5,
                 imgsz=self.img_size,
                 device=self.device,
-                classes=[2, 3, 5, 7],  # voitures, motos, bus, camions (COCO)
+                classes=[2, 5, 7],  # COCO: 2=car, 5=bus, 7=truck (évite autres objets)
+                verbose=False
             )
 
-        display = frame.copy()
-        H, W = display.shape[:2]
-
-        # Polylines
-        cv2.polylines(display, [np.array(self.poly1, np.int32)], isClosed=True, color=(0, 255, 0), thickness=2)
-        cv2.polylines(display, [np.array(self.poly2, np.int32)], isClosed=True, color=(255, 0, 0), thickness=2)
+        display_frame = frame.copy()
+        frame_height, frame_width = display_frame.shape[:2]
 
-        # Échelle vers taille originale
-        sx = orig_w / float(resized_w)
-        sy = orig_h / float(resized_h)
+        # 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)
 
-        # Seuils anti-roues (relatifs à l'image d'affichage)
-        min_w = int(self.min_w_ratio * W)
-        min_h = int(self.min_h_ratio * H)
-        min_area = int(self.min_area_ratio * W * H)
+        # Échelle pour remonter aux coords originales
+        scale_x = orig_width / float(resized_width)
+        scale_y = orig_height / float(resized_height)
 
         if results and len(results) > 0 and getattr(results[0], "boxes", None) is not None:
             try:
                 boxes = results[0].boxes.xywh.cpu().numpy()
                 ids_tensor = results[0].boxes.id
-                track_ids = ([None] * len(boxes)) if ids_tensor is None else ids_tensor.int().cpu().tolist()
-
-                for (x, y, w, h), tid in zip(boxes, track_ids):
-                    # Rescale
-                    cx = int(x * sx)
-                    cy = int(y * sy)
-                    ww = int(w * sx)
-                    hh = int(h * sy)
+                confs = results[0].boxes.conf.cpu().numpy()
+                
+                if ids_tensor is None:
+                    track_ids = [None] * len(boxes)
+                else:
+                    track_ids = ids_tensor.int().cpu().tolist()
+
+                # Convertir les boîtes en format [x_min, y_min, x_max, y_max]
+                boxes_coords = []
+                for x, y, w, h in boxes:
+                    center_x = int(x * scale_x)
+                    center_y = int(y * scale_y)
+                    width = int(w * scale_x)
+                    height = int(h * scale_y)
+                    x_min = max(0, center_x - width // 2)
+                    y_min = max(0, center_y - height // 2)
+                    x_max = min(frame_width - 1, center_x + width // 2)
+                    y_max = min(frame_height - 1, center_y + height // 2)
+                    boxes_coords.append([x_min, y_min, x_max, y_max])
+
+                # Filtrer les détections qui se chevauchent
+                filtered_boxes, filtered_ids, filtered_confs = self.filter_overlapping_detections(
+                    boxes_coords, track_ids, confs
+                )
 
-                    # --- FILTRE TAILLE MIN (anti-roues) ---
-                    if ww < min_w or hh < min_h or (ww * hh) < min_area:
+                # Traiter les détections filtrées
+                for box, track_id, conf in zip(filtered_boxes, filtered_ids, filtered_confs):
+                    if track_id is None:
                         continue
-
-                    # Point de comptage : bas de la boîte (bottom-center)
-                    bottom_center = (cx, cy + hh // 2)
-
-                    if tid is not None:
-                        if self.is_in_region(bottom_center, self.poly1):
-                            self.unique_region1_ids.add(tid)
-                        if self.is_in_region(bottom_center, self.poly2):
-                            self.unique_region2_ids.add(tid)
-
-                    # Dessin bbox
-                    tl = (max(0, cx - ww // 2), max(0, cy - hh // 2))
-                    br = (min(W - 1, cx + ww // 2), min(H - 1, cy + hh // 2))
-                    cv2.rectangle(display, tl, br, (0, 255, 0), 2)
-
+                    
+                    x_min, y_min, x_max, y_max = box
+                    center_x = (x_min + x_max) // 2
+                    center_y = (y_min + y_max) // 2
+                    center_point = (center_x, center_y)
+                    
+                    # Mettre à jour l'historique
+                    self.update_detection_history(track_id, box, frame_num)
+                    
+                    # Compter seulement les détections stables
+                    if self.is_stable_detection(track_id):
+                        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)
+                    
+                    # Dessiner la boîte (vert si stable, jaune sinon)
+                    color = (0, 255, 0) if self.is_stable_detection(track_id) else (0, 255, 255)
+                    cv2.rectangle(display_frame, (x_min, y_min), (x_max, y_max), color, 2)
+                    
+                    # Afficher l'ID et la confiance
+                    label = f"ID:{track_id} {conf:.2f}"
+                    cv2.putText(display_frame, label, (x_min, y_min - 10),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+                    
             except Exception as e:
-                draw_text_with_background(display, f"Tracking error: {e}", (10, 60), bg_color=(80, 0, 0))
+                draw_text_with_background(display_frame, f"Tracking error: {e}", (10, 60), bg_color=(80, 0, 0))
 
-        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
+        # Affichage du comptage
+        # 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 comptes: {len(self.unique_region2_ids)}", (frame_width - 300, frame_height - 50))
 
-    # ---------- CAPTURE WEBCAM (thread secondaire, aucun st.*) ----------
-    def process_webcam(self, camera_id=0, display_placeholder=None, count_placeholders=None, status_placeholder=None):
-        """Traite la vidéo en temps réel depuis une webcam (aucun appel direct à streamlit dans ce thread)."""
+        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"""
         cap = cv2.VideoCapture(camera_id)
         if not cap.isOpened():
-            if status_placeholder:
-                status_placeholder.error("⚠️ Impossible d'ouvrir la webcam.")
+            st.error("⚠️ Erreur : Impossible d'ouvrir la webcam.")
             return
 
         try:
@@ -263,50 +377,43 @@ class YOLOVideoProcessor:
         frame_count = 0
         last_ts = time.time()
 
-        # Afficher une première image (pour signaler la connexion)
-        ok, first = cap.read()
-        if ok and display_placeholder:
-            try:
-                rgb0 = cv2.cvtColor(first, cv2.COLOR_BGR2RGB)
-            except Exception:
-                rgb0 = first
-            display_placeholder.image(Image.fromarray(rgb0), channels="RGB", use_column_width=True, caption="Webcam connectée")
-
         while not self.stop_processing:
             success, frame = cap.read()
             if not success:
-                if status_placeholder:
-                    status_placeholder.error("⚠️ Erreur lors de la lecture du flux vidéo.")
+                st.error("⚠️ Erreur lors de la lecture du flux vidéo.")
                 break
 
             if frame_count % self.frame_skip == 0:
-                processed = self.process_frame(frame)
-                self.last_processed_frame = processed
+                processed_frame = self.process_frame(frame, frame_count)
+                self.last_processed_frame = processed_frame
                 now = time.time()
-                fps = 1.0 / max(1e-6, (now - last_ts))
+                dt = max(1e-6, now - last_ts)
+                fps = 1.0 / dt
                 last_ts = now
-                if processed is not None:
-                    draw_text_with_background(processed, f"FPS: {fps:.1f}", (10, 30))
+                if processed_frame is not None:
+                    draw_text_with_background(processed_frame, f"FPS: {fps:.1f}", (10, 30))
             else:
-                processed = self.last_processed_frame if self.last_processed_frame is not None else frame
+                processed_frame = self.last_processed_frame if self.last_processed_frame is not None else frame
 
-            if processed is not None and display_placeholder:
+            if processed_frame is not None:
                 try:
-                    rgb = cv2.cvtColor(processed, cv2.COLOR_BGR2RGB)
+                    processed_frame_rgb = cv2.cvtColor(processed_frame, cv2.COLOR_BGR2RGB)
                 except Exception:
-                    rgb = processed
-                display_placeholder.image(Image.fromarray(rgb), channels="RGB", use_column_width=True)
+                    processed_frame_rgb = processed_frame
+                img = Image.fromarray(processed_frame_rgb)
+
+                if display_placeholder:
+                    display_placeholder.image(img, channels="RGB", use_column_width=True)
 
-            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))
+                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
             time.sleep(0.01)
 
         cap.release()
-        if status_placeholder:
-            status_placeholder.success("✅ Flux vidéo arrêté.")
+        st.success("✅ Flux vidéo arrêté.")
 
 
 # --- INTERFACE STREAMLIT ---
@@ -319,9 +426,9 @@ def main():
 
     st.title("🚗 Détection et comptage de Véhicules sur l'Autoroute de l'Avenir")
 
+    # Session state
     st.session_state.setdefault("webcam_active", False)
     st.session_state.setdefault("processor", None)
-    st.session_state.setdefault("processing_thread", None)
 
     # Modèle
     model_path = "best.pt"
@@ -345,15 +452,20 @@ def main():
 
         st.subheader("📍 Polygone 1 (vert)")
         poly1_input = st.text_area("Entrez 4 points (x,y) séparés par des espaces", "900,350 1150,350 700,630 200,630")
+
         st.subheader("📍 Polygone 2 (rouge)")
         poly2_input = st.text_area("Entrez 4 points (x,y) séparés par des espaces", "1200,350 1400,350 1150,630 743,630")
 
-        tracker_method = st.selectbox("Méthode de tracking", ["bot", "byte"], index=1)  # byte par défaut
+        tracker_method = st.selectbox("Méthode de tracking", ["bot", "byte"], index=0)
 
         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.5, 0.05)  # 0.5 par défaut
+        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)
+        
+        st.subheader("🔧 Anti-duplicata")
+        iou_thresh = st.slider("Seuil IoU (fusion détections)", 0.1, 0.9, 0.3, 0.05)
+        min_area = st.slider("Surface minimale (pixels²)", 100, 2000, 500, 100)
 
     def parse_polygon(input_text):
         try:
@@ -371,9 +483,7 @@ def main():
 
     # Onglet 1: Analyse vidéo
     with tab1:
-        uploaded_file = st.file_uploader("📂 Upload une vidéo", type=["mp4", "avi", "mov", "mkv"])
-        status_vid = st.empty()
-
+        uploaded_file = st.file_uploader("📂 Upload une vidéo", type=["mp4", "avi", "mkv", "mov"])
         if uploaded_file is not None:
             temp_dir = tempfile.mkdtemp()
             ext = os.path.splitext(uploaded_file.name)[1].lower() or ".mp4"
@@ -392,38 +502,37 @@ def main():
                     processor.frame_skip = frame_skip
                     processor.downsample_factor = downsample
                     processor.conf_threshold = conf_threshold
+                    processor.iou_threshold = iou_thresh
+                    processor.min_box_area = min_area
 
                     start_time = time.time()
-                    counts = processor.process_video(
-                        input_video_path, output_video_path,
-                        progress_bar=progress_bar,
-                        status_placeholder=status_vid
-                    )
+                    counts = processor.process_video(input_video_path, output_video_path, progress_bar=progress_bar)
                     end_time = time.time()
                     if counts:
-                        c1, c2 = counts
-                        st.success(f"✅ Terminé en {end_time - start_time:.2f} s")
+                        count1, count2 = counts
+                        st.success(f"✅ Traitement terminé en {end_time - start_time:.2f} s")
+
                         col_result1, col_result2 = st.columns(2)
-                        col_result1.metric("Véhicules Sens 1 (Vert)", c1)
-                        col_result2.metric("Véhicules Sens 2 (Rouge)", c2)
+                        col_result1.metric("Véhicules Sens 1 (Vert)", count1)
+                        col_result2.metric("Véhicules Sens 2 (Rouge)", count2)
 
                         st.subheader("Vidéo traitée")
                         st.video(output_video_path)
+
                         with open(output_video_path, "rb") as file:
                             st.download_button(
                                 label="⬇️ Télécharger la vidéo",
                                 data=file,
                                 file_name=f"video_traitee{ext}",
-                                mime=f"video/{ext.strip('.') or 'mp4'}",
+                                mime=f"video/{ext.strip('.')}",
                             )
                 else:
-                    st.error("❌ Les polygones doivent contenir **exactement 4 points**.")
+                    st.error("❌ Les coordonnées des polygones doivent contenir **exactement 4 points**.")
 
     # Onglet 2: Webcam
     with tab2:
         st.header("Détection en Temps Réel avec Webcam")
 
-        # Découverte simple des caméras locales
         camera_options = {"Webcam par défaut": 0}
         for i in range(1, 5):
             try:
@@ -438,17 +547,16 @@ def main():
         camera_id = camera_options[selected_camera]
 
         video_placeholder = st.empty()
-        status_cam = st.empty()
         col1, col2 = st.columns(2)
         count_placeholders = [col1.empty(), col2.empty()]
 
-        st.info("ℹ️ Optimisations: redimensionnement, skip de frames, CUDA si disponible.")
+        st.info("ℹ️ Optimisations: redimensionnement, skip de frames, filtrage anti-duplicata, CUDA si disponible.")
 
         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 polygones doivent contenir **exactement 4 points**.")
+                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:
@@ -456,31 +564,24 @@ def main():
                 processor.frame_skip = frame_skip
                 processor.downsample_factor = downsample
                 processor.conf_threshold = conf_threshold
+                processor.iou_threshold = iou_thresh
+                processor.min_box_area = min_area
 
                 st.session_state.processor = processor
                 st.session_state.webcam_active = True
 
-                t = threading.Thread(
+                threading.Thread(
                     target=st.session_state.processor.process_webcam,
-                    args=(camera_id, video_placeholder, count_placeholders, status_cam),
+                    args=(camera_id, video_placeholder, count_placeholders),
                     daemon=True,
-                )
-                add_script_run_ctx(t)   # <— attache le contexte Streamlit
-                t.start()
-                st.session_state.processing_thread = t
+                ).start()
 
         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 la fin proprement
-                t = st.session_state.get("processing_thread")
-                if t:
-                    t.join(timeout=2.0)
-                    st.session_state.processing_thread = None
-                time.sleep(0.3)
+                time.sleep(0.5)
                 video_placeholder.empty()
-                status_cam.info("Arrêt demandé.")
             else:
                 st.warning("⚠️ Aucune détection en cours !")