Añadir modo de captura continua para reconocimiento facial en Hugging Face Spaces

streamlit_app.py

@@ -2353,6 +2353,165 @@ def main():
                     3. If it still doesn't work, use the alternative options shown below
                     """)
 
+                # Añadir modo de captura continua (funciona mejor en Hugging Face)
+                st.markdown("---")
+                st.markdown("### Continuous Capture Mode")
+                st.info("⚠️ Recommended mode for Hugging Face: Captures frames continuously with reliable camera access.")
+                
+                col1, col2 = st.columns(2)
+                start_continuous = col1.button("Start Continuous Capture", key="start_continuous_button", use_container_width=True)
+                stop_continuous = col2.button("Stop Continuous Capture", key="stop_continuous_button", use_container_width=True)
+                
+                if start_continuous:
+                    st.session_state.continuous_capture = True
+                    st.session_state.frame_count = 0
+                    st.session_state.frames_processed = 0
+                    st.session_state.start_time = time.time()
+                    st.session_state.last_fps_update = time.time()
+                    # Desactivar otros modos
+                    st.session_state.demo_running = False
+                    st.session_state.upload_mode = False
+                    st.session_state.simple_camera = False
+                    
+                if stop_continuous:
+                    st.session_state.continuous_capture = False
+                
+                if st.session_state.get('continuous_capture', False):
+                    # Área para mostrar resultados
+                    result_container = st.container()
+                    camera_container = st.container()
+                    
+                    # Configurar métricas
+                    faces_metric.metric("Faces detected", 0)
+                    fps_metric.metric("FPS", "Processing...")
+                    time_metric.metric("Status", "Running")
+                    
+                    # Capturar imagen y procesarla
+                    with camera_container:
+                        st.info("Continuous capture mode active. Processing frames automatically.")
+                        
+                        # Incrementar contador de frames para forzar una nueva captura en cada ciclo
+                        frame_key = f"continuous_frame_{st.session_state.get('frame_count', 0)}"
+                        captured_image = st.camera_input("Camera feed", key=frame_key)
+                        
+                        if captured_image is not None:
+                            try:
+                                # Procesar la imagen
+                                image_bytes = captured_image.getvalue()
+                                image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
+                                
+                                if image is not None and image.size > 0:
+                                    # Detectar rostros
+                                    bboxes = detect_face_dnn(face_net, image, confidence_threshold)
+                                    
+                                    # Actualizar métricas
+                                    faces_metric.metric("Faces detected", len(bboxes))
+                                    
+                                    # Incrementar contador de frames procesados
+                                    st.session_state.frames_processed += 1
+                                    
+                                    # Calcular FPS real (actualizar cada segundo)
+                                    current_time = time.time()
+                                    elapsed = current_time - st.session_state.start_time
+                                    
+                                    if current_time - st.session_state.last_fps_update >= 1.0:
+                                        fps = st.session_state.frames_processed / elapsed
+                                        fps_metric.metric("FPS", f"{fps:.1f}")
+                                        st.session_state.last_fps_update = current_time
+                                    
+                                    # Dibujar resultados
+                                    result_img = image.copy()
+                                    for i, bbox in enumerate(bboxes):
+                                        x1, y1, x2, y2, conf = bbox
+                                        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.6, (0, 255, 0), 2)
+                                    
+                                    # Mostrar resultado
+                                    with result_container:
+                                        st.image(result_img, channels="BGR", caption=f"Frame {st.session_state.frames_processed}", use_container_width=True)
+                                    
+                                    # Si hay rostros y hay una base de datos, intentar reconocerlos
+                                    if len(bboxes) > 0 and st.session_state.face_database and len(st.session_state.face_database) > 0:
+                                        recognition_results = []
+                                        
+                                        for i, bbox in enumerate(bboxes):
+                                            x1, y1, x2, y2, _ = bbox
+                                            face_img = image[y1:y2, x1:x2]
+                                            
+                                            # Extraer el embedding del rostro con el modelo seleccionado
+                                            if model_choice == "VGG-Face":
+                                                embedding = vggface_model(face_img)
+                                            elif model_choice == "Facenet":
+                                                embedding = facenet_model(face_img)
+                                            elif model_choice == "OpenFace":
+                                                embedding = openface_model(face_img)
+                                            elif model_choice == "ArcFace":
+                                                embedding = arcface_model(face_img)
+                                            else:
+                                                embedding = vggface_model(face_img)
+                                            
+                                            # Comparar con rostros registrados
+                                            best_match = None
+                                            best_similarity = -1
+                                            
+                                            for name, info in st.session_state.face_database.items():
+                                                if 'embeddings' in info and info['embeddings']:
+                                                    # Buscar embedding del mismo modelo
+                                                    for emb in info['embeddings']:
+                                                        if isinstance(emb, dict) and 'model' in emb and emb['model'] == model_choice:
+                                                            stored_emb = emb['embedding']
+                                                            similarity = cosine_similarity(embedding, stored_emb)
+                                                            
+                                                            if similarity > similarity_threshold/100 and similarity > best_similarity:
+                                                                best_similarity = similarity
+                                                                best_match = name
+                                            
+                                            if best_match is not None:
+                                                recognition_results.append({
+                                                    'bbox': bbox,
+                                                    'name': best_match,
+                                                    'similarity': best_similarity
+                                                })
+                                        
+                                        # Mostrar resultados de reconocimiento
+                                        if recognition_results:
+                                            result_with_names = result_img.copy()
+                                            
+                                            for result in recognition_results:
+                                                x1, y1, x2, y2, _ = result['bbox']
+                                                name = result['name']
+                                                similarity = result['similarity']
+                                                
+                                                # Dibujar nombre y similitud
+                                                cv2.rectangle(result_with_names, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                                                label = f"{name}: {similarity:.2f}"
+                                                cv2.putText(result_with_names, label, (x1, y1-10), 
+                                                          cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+                                            
+                                            with result_container:
+                                                st.image(result_with_names, channels="BGR", caption="Recognized faces", use_container_width=True)
+                                                
+                                                # Mostrar tabla de resultados
+                                                results_df = pd.DataFrame([
+                                                    {"Name": r['name'], "Confidence": f"{r['similarity']:.2f}"} 
+                                                    for r in recognition_results
+                                                ])
+                                                st.table(results_df)
+                                    
+                                    # Incrementar contador para siguiente frame
+                                    st.session_state.frame_count += 1
+                                    
+                                    # Recargar para capturar siguiente frame (si todavía está activo)
+                                    if st.session_state.get('continuous_capture', False):
+                                        time.sleep(0.1)  # Pequeña pausa para evitar sobrecarga
+                                        st.experimental_rerun()
+                                else:
+                                    st.error("Could not process the image. Try taking another photo.")
+                            except Exception as e:
+                                st.error(f"Error processing image: {str(e)}")
+                                st.info("Try again or use another camera mode.")
+
                 # Añadir opción de cámara alternativa para entornos donde WebRTC no funciona bien
                 st.markdown("---")
                 st.markdown("### Alternative Camera Mode")