Corregir problemas de indentación en el try-except de la clase VideoProcessor

streamlit_app.py

@@ -2247,8 +2247,8 @@ def main():
                             scale_factor = 0.5
                             h, w = img.shape[:2]
                             small_img = safe_resize(img, (int(w * scale_factor), int(h * scale_factor)))
-            if small_img is None:
-                return frame
+                            if small_img is None:
+                                return av.VideoFrame.from_ndarray(img, format="bgr24")
                             
                             # Detect faces - la función ahora devuelve directamente los bboxes
                             bboxes = detect_face_dnn(face_net, small_img, confidence_threshold)
@@ -2260,44 +2260,38 @@ def main():
                                     int(x1 / scale_factor), 
                                     int(y1 / scale_factor), 
                                     int(x2 / scale_factor), 
-                                    int(y2 / scale_factor), 
+                                    int(y2 / scale_factor),
                                     conf
                                 ))
                             
-                            # Update face count in session state
+                            # Actualizar contadores
                             self.face_count = len(original_bboxes)
-                            if self.frame_count % 15 == 0:  # Actualizar métricas con menos frecuencia
-                                if 'webrtc_face_count' not in st.session_state:
-                                    st.session_state.webrtc_face_count = 0
-                                st.session_state.webrtc_face_count = self.face_count
-                                
-                                if 'webrtc_fps' not in st.session_state:
-                                    st.session_state.webrtc_fps = 0
-                                elapsed = time.time() - self.start_time
-                                st.session_state.webrtc_fps = 15 / elapsed if elapsed > 0 else 0
-                                self.start_time = time.time()
+                            current_time = time.time()
+                            elapsed_time = current_time - self.start_time
+                            fps = self.frame_count / elapsed_time if elapsed_time > 0 else 0
                             
-                            # Recognize each face
-                            result_frame = img.copy()
+                            # Actualizar métricas en session_state para que sean accesibles fuera
+                            st.session_state.faces_detected = self.face_count
+                            st.session_state.fps = fps
                             
-                            # Simplificar - solo dibujar rectángulos para esta versión rápida
-                            for i, bbox in enumerate(original_bboxes):
-                                x1, y1, x2, y2, _ = bbox
-                                cv2.rectangle(result_frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
-                                cv2.putText(result_frame, f"Face {i+1}", (x1, y1-10), 
-                                           cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+                            # Dibujar cajas de los rostros
+                            result_img = img.copy()
+                            for i, (x1, y1, x2, y2, conf) in enumerate(original_bboxes):
+                                cv2.rectangle(result_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                                cv2.putText(result_img, f"Face {i+1}: {conf:.2f}", (x1, y1-10), 
+                                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
                             
-                            return av.VideoFrame.from_ndarray(result_frame, format="bgr24")
-                        
+                            # Añadir información FPS y rostros
+                            cv2.putText(result_img, f"FPS: {fps:.1f}", (10, 30), 
+                                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+                            cv2.putText(result_img, f"Faces: {self.face_count}", (10, 60), 
+                                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+                            
+                            return av.VideoFrame.from_ndarray(result_img, format="bgr24")
                         except Exception as e:
-                            # En caso de cualquier error, mostrar mensaje en la imagen
-                            error_frame = np.ones((480, 640, 3), dtype=np.uint8) * 255
-                            error_msg = f"Error: {str(e)}"
-                            cv2.putText(error_frame, error_msg[:50], (20, 240), 
-                                      cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-                            cv2.putText(error_frame, "Intente usar opciones alternativas", (20, 280), 
-                                      cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-                            return av.VideoFrame.from_ndarray(error_frame, format="bgr24")
+                            print(f"Error en procesamiento de video: {str(e)}")
+                            # En caso de error, devolver el frame original
+                            return av.VideoFrame.from_ndarray(img, format="bgr24")
                 
                 # Display WebRTC streamer
                 webrtc_ctx = webrtc_streamer(
@@ -2317,8 +2311,8 @@ def main():
                 # Update metrics if WebRTC is running
                 if webrtc_ctx.state.playing:
                     # Use a separate thread to update metrics
-                    faces_metric.metric("Faces detected", st.session_state.get('webrtc_face_count', 0))
-                    fps_metric.metric("FPS", f"{st.session_state.get('webrtc_fps', 0):.1f}")
+                    faces_metric.metric("Faces detected", st.session_state.get('faces_detected', 0))
+                    fps_metric.metric("FPS", f"{st.session_state.get('fps', 0):.1f}")
                     time_metric.metric("Status", "Running")
                     
                     # Add instructions