app.py

# Simple app.py for Face Detection
import os
import streamlit as st

# Comprobar y descargar modelos necesarios
try:
    # Verificar si los archivos de modelo existen
    model_files = [
        "deploy.prototxt.txt",
        "res10_300x300_ssd_iter_140000.caffemodel"
    ]
    
    missing_files = [f for f in model_files if not os.path.exists(f)]
    
    if missing_files:
        st.warning("Faltan archivos de modelo. Descargando...")
        import download_models
        download_models.main()
        st.success("¡Archivos de modelo descargados correctamente!")
except Exception as e:
    st.error(f"Error al comprobar/descargar modelos: {e}")

# Modo diagnóstico
if 'modo_diagnostico' not in st.session_state:
    st.session_state.modo_diagnostico = False

# Función para el modo de diagnóstico
def modo_diagnostico():
    st.title("Diagnóstico de Detección Facial")
    st.write("Esta herramienta ayuda a identificar problemas con la detección de rostros.")
    
    # Verificar modelos
    st.subheader("1. Verificación de archivos de modelo")
    for archivo in model_files:
        if os.path.exists(archivo):
            st.success(f"✅ Modelo encontrado: {archivo}")
        else:
            st.error(f"❌ Modelo NO encontrado: {archivo}")
    
    # Probar carga del modelo
    st.subheader("2. Prueba de carga del modelo")
    try:
        import cv2
        import numpy as np
        from PIL import Image
        import io
        import base64
        
        modelFile = "res10_300x300_ssd_iter_140000.caffemodel"
        configFile = "deploy.prototxt.txt"
        
        net = cv2.dnn.readNetFromCaffe(configFile, modelFile)
        st.success(f"✅ Modelo cargado correctamente: {type(net)}")
        
        # Crear imagen de prueba
        st.subheader("3. Probar detección")
        
        # Crear una imagen de prueba con un óvalo como rostro
        example_image = np.zeros((400, 400, 3), dtype=np.uint8)
        # Dibujar un óvalo que simule un rostro
        cv2.ellipse(example_image, (200, 200), (100, 140), 0, 0, 360, (200, 200, 200), -1)
        # Dibujar ojos
        cv2.circle(example_image, (150, 150), 15, (255, 255, 255), -1)
        cv2.circle(example_image, (250, 150), 15, (255, 255, 255), -1)
        # Dibujar boca
        cv2.ellipse(example_image, (200, 250), (50, 20), 0, 0, 360, (150, 150, 150), -1)
        
        # Mostrar imagen de prueba
        st.image(example_image, caption="Imagen de prueba", channels="BGR")
        
        # Detectar rostros en la imagen de prueba
        h, w = example_image.shape[:2]
        blob = cv2.dnn.blobFromImage(cv2.resize(example_image, (300, 300)), 1.0,
                                     (300, 300), (104.0, 177.0, 123.0))
        
        net.setInput(blob)
        detections = net.forward()
        
        # Dibujar resultados con diferentes umbrales
        umbral = st.slider("Umbral de confianza", 0.1, 0.9, 0.3, 0.1)
        
        # Procesar detecciones
        bboxes = []
        frame_h, frame_w = example_image.shape[:2]
        
        for i in range(detections.shape[2]):
            confidence = detections[0, 0, i, 2]
            
            if confidence > umbral:
                box = detections[0, 0, i, 3:7] * np.array([frame_w, frame_h, frame_w, frame_h])
                x1, y1, x2, y2 = box.astype("int")
                
                # Asegurar coordenadas válidas
                x1 = max(0, min(x1, frame_w - 1))
                y1 = max(0, min(y1, frame_h - 1))
                x2 = max(0, min(x2, frame_w - 1))
                y2 = max(0, min(y2, frame_h - 1))
                
                # Verificar validez de la caja
                width, height = x2 - x1, y2 - y1
                if width <= 0 or height <= 0:
                    continue
                
                bboxes.append([x1, y1, x2, y2, confidence])
        
        # Dibujar resultados
        result_image = example_image.copy()
        for bbox in bboxes:
            x1, y1, x2, y2, confidence = bbox
            # Dibujar rectángulo verde grueso
            cv2.rectangle(result_image, (x1, y1), (x2, y2), (0, 255, 0), 3)
            # Añadir texto con confianza
            cv2.putText(result_image, f"{confidence:.2f}", (x1, y1-10), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
        
        st.image(result_image, caption=f"Resultado con umbral {umbral}", channels="BGR")
        
        # Mostrar estadísticas
        st.subheader("Estadísticas de detección")
        st.write(f"Detecciones encontradas: {len(bboxes)}")
        
        if len(bboxes) > 0:
            st.success("✅ La detección facial funciona correctamente")
        else:
            st.error("❌ No se detectaron rostros en la imagen de prueba")
            
        # Diagnóstico
        if len(bboxes) == 0:
            st.subheader("Posibles problemas:")
            st.write("""
            1. El modelo no se está cargando correctamente.
            2. El procesamiento de la imagen es incorrecto.
            3. El umbral de confianza es demasiado alto.
            4. Hay un problema con la visualización de los resultados.
            """)
        
    except Exception as e:
        st.error(f"Error en el diagnóstico: {e}")

# Crear un sidebar con opciones
st.sidebar.title("Opciones")
modo = st.sidebar.radio("Seleccionar modo:", ["Aplicación principal", "Diagnóstico"])

if modo == "Diagnóstico":
    # Ejecutar diagnóstico
    modo_diagnostico()
else:
    # Ejecutar aplicación principal
    try:
        # Importar la aplicación principal
        print("Starting Face Detection Application...")
        from streamlit_app import main
        
        # Main entry point
        if __name__ == "__main__":
            main()
    except Exception as e:
        st.error(f"Error al iniciar la aplicación: {e}")
        st.error("Por favor, revise los logs para más información.")