Translate Real-time Recognition interface to English

streamlit_app.py

@@ -2303,13 +2303,13 @@ def main():
                             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"Rostro {i+1}: {conf:.2f}", (x1, y1-10), 
+                                cv2.putText(result_img, f"Face {i+1}: {conf:.2f}", (x1, y1-10), 
                                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
                             
                             # 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"Rostros: {self.face_count}", (10, 60), 
+                            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")
@@ -2324,7 +2324,7 @@ def main():
                                 return av.VideoFrame.from_ndarray(blank, format="bgr24")
                 
                 # Display WebRTC streamer con opciones simplificadas para mejorar compatibilidad
-                st.info("⚠️ Si el video no carga: Intente usar Chrome, recargar la página o pruebe las opciones alternativas abajo.")
+                st.info("⚠️ If the video doesn't load: Try using Chrome, reload the page, or use the alternative options below.")
                 webrtc_ctx = webrtc_streamer(
                     key="face-recognition",
                     mode=WebRtcMode.SENDRECV,
@@ -2341,250 +2341,250 @@ def main():
                     time_metric.metric("Status", "Running")
                     
                     # Mostrar instrucciones de uso
-                    st.success("Cámara web activada. Los rostros detectados serán identificados en tiempo real.")
+                    st.success("Webcam activated. Detected faces will be identified in real-time.")
                 else:
                     faces_metric.metric("Faces detected", 0)
                     fps_metric.metric("FPS", "0")
                     time_metric.metric("Status", "Stopped")
                     
                     # Mostrar instrucciones de activación
-                    st.warning("Haga clic en START para activar la cámara web. Esta función puede no estar disponible en entornos como Hugging Face Spaces debido a restricciones de seguridad.")
+                    st.warning("Click START to activate the webcam. This feature may not be available in environments like Hugging Face Spaces due to security restrictions.")
                 
                 # WebRTC troubleshooting
-                with st.expander("Ayuda: Problemas con WebRTC"):
+                with st.expander("Help: WebRTC Issues"):
                     st.markdown("""
-                    ### Solución de problemas con WebRTC
+                    ### WebRTC Troubleshooting
                     
-                    Si el reconocimiento en tiempo real no funciona, puede deberse a las siguientes razones:
+                    If real-time recognition is not working, it may be due to the following reasons:
                     
-                    1. **Restricciones de seguridad en Hugging Face Spaces**: Algunos navegadores restringen el acceso a la cámara en entornos como este.
-                    2. **Problemas de conexión**: WebRTC requiere establecer una conexión que puede ser bloqueada por firewalls o proxies.
-                    3. **Permisos de cámara**: Es posible que deba conceder permisos explícitos al navegador para acceder a su cámara.
+                    1. **Security restrictions in Hugging Face Spaces**: Some browsers restrict camera access in environments like this.
+                    2. **Connection problems**: WebRTC requires establishing a connection that may be blocked by firewalls or proxies.
+                    3. **Camera permissions**: You may need to grant explicit permissions to the browser to access your camera.
                     
-                    ### Qué hacer:
+                    ### What to do:
                     
-                    1. Intente usar otro navegador (Chrome suele funcionar mejor)
-                    2. Asegúrese de que ha concedido permisos de cámara cuando el navegador los solicita
-                    3. Si sigue sin funcionar, use las opciones alternativas que se muestran a continuación
+                    1. Try using another browser (Chrome usually works better)
+                    2. Make sure you have granted camera permissions when the browser requests them
+                    3. If it still doesn't work, use the alternative options shown below
                     """)
 
-                    # Añadir opción de cámara alternativa para entornos donde WebRTC no funciona bien
-                    st.markdown("---")
-                    st.markdown("### Modo de cámara alternativo")
+                # Añadir opción de cámara alternativa para entornos donde WebRTC no funciona bien
+                st.markdown("---")
+                st.markdown("### Alternative Camera Mode")
 
-                    col1, col2 = st.columns(2)
-                    simple_camera = col1.button("Usar cámara simple", key="simple_camera_button1", use_container_width=True)
-                    stop_simple_camera = col2.button("Detener cámara simple", key="stop_camera_button1", use_container_width=True)
+                col1, col2 = st.columns(2)
+                simple_camera = col1.button("Use Simple Camera", key="simple_camera_button1", use_container_width=True)
+                stop_simple_camera = col2.button("Stop Camera", key="stop_camera_button1", use_container_width=True)
 
-                    if simple_camera:
-                        st.session_state.simple_camera = True
-                        st.session_state.demo_running = False
-                        st.session_state.upload_mode = False
-                        
-                    if stop_simple_camera:
-                        st.session_state.simple_camera = False
+                if simple_camera:
+                    st.session_state.simple_camera = True
+                    st.session_state.demo_running = False
+                    st.session_state.upload_mode = False
+                    
+                if stop_simple_camera:
+                    st.session_state.simple_camera = False
 
-                    if st.session_state.get('simple_camera', False):
-                        # Contenedor para la cámara
-                        camera_container = st.container()
+                if st.session_state.get('simple_camera', False):
+                    # Contenedor para la cámara
+                    camera_container = st.container()
+                    
+                    # Configurar métricas
+                    faces_metric.metric("Faces detected", 0)
+                    fps_metric.metric("FPS", "N/A")
+                    time_metric.metric("Status", "Running")
+                    
+                    # Cámara simple que toma una imagen a la vez
+                    with camera_container:
+                        st.info("Simple camera activated. Each image is processed individually. Take a photo with your camera to detect faces.")
                         
-                        # Configurar métricas
-                        faces_metric.metric("Faces detected", 0)
-                        fps_metric.metric("FPS", "N/A")
-                        time_metric.metric("Status", "Running")
+                        # Usar imagen de la cámara
+                        captured_image = st.camera_input("Take photo for recognition", key="camera_simple_input")
                         
-                        # Cámara simple que toma una imagen a la vez
-                        with camera_container:
-                            st.info("Cámara simple activada. Cada imagen se procesa individualmente. Tome una foto con su cámara para detectar rostros.")
-                            
-                            # Usar imagen de la cámara
-                            captured_image = st.camera_input("Tomar foto para reconocimiento", key="camera_simple_input")
-                            
-                            # Procesar la imagen si está disponible
-                            if captured_image is not None:
-                                try:
-                                    # Leer imagen
-                                    image_bytes = captured_image.getvalue()
-                                    image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
+                        # Procesar la imagen si está disponible
+                        if captured_image is not None:
+                            try:
+                                # Leer 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)
                                     
-                                    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))
-                                        
-                                        # 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"Rostro {i+1}: {conf:.2f}", (x1, y1-10), 
-                                                      cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
-                                        
-                                        # Mostrar resultado
-                                        st.image(result_img, channels="BGR", caption="Rostros detectados", use_column_width=True)
-                                        
-                                        if len(bboxes) > 0:
-                                            # Si hay rostros registrados, intentar reconocerlos
-                                            if st.session_state.face_database and len(st.session_state.face_database) > 0:
-                                                st.subheader("Reconocimiento de rostros:")
+                                    # Actualizar métricas
+                                    faces_metric.metric("Faces detected", len(bboxes))
+                                    
+                                    # 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
+                                    st.image(result_img, channels="BGR", caption="Detected faces", use_column_width=True)
+                                    
+                                    if len(bboxes) > 0:
+                                        # Si hay rostros registrados, intentar reconocerlos
+                                        if st.session_state.face_database and len(st.session_state.face_database) > 0:
+                                            st.subheader("Face Recognition:")
+                                            
+                                            recognition_results = []
+                                            for i, bbox in enumerate(bboxes):
+                                                x1, y1, x2, y2, _ = bbox
+                                                face_img = image[y1:y2, x1:x2]
                                                 
-                                                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
-                                                    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:  # Default to VGG-Face
-                                                        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']:
-                                                            for emb_info in info['embeddings']:
-                                                                if emb_info['model'] == model_choice:
-                                                                    stored_emb = emb_info['embedding']
-                                                                    similarity = cosine_similarity(embedding, stored_emb)
-                                                                    
-                                                                    if similarity > similarity_threshold 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
-                                                        })
+                                                # Extraer el embedding del rostro
+                                                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:  # Default to VGG-Face
+                                                    embedding = vggface_model(face_img)
                                                 
-                                                # 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)
-                                                    
-                                                    st.image(result_with_names, channels="BGR", caption="Rostros reconocidos", use_column_width=True)
+                                                # 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']:
+                                                        for emb_info in info['embeddings']:
+                                                            if emb_info['model'] == model_choice:
+                                                                stored_emb = emb_info['embedding']
+                                                                similarity = cosine_similarity(embedding, stored_emb)
+                                                                
+                                                                if similarity > similarity_threshold 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']
                                                     
-                                                    # Mostrar tabla de resultados
-                                                    results_df = pd.DataFrame([
-                                                        {"Nombre": r['name'], "Confianza": f"{r['similarity']:.2f}"} 
-                                                        for r in recognition_results
-                                                    ])
-                                                    st.table(results_df)
-                                                else:
-                                                    st.warning("No se pudo reconocer ninguno de los rostros detectados.")
+                                                    # 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)
+                                                
+                                                st.image(result_with_names, channels="BGR", caption="Recognized faces", use_column_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)
                                             else:
-                                                st.info("No hay rostros registrados para comparar. Registre rostros en la sección 'Face Registration'.")
-                                            
-                                            st.success(f"Se detectaron {len(bboxes)} rostros")
+                                                st.warning("Could not recognize any of the detected faces.")
                                         else:
-                                            st.warning("No se detectaron rostros. Intente con una iluminación mejor o una posición diferente.")
+                                            st.info("No registered faces to compare. Please register faces in the 'Face Registration' section.")
+                                        
+                                        st.success(f"{len(bboxes)} faces detected")
                                     else:
-                                        st.error("No se pudo procesar la imagen. Intente tomar otra foto.")
-                                except Exception as e:
-                                    st.error(f"Error al procesar la imagen: {str(e)}")
-                                    st.info("Intente tomar otra foto o use otra opción.")
+                                        st.warning("No faces detected. Try with better lighting or a different position.")
+                                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 taking another photo or use another option.")
 
-                    # Opción alternativa en caso de problemas con WebRTC (mantenemos esta opción también)
-                    st.markdown("---")
-                    st.markdown("### Otras opciones")
-                    col1, col2 = st.columns(2)
-                    demo_mode = col1.button("Usar modo de demostración", key="demo_button1")
-                    upload_mode = col2.button("Subir imagen para reconocimiento", key="upload_button1")
+                # Opción alternativa en caso de problemas con WebRTC (mantenemos esta opción también)
+                st.markdown("---")
+                st.markdown("### Other Options")
+                col1, col2 = st.columns(2)
+                demo_mode = col1.button("Use Demo Mode", key="demo_button1")
+                upload_mode = col2.button("Upload Image for Recognition", key="upload_button1")
 
-                    if demo_mode:
-                        st.session_state.demo_running = True
-                        st.session_state.upload_mode = False
-                        st.session_state.simple_camera = False
-                    elif upload_mode:
-                        st.session_state.upload_mode = True
-                        st.session_state.demo_running = False
-                        st.session_state.simple_camera = False
+                if demo_mode:
+                    st.session_state.demo_running = True
+                    st.session_state.upload_mode = False
+                    st.session_state.simple_camera = False
+                elif upload_mode:
+                    st.session_state.upload_mode = True
+                    st.session_state.demo_running = False
+                    st.session_state.simple_camera = False
 
-                    # Modo de demostración con imágenes simuladas
-                    if st.session_state.get('demo_running', False):
-                        # Cargar algunas imágenes de ejemplo (usar tus propias imágenes si es posible)
-                        demo_img = None
-                        
-                        # Intentar usar una imagen de la base de datos
-                        if st.session_state.face_database:
-                            for name, info in st.session_state.face_database.items():
-                                if 'image' in info:
-                                    try:
-                                        demo_img = info['image']
-                                        break
-                                    except:
-                                        pass
-                        
-                        # Si no hay imagen disponible, crear una imagen en blanco
-                        if demo_img is None:
-                            demo_img = np.ones((480, 640, 3), dtype=np.uint8) * 255
-                            # Dibujar un círculo como "cara" simulada
-                            cv2.circle(demo_img, (320, 240), 100, (0, 0, 255), -1)
-                            cv2.circle(demo_img, (280, 200), 15, (255, 255, 255), -1)
-                            cv2.circle(demo_img, (360, 200), 15, (255, 255, 255), -1)
-                            cv2.ellipse(demo_img, (320, 260), (50, 30), 0, 0, 180, (255, 255, 255), -1)
+                # Modo de demostración con imágenes simuladas
+                if st.session_state.get('demo_running', False):
+                    # Cargar algunas imágenes de ejemplo (usar tus propias imágenes si es posible)
+                    demo_img = None
+                    
+                    # Intentar usar una imagen de la base de datos
+                    if st.session_state.face_database:
+                        for name, info in st.session_state.face_database.items():
+                            if 'image' in info:
+                                try:
+                                    demo_img = info['image']
+                                    break
+                                except:
+                                    pass
+                    
+                    # Si no hay imagen disponible, crear una imagen en blanco
+                    if demo_img is None:
+                        demo_img = np.ones((480, 640, 3), dtype=np.uint8) * 255
+                        # Dibujar un círculo como "cara" simulada
+                        cv2.circle(demo_img, (320, 240), 100, (0, 0, 255), -1)
+                        cv2.circle(demo_img, (280, 200), 15, (255, 255, 255), -1)
+                        cv2.circle(demo_img, (360, 200), 15, (255, 255, 255), -1)
+                        cv2.ellipse(demo_img, (320, 260), (50, 30), 0, 0, 180, (255, 255, 255), -1)
+                    
+                    # Mostrar la imagen
+                    st.image(demo_img, channels="BGR", caption="Demo Mode", use_column_width=True)
+                    
+                    # Simular métricas
+                    faces_metric.metric("Faces detected", 1)
+                    fps_metric.metric("FPS", "15.5")
+                    time_metric.metric("Status", "Demo")
+                    
+                    st.success("Demo mode activated. In a local environment, real-time facial recognition would work correctly.")
+
+                # Modo de carga de imagen
+                if st.session_state.get('upload_mode', False):
+                    uploaded_file = st.file_uploader("Upload an image with faces", type=["jpg", "jpeg", "png"], key="upload_image_input")
+                    
+                    if uploaded_file is not None:
+                        # Leer imagen
+                        image_bytes = uploaded_file.read()
+                        image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
                         
-                        # Mostrar la imagen
-                        st.image(demo_img, channels="BGR", caption="Modo de demostración", use_column_width=True)
+                        # Detectar rostros
+                        bboxes = detect_face_dnn(face_net, image, confidence_threshold)
                         
-                        # Simular métricas
-                        faces_metric.metric("Faces detected", 1)
-                        fps_metric.metric("FPS", "15.5")
-                        time_metric.metric("Status", "Demo")
+                        # Dibujar rostros detectados
+                        result_img = image.copy()
+                        for i, bbox in enumerate(bboxes):
+                            x1, y1, x2, y2, _ = bbox
+                            cv2.rectangle(result_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                            cv2.putText(result_img, f"Face {i+1}", (x1, y1-10), 
+                                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
                         
-                        st.success("Modo de demostración activado. En un entorno local, el reconocimiento facial en tiempo real funcionaría correctamente.")
-
-                    # Modo de carga de imagen
-                    if st.session_state.get('upload_mode', False):
-                        uploaded_file = st.file_uploader("Sube una imagen con rostros", type=["jpg", "jpeg", "png"], key="upload_image_input")
+                        # Mostrar resultado
+                        st.image(result_img, channels="BGR", caption="Detected faces", use_column_width=True)
                         
-                        if uploaded_file is not None:
-                            # Leer imagen
-                            image_bytes = uploaded_file.read()
-                            image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
-                            
-                            # Detectar rostros
-                            bboxes = detect_face_dnn(face_net, image, confidence_threshold)
-                            
-                            # Dibujar rostros detectados
-                            result_img = image.copy()
-                            for i, bbox in enumerate(bboxes):
-                                x1, y1, x2, y2, _ = bbox
-                                cv2.rectangle(result_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
-                                cv2.putText(result_img, f"Face {i+1}", (x1, y1-10), 
-                                           cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
-                            
-                            # Mostrar resultado
-                            st.image(result_img, channels="BGR", caption="Rostros detectados", use_column_width=True)
-                            
-                            # Actualizar métricas
-                            faces_metric.metric("Faces detected", len(bboxes))
-                            time_metric.metric("Status", "Processed")
+                        # Actualizar métricas
+                        faces_metric.metric("Faces detected", len(bboxes))
+                        time_metric.metric("Status", "Processed")
 
-                    # Add a note about privacy
-                    st.markdown("---")
-                    st.markdown("**Privacy Note**: Video is processed in your browser and on the server. No video data is stored permanently.")
+                # Add a note about privacy
+                st.markdown("---")
+                st.markdown("**Privacy Note**: Video is processed in your browser and on the server. No video data is stored permanently.")
 
 # Si se ejecuta este archivo directamente, llamar a la función main
 if __name__ == "__main__":