Añadir diagnóstico detallado para verificar funcionamiento del modelo de detección facial

streamlit_app.py

@@ -127,32 +127,57 @@ def main():
             Lista de bounding boxes con formato [x1, y1, x2, y2, confidence]
             o None si no se detectan rostros
         """
+        # Crear un diagnóstico más detallado
+        log_info = f"===== DIAGNÓSTICO DE DETECCIÓN FACIAL =====\n"
+        log_info += f"Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}\n"
+        log_info += f"Tipo de modelo: {type(net)}\n"
+        log_info += f"Forma de la imagen: {frame.shape}\n"
+        
         # Forzar un umbral muy bajo para aumentar la sensibilidad
         internal_threshold = 0.1  # Usar este umbral internamente para mayor sensibilidad
         
         # Añadir impresión de depuración para el umbral usado
         print(f"Detecting faces with original threshold: {conf_threshold}, using internal threshold: {internal_threshold}")
+        log_info += f"Umbral original: {conf_threshold}, umbral interno: {internal_threshold}\n"
         
         # Obtener dimensiones de la imagen
         h, w = frame.shape[:2]
+        log_info += f"Dimensiones de imagen: {w}x{h}\n"
         
         # Crear un blob de la imagen (redimensionada a 300x300 y normalizada)
         # IMPORTANTE: Los valores de media (104.0, 177.0, 123.0) son específicos 
         # para el modelo res10_300x300_ssd_iter_140000.caffemodel entrenado en Caffe
-        blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0,
-                                    (300, 300), (104.0, 177.0, 123.0))
+        try:
+            blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0,
+                                        (300, 300), (104.0, 177.0, 123.0))
+            log_info += f"Blob creado correctamente. Forma: {blob.shape}\n"
+        except Exception as e:
+            log_info += f"ERROR al crear blob: {str(e)}\n"
+            with open("diagnostico_deteccion.txt", "a") as f:
+                f.write(log_info)
+            print(log_info)
+            return []
         
         # Pasar el blob a través de la red
-        net.setInput(blob)
+        try:
+            net.setInput(blob)
+            log_info += "Input establecido correctamente en la red\n"
+        except Exception as e:
+            log_info += f"ERROR al establecer input: {str(e)}\n"
+            with open("diagnostico_deteccion.txt", "a") as f:
+                f.write(log_info)
+            print(log_info)
+            return []
         
         # Realizar la detección (forward pass)
         try:
             detections = net.forward()
-            print(f"Shape of detection output: {detections.shape}")
+            log_info += f"Forward pass exitoso. Forma de las detecciones: {detections.shape}\n"
         except Exception as e:
-            print(f"Error al procesar la imagen con el modelo DNN: {str(e)}")
-            # En caso de error, devolver lista vacía
-            print("Error en la detección de rostros. No se pudo procesar la imagen.")
+            log_info += f"ERROR en forward pass: {str(e)}\n"
+            with open("diagnostico_deteccion.txt", "a") as f:
+                f.write(log_info)
+            print(log_info)
             # Intentar con Haar cascade como respaldo
             print("Intentando detección con Haar cascade como respaldo...")
             return detect_face_haar(frame, conf_threshold)
@@ -162,9 +187,12 @@ def main():
         
         # Procesar cada detección
         detection_count = 0
+        detection_info = []
+        
         for i in range(detections.shape[2]):
             # Extraer la confianza (probabilidad) de la detección
             confidence = detections[0, 0, i, 2]
+            detection_info.append(f"  {i}: confianza={confidence:.3f}")
             
             # Filtrar detecciones débiles por confianza (usando el umbral interno más bajo)
             if confidence > internal_threshold:
@@ -182,32 +210,33 @@ def main():
                 
                 # Imprimir información de depuración
                 print(f"Detección #{detection_count}: confianza={confidence:.3f}, bbox=[{x1},{y1},{x2},{y2}]")
+                detection_info[i] += f", bbox=[{x1},{y1},{x2},{y2}]"
                 
                 # Saltar cajas inválidas (por ejemplo, con ancho o alto negativo)
                 width, height = x2 - x1, y2 - y1
                 if width <= 0 or height <= 0:
                     print(f"Saltando caja inválida con dimensiones: {width}x{height}")
+                    detection_info[i] += f" - INVÁLIDA: dimensiones {width}x{height}"
                     continue
                 
                 # Añadir la caja y la confianza a la lista de resultados
                 bboxes.append([x1, y1, x2, y2, confidence])
+                detection_info[i] += " - AÑADIDA"
+        
+        # Añadir información de detecciones al log
+        log_info += f"Detecciones totales analizadas: {detections.shape[2]}\n"
+        log_info += "Detalles de detecciones:\n"
+        for info in detection_info:
+            log_info += f"{info}\n"
         
         # Dar feedback sobre el número de detecciones
-        print(f"Total de detecciones con confianza > {internal_threshold}: {detection_count}")
-        print(f"Total de cajas válidas: {len(bboxes)}")
+        log_info += f"Total de detecciones con confianza > {internal_threshold}: {detection_count}\n"
+        log_info += f"Total de cajas válidas: {len(bboxes)}\n"
         
         # Si no se encontraron rostros, intentar con Haar cascade
         if not bboxes:
-            print(f"No se detectaron rostros con confianza > {internal_threshold}")
-            print("Intentando detección con Haar cascade como respaldo...")
-            haar_bboxes = detect_face_haar(frame, conf_threshold)
-            if haar_bboxes and len(haar_bboxes) > 0:
-                print(f"Haar cascade encontró {len(haar_bboxes)} rostro(s)")
-                return haar_bboxes
-            print("Sugerencias para mejorar la detección:")
-            print("1. Ajustar la iluminación - evitar contraluces")
-            print("2. Mirar directamente a la cámara")
-            print("3. Verificar que la cámara esté enfocada")
+            log_info += "NO SE DETECTARON ROSTROS CON DNN\n"
+            log_info += "Intentando detección con Haar cascade como respaldo...\n"
             
             # Verificar si hay detecciones con umbral más bajo para depuración
             for i in range(detections.shape[2]):
@@ -215,10 +244,37 @@ def main():
                 if confidence > 0.05:  # Umbral muy bajo para depuración
                     box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                     x1, y1, x2, y2 = box.astype("int")
-                    print(f"Detección de baja confianza: {confidence:.3f} en [{x1},{y1},{x2},{y2}]")
+                    log_info += f"Detección de baja confianza: {confidence:.3f} en [{x1},{y1},{x2},{y2}]\n"
+            
+            # Intentar detección Haar
+            haar_bboxes = detect_face_haar(frame, conf_threshold)
+            if haar_bboxes and len(haar_bboxes) > 0:
+                log_info += f"Haar cascade encontró {len(haar_bboxes)} rostro(s)\n"
+                log_info += f"Haar bboxes: {haar_bboxes}\n"
+                
+                # Guardar diagnóstico en archivo
+                with open("diagnostico_deteccion.txt", "a") as f:
+                    f.write(log_info)
+                print(log_info)
+                return haar_bboxes
+                
+            log_info += "Haar cascade NO detectó rostros\n"
             
+            # Guardar diagnóstico en archivo cuando no hay detecciones
+            with open("diagnostico_deteccion.txt", "a") as f:
+                f.write(log_info)
+            print(log_info)
             return []
         
+        # Si llegamos aquí, hay detecciones exitosas
+        log_info += f"Detección exitosa. Retornando {len(bboxes)} bounding boxes.\n"
+        log_info += f"Bounding boxes: {bboxes}\n"
+        
+        # Guardar diagnóstico en archivo
+        with open("diagnostico_deteccion.txt", "a") as f:
+            f.write(log_info)
+        print(log_info)
+        
         # Devolver las cajas detectadas
         return bboxes
 
@@ -3162,6 +3218,78 @@ def main():
                 st.markdown("---")
                 st.markdown("**Privacy Note**: Video is processed in your browser and on the server. No video data is stored permanently.")
 
+                # Agregar opción para cargar imagen desde URL
+                use_url = st.checkbox("Load image from URL")
+                
+                # Diagnóstico para verificar modelos
+                with st.expander("🔍 Diagnóstico de detección", expanded=False):
+                    st.warning("Si los rectángulos no aparecen, usa esta herramienta para verificar que los modelos de detección están funcionando correctamente.")
+                    col1, col2 = st.columns(2)
+                    
+                    if col1.button("Ver diagnóstico de detección"):
+                        try:
+                            with open("diagnostico_deteccion.txt", "r") as f:
+                                diagnostico = f.read()
+                            st.code(diagnostico, language="text")
+                        except FileNotFoundError:
+                            st.info("Aún no hay información de diagnóstico disponible. Procesa una imagen primero.")
+                    
+                    if col2.button("Verificar modelo"):
+                        st.info("Verificando modelo de detección facial...")
+                        
+                        # Verificar si el modelo está cargado correctamente
+                        try:
+                            if 'face_net' in locals():
+                                st.success(f"Modelo cargado: {type(face_net)}")
+                                st.json({"Modelo": str(type(face_net)),
+                                        "Estado": "Cargado correctamente",
+                                        "Archivo del modelo": "res10_300x300_ssd_iter_140000.caffemodel",
+                                        "Archivo de configuración": "deploy.prototxt.txt"})
+                            else:
+                                face_net = load_face_model()
+                                st.success(f"Modelo cargado durante verificación: {type(face_net)}")
+                        except Exception as e:
+                            st.error(f"Error al verificar modelo: {str(e)}")
+                
+                if use_url:
+                    # Agregar campo de URL
+                    url = st.text_input("Enter image URL")
+                    
+                    if st.button("Load Image from URL"):
+                        try:
+                            # Cargar imagen desde URL
+                            response = urllib.request.urlopen(url)
+                            image_data = response.read()
+                            image = cv2.imdecode(np.frombuffer(image_data, np.uint8), cv2.IMREAD_COLOR)
+                            
+                            if image is not None and image.size > 0:
+                                # Detectar rostros
+                                bboxes = detect_face_dnn(face_net, image, conf_threshold)
+                                
+                                if bboxes:
+                                    # Mostrar imagen con rostros detectados
+                                    st.image(image, channels='BGR', caption="Detected faces")
+                                    
+                                    # Mostrar estadísticas
+                                    st.subheader("Detection Summary")
+                                    summary_col1, summary_col2, summary_col3 = st.columns(3)
+                                    summary_col1.metric("Faces Detected", len(bboxes))
+                                    summary_col2.metric("Eyes Detected", 0)
+                                    summary_col3.metric("Smiles Detected", 0)
+                                    
+                                    # Mostrar cajas detectadas
+                                    st.subheader("Detected Faces")
+                                    for i, bbox in enumerate(bboxes):
+                                        x1, y1, x2, y2, _ = bbox
+                                        cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                                        cv2.putText(image, f"Face {i+1}", (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+                                else:
+                                    st.warning("No faces detected. Please try a different URL.")
+                            else:
+                                st.warning("Failed to load image. Please check the URL.")
+                        except Exception as e:
+                            st.error(f"Error loading image from URL: {str(e)}")
+
 # Si se ejecuta este archivo directamente, llamar a la función main
 if __name__ == "__main__":
     main()