Update app.py

app.py

@@ -25,6 +25,19 @@ 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)
 
+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
+        cap = cv2.VideoCapture(i)
+        if cap.isOpened():
+            ret, frame = cap.read()
+            if ret:
+                available_cameras.append(i)
+            cap.release()
+    
+    return available_cameras
+
 # --- CLASSE YOLO OPTIMISÉE ---
 class YOLOVideoProcessor:
     def __init__(self, model_path, poly1, poly2, tracker_method="bot"):
@@ -228,19 +241,35 @@ class YOLOVideoProcessor:
 
     def process_webcam(self, camera_id=0, display_placeholder=None, count_placeholders=None):
         """Traite la vidéo en temps réel depuis une webcam avec multi-threading"""
-        # Tentative d'ouverture avec plusieurs backends dans OpenCV
-        for backend_pref in [cv2.CAP_ANY, cv2.CAP_DSHOW, cv2.CAP_MSMF, cv2.CAP_V4L2]:
+        # Essayer différentes méthodes d'initialisation de la webcam
+        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)
+        ]
+        
+        for backend in backends_to_try:
             try:
-                # Essayer différents backends de capture
-                cap = cv2.VideoCapture(camera_id, backend_pref)
+                cap = cv2.VideoCapture(camera_id, backend)
                 if cap.isOpened():
+                    if display_placeholder:
+                        display_placeholder.success(f"✅ Webcam connectée avec succès (backend: {backend})")
                     break
-            except:
+            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 avec le backend par défaut
-        if not cap.isOpened():
-            cap = cv2.VideoCapture(camera_id)
+        # Si aucun backend n'a fonctionné, essayer une dernière fois sans spécifier de backend
+        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
         if not cap.isOpened():
@@ -414,12 +443,12 @@ def main():
         downsample = st.slider("Facteur d'échelle (plus petit = plus rapide)", 0.3, 1.0, 0.5, 0.1)
         conf_threshold = st.slider("Seuil de confiance", 0.1, 0.9, 0.35, 0.05)
         
-        # # Informations système
-        # st.subheader("💻 Informations système")
-        # device_info = f"GPU: {'Disponible' if torch.cuda.is_available() else 'Non disponible'}"
-        # if torch.cuda.is_available():
-        #     device_info += f" ({torch.cuda.get_device_name(0)})"
-        # st.info(device_info)
+        # Informations système
+        st.subheader("💻 Informations système")
+        device_info = f"GPU: {'Disponible' if torch.cuda.is_available() else 'Non disponible'}"
+        if torch.cuda.is_available():
+            device_info += f" ({torch.cuda.get_device_name(0)})"
+        st.info(device_info)
         
     def parse_polygon(input_text):
         try:
@@ -498,14 +527,31 @@ def main():
     with tab2:
         st.header("Détection en Temps Réel avec Webcam")
         
-        # Simplified camera selection - focusing on reliability
+        # Vérifier les caméras disponibles
+        available_cameras = check_camera_availability()
+        if not available_cameras:
+            st.warning("⚠️ Aucune caméra détectée automatiquement sur votre système. Vous pouvez toujours essayer les options ci-dessous.")
+        else:
+            st.success(f"✅ Caméras détectées aux indices: {available_cameras}")
+        
+        # Méthode améliorée de sélection de caméra
         camera_options = {"Webcam par défaut (0)": 0}
-        # Ajout de quelques options supplémentaires sans test préalable
-        for i in range(1, 4):
+        
+        # Ajouter plus d'options pour les caméras alternatives
+        for i in range(1, 8):  # Essayer jusqu'à 8 caméras différentes
             camera_options[f"Caméra alternative ({i})"] = i
-                
+        
+        # Ajouter aussi des options pour les caméras virtuelles ou IP
+        camera_options["Caméra IP (entrez l'URL)"] = "ip"
+        
         selected_camera = st.selectbox("Sélectionnez la source vidéo", list(camera_options.keys()))
-        camera_id = camera_options[selected_camera]
+        
+        # Permettre d'entrer une URL de caméra IP
+        if camera_options[selected_camera] == "ip":
+            ip_camera_url = st.text_input("URL de la caméra IP (RTSP, HTTP)", "http://adresse-ip:port/video")
+            camera_id = ip_camera_url
+        else:
+            camera_id = camera_options[selected_camera]
         
         # Paramètres d'affichage
         display_quality = st.select_slider(
@@ -534,40 +580,33 @@ def main():
             elif st.session_state.webcam_active:
                 st.warning("⚠️ La webcam est déjà active !")
             else:
-                # Tester l'ouverture de la webcam avant de démarrer le traitement
-                test_cap = cv2.VideoCapture(camera_id)
-                if not test_cap.isOpened():
-                    st.error(f"⚠️ Impossible d'ouvrir la caméra {camera_id}. Essayez une autre source vidéo.")
-                    test_cap.release()
-                else:
-                    test_cap.release()  # Libérer la caméra pour le traitement réel
-                    
-                    # Créer le processeur YOLO avec les paramètres d'optimisation
-                    processor = YOLOVideoProcessor(model_path, poly1, poly2, tracker_method)
-                    processor.frame_skip = frame_skip
-                    processor.downsample_factor = downsample
-                    processor.conf_threshold = conf_threshold
-                    
-                    st.session_state.processor = processor
-                    st.session_state.webcam_active = True
-                    
-                    # Démarrer le traitement dans un thread séparé
-                    processing_thread = threading.Thread(
-                        target=st.session_state.processor.process_webcam,
-                        args=(camera_id, video_placeholder, count_placeholders)
-                    )
-                    processing_thread.daemon = True
-                    
-                    # Ajouter le contexte Streamlit au thread pour éviter les erreurs
-                    add_script_run_ctx(processing_thread)
-                    
-                    try:
-                        processing_thread.start()
-                        st.session_state.processing_thread = processing_thread
-                        st.success("✅ Webcam démarrée avec succès!")
-                    except Exception as e:
-                        st.error(f"Erreur au démarrage du thread: {e}")
-                        st.session_state.webcam_active = False
+                video_placeholder.info("🔄 Tentative de connexion à la caméra... Veuillez patienter.")
+                
+                # Créer le processeur YOLO avec les paramètres d'optimisation
+                processor = YOLOVideoProcessor(model_path, poly1, poly2, tracker_method)
+                processor.frame_skip = frame_skip
+                processor.downsample_factor = downsample
+                processor.conf_threshold = conf_threshold
+                
+                st.session_state.processor = processor
+                st.session_state.webcam_active = True
+                
+                # Démarrer le traitement dans un thread séparé
+                processing_thread = threading.Thread(
+                    target=st.session_state.processor.process_webcam,
+                    args=(camera_id, video_placeholder, count_placeholders)
+                )
+                processing_thread.daemon = True
+                
+                # Ajouter le contexte Streamlit au thread pour éviter les erreurs
+                add_script_run_ctx(processing_thread)
+                
+                try:
+                    processing_thread.start()
+                    st.session_state.processing_thread = processing_thread
+                except Exception as e:
+                    st.error(f"Erreur au démarrage du thread: {e}")
+                    st.session_state.webcam_active = False
                 
         if col_stop.button("⏹️ Arrêter la détection"):
             if st.session_state.webcam_active and st.session_state.processor: