Agregado modo de diagnostico facial al app.py

app.py

@@ -20,14 +20,140 @@ try:
 except Exception as e:
     st.error(f"Error al comprobar/descargar modelos: {e}")
 
-try:
-    # Importar la aplicación principal
-    print("Starting Face Detection Application...")
-    from streamlit_app import main
+# 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.")
     
-    # 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.") 
+    # 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.")