Implementar persistencia de base de datos de rostros

face_database_utils.py

@@ -0,0 +1,136 @@
+"""
+Utilidades para manejar la persistencia de la base de datos de rostros.
+"""
+import os
+import pickle
+import streamlit as st
+import json
+import base64
+import numpy as np
+
+# Configurar ruta para la base de datos
+DATABASE_FILE = "face_database.pkl"
+
+def save_face_database(database):
+    """
+    Guarda la base de datos de rostros en un archivo persistente.
+    
+    Args:
+        database (dict): La base de datos de rostros a guardar
+    """
+    try:
+        # Convertir numpy arrays a listas para poder serializarlas
+        serializable_db = {}
+        for name, info in database.items():
+            serializable_db[name] = {}
+            # Manejar diferentes formatos de la base de datos
+            if 'embeddings' in info:
+                serializable_db[name]['embeddings'] = [emb.tolist() if isinstance(emb, np.ndarray) else emb for emb in info['embeddings']]
+                serializable_db[name]['models'] = info['models']
+                serializable_db[name]['count'] = info['count']
+            elif 'embedding' in info:
+                # Formato antiguo
+                serializable_db[name]['embedding'] = info['embedding'].tolist() if isinstance(info['embedding'], np.ndarray) else info['embedding']
+                serializable_db[name]['count'] = info.get('count', 1)
+        
+        # Guardar en un archivo pickle
+        with open(DATABASE_FILE, 'wb') as f:
+            pickle.dump(serializable_db, f)
+        return True
+    except Exception as e:
+        st.error(f"Error al guardar la base de datos: {str(e)}")
+        return False
+
+def load_face_database():
+    """
+    Carga la base de datos de rostros desde un archivo persistente.
+    
+    Returns:
+        dict: La base de datos de rostros cargada, o un diccionario vacío si no existe el archivo.
+    """
+    if not os.path.exists(DATABASE_FILE):
+        return {}
+    
+    try:
+        with open(DATABASE_FILE, 'rb') as f:
+            database = pickle.load(f)
+        
+        # Convertir listas a numpy arrays
+        for name, info in database.items():
+            if 'embeddings' in info:
+                database[name]['embeddings'] = [np.array(emb) if isinstance(emb, list) else emb for emb in info['embeddings']]
+            elif 'embedding' in info:
+                database[name]['embedding'] = np.array(info['embedding']) if isinstance(info['embedding'], list) else info['embedding']
+        
+        return database
+    except Exception as e:
+        st.error(f"Error al cargar la base de datos: {str(e)}")
+        return {}
+
+def export_database_json():
+    """
+    Exporta la base de datos a un archivo JSON para compartir o hacer backup.
+    
+    Returns:
+        str: Ruta al archivo JSON exportado.
+    """
+    try:
+        if 'face_database' in st.session_state and st.session_state.face_database:
+            # Crear una versión serializable de la base de datos
+            serializable_db = {}
+            for name, info in st.session_state.face_database.items():
+                serializable_db[name] = {}
+                if 'embeddings' in info:
+                    serializable_db[name]['embeddings'] = [
+                        base64.b64encode(np.array(emb).tobytes()).decode('utf-8') 
+                        for emb in info['embeddings']
+                    ]
+                    serializable_db[name]['models'] = info['models']
+                    serializable_db[name]['count'] = info['count']
+                elif 'embedding' in info:
+                    serializable_db[name]['embedding'] = base64.b64encode(
+                        np.array(info['embedding']).tobytes()
+                    ).decode('utf-8')
+                    serializable_db[name]['count'] = info.get('count', 1)
+            
+            # Guardar en un archivo JSON
+            export_file = "face_database_export.json"
+            with open(export_file, 'w') as f:
+                json.dump(serializable_db, f, indent=2)
+            
+            return export_file
+        return None
+    except Exception as e:
+        st.error(f"Error al exportar la base de datos: {str(e)}")
+        return None
+
+def import_database_json(json_file):
+    """
+    Importa una base de datos desde un archivo JSON.
+    
+    Args:
+        json_file: El archivo JSON a importar
+        
+    Returns:
+        dict: La base de datos importada.
+    """
+    try:
+        content = json_file.read()
+        imported_db = json.loads(content)
+        
+        # Convertir datos codificados en base64 a numpy arrays
+        for name, info in imported_db.items():
+            if 'embeddings' in info:
+                imported_db[name]['embeddings'] = [
+                    np.frombuffer(base64.b64decode(emb), dtype=np.float32) 
+                    for emb in info['embeddings']
+                ]
+            elif 'embedding' in info:
+                imported_db[name]['embedding'] = np.frombuffer(
+                    base64.b64decode(info['embedding']), dtype=np.float32
+                )
+        
+        return imported_db
+    except Exception as e:
+        st.error(f"Error al importar la base de datos: {str(e)}")
+        return {} 

streamlit_app.py

@@ -13,6 +13,14 @@ import pickle
 from sklearn.metrics.pairwise import cosine_similarity # type: ignore
 import pandas as pd
 
+# Importar las utilidades para la base de datos de rostros
+try:
+    from face_database_utils import save_face_database, load_face_database, export_database_json, import_database_json
+    DATABASE_UTILS_AVAILABLE = True
+except ImportError:
+    DATABASE_UTILS_AVAILABLE = False
+    st.warning("Database utilities are not available. Face recognition data will not be persistent between sessions.")
+
 # Importar DeepFace para reconocimiento facial avanzado
 try:
     from deepface import DeepFace
@@ -1430,7 +1438,11 @@ def main():
         
         # Inicializar base de datos de rostros si no existe
         if 'face_database' not in st.session_state:
-            st.session_state.face_database = {}
+            if DATABASE_UTILS_AVAILABLE:
+                # Cargar la base de datos desde el archivo persistente
+                st.session_state.face_database = load_face_database()
+            else:
+                st.session_state.face_database = {}
         
         # Crear pestañas para las diferentes funcionalidades
         tab1, tab2, tab3 = st.tabs(["Register Face", "Image Recognition", "Real-time Recognition"])
@@ -1556,6 +1568,11 @@ def main():
                                 
                                 st.success(f"Face registered successfully for {person_name}!")
                                 
+                                # Guardar la base de datos actualizada
+                                if DATABASE_UTILS_AVAILABLE:
+                                    if save_face_database(st.session_state.face_database):
+                                        st.info("Face database saved successfully!")
+                                
                                 # Mostrar la imagen con el rostro detectado
                                 processed_image, _ = process_face_detections(image, [bboxes[0]], confidence_threshold)
                                 st.image(cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB), caption=f"Registered face: {person_name}")
@@ -1610,6 +1627,11 @@ def main():
                             # Eliminar el registro
                             if row["Name"] in st.session_state.face_database:
                                 del st.session_state.face_database[row["Name"]]
+                                
+                                # Guardar la base de datos actualizada
+                                if DATABASE_UTILS_AVAILABLE:
+                                    save_face_database(st.session_state.face_database)
+                                
                                 st.success(f"Deleted {row['Name']} from the database.")
                                 st.experimental_rerun()
                 
@@ -1625,6 +1647,11 @@ def main():
                         with col1:
                             if st.button("Yes, delete all"):
                                 st.session_state.face_database = {}
+                                
+                                # Guardar la base de datos vacía
+                                if DATABASE_UTILS_AVAILABLE:
+                                    save_face_database({})
+                                
                                 st.session_state.confirm_delete_all = False
                                 st.success("All registered faces have been deleted.")
                                 st.experimental_rerun()
@@ -1634,6 +1661,40 @@ def main():
                                 st.experimental_rerun()
             else:
                 st.info("No faces registered yet. Use the form above to register faces.")
+            
+            # Añadir botones para importar/exportar la base de datos
+            if DATABASE_UTILS_AVAILABLE:
+                st.subheader("Database Management")
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    # Exportar base de datos
+                    if st.button("Export Face Database") and st.session_state.face_database:
+                        export_file = export_database_json()
+                        if export_file:
+                            with open(export_file, "rb") as f:
+                                st.download_button(
+                                    label="Download JSON Database",
+                                    data=f,
+                                    file_name="face_database.json",
+                                    mime="application/json"
+                                )
+                
+                with col2:
+                    # Importar base de datos
+                    uploaded_json = st.file_uploader("Import Face Database", type=["json"], key="import_database")
+                    if uploaded_json is not None:
+                        if st.button("Process Import"):
+                            with st.spinner("Importing database..."):
+                                imported_db = import_database_json(uploaded_json)
+                                if imported_db:
+                                    # Actualizar la base de datos actual
+                                    st.session_state.face_database.update(imported_db)
+                                    
+                                    # Guardar la base de datos actualizada
+                                    if save_face_database(st.session_state.face_database):
+                                        st.success("Database imported and saved successfully!")
+                                        st.experimental_rerun()
         
         with tab2:
             st.header("Image Recognition")