Agregar scripts de prueba para diagnóstico de detección facial

detect_face_test.py

@@ -0,0 +1,197 @@
+import cv2
+import numpy as np
+import time
+
+def main():
+    """
+    Script para probar la detección de rostros con diferentes configuraciones
+    y visualizar claramente los resultados.
+    """
+    print("Iniciando prueba de detección facial...")
+    
+    # Cargar el modelo DNN preentrenado para detección de rostros
+    print("Cargando modelo DNN para detección facial...")
+    
+    # Usar el modelo Caffe
+    modelFile = "models/deploy.prototxt"
+    weightsFile = "models/res10_300x300_ssd_iter_140000_fp16.caffemodel"
+    
+    try:
+        face_net = cv2.dnn.readNetFromCaffe(modelFile, weightsFile)
+        print("Modelo DNN cargado correctamente.")
+    except Exception as e:
+        print(f"Error al cargar el modelo DNN: {str(e)}")
+        print("Intentando usar detección Haar en su lugar...")
+        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        if face_cascade.empty():
+            print("Error: No se pudo cargar el clasificador Haar.")
+            return
+        use_dnn = False
+    else:
+        use_dnn = True
+    
+    # Iniciar la cámara
+    cap = cv2.VideoCapture(0)
+    
+    if not cap.isOpened():
+        print("Error: No se pudo abrir la cámara.")
+        return
+    
+    print("Cámara iniciada correctamente. Presione 'q' para salir, 's' para guardar una captura.")
+    
+    # Contador de frames
+    frame_count = 0
+    start_time = time.time()
+    
+    # Umbrales de confianza para probar
+    confidence_thresholds = [0.5, 0.3, 0.1]
+    current_threshold_index = 0
+    current_threshold = confidence_thresholds[current_threshold_index]
+    
+    def detect_face_dnn(net, frame, conf_threshold=0.5):
+        # Preparar la imagen para la red (redimensionar a 300x300 y normalizar)
+        h, w = frame.shape[:2]
+        blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 1.0,
+                                     (300, 300), (104.0, 177.0, 123.0))
+        
+        # Pasar la imagen a través de la red
+        net.setInput(blob)
+        detections = net.forward()
+        
+        # Procesar las detecciones
+        bboxes = []
+        for i in range(detections.shape[2]):
+            confidence = detections[0, 0, i, 2]
+            
+            if confidence > conf_threshold:
+                # Obtener coordenadas de la caja delimitadora
+                box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
+                x1, y1, x2, y2 = box.astype("int")
+                
+                # Asegurarse de que las coordenadas estén dentro de la imagen
+                x1, y1 = max(0, x1), max(0, y1)
+                x2, y2 = min(w, x2), min(h, y2)
+                
+                # Añadir caja y confianza
+                bboxes.append([x1, y1, x2, y2, confidence])
+        
+        return bboxes if bboxes else None
+    
+    def detect_face_haar(face_cascade, frame, scale_factor=1.1):
+        # Convertir a escala de grises para la detección Haar
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        # Detectar rostros
+        faces = face_cascade.detectMultiScale(
+            gray,
+            scaleFactor=scale_factor,
+            minNeighbors=5,
+            minSize=(30, 30),
+            flags=cv2.CASCADE_SCALE_IMAGE
+        )
+        
+        if len(faces) == 0:
+            return None
+            
+        # Convertir al mismo formato que el DNN
+        bboxes = []
+        for (x, y, w, h) in faces:
+            bboxes.append([x, y, x+w, y+h, 1.0])  # Confianza simulada de 1.0
+            
+        return bboxes
+    
+    while True:
+        # Leer un frame de la cámara
+        ret, frame = cap.read()
+        
+        if not ret:
+            print("Error al capturar el frame.")
+            break
+        
+        # Incrementar contador
+        frame_count += 1
+        elapsed = time.time() - start_time
+        fps = frame_count / elapsed if elapsed > 0 else 0
+        
+        # Crear copia del frame para dibujar
+        display_frame = frame.copy()
+        
+        # Detectar rostros según el método seleccionado
+        if use_dnn:
+            bboxes = detect_face_dnn(face_net, frame, current_threshold)
+            method_text = f"DNN (Conf: {current_threshold})"
+        else:
+            bboxes = detect_face_haar(face_cascade, frame)
+            method_text = "Haar Cascade"
+        
+        # Dibujar los rostros detectados
+        if bboxes is not None:
+            for box in bboxes:
+                x1, y1, x2, y2 = int(box[0]), int(box[1]), int(box[2]), int(box[3])
+                
+                # Dibujar rectángulo verde grueso
+                cv2.rectangle(display_frame, (x1, y1), (x2, y2), (0, 255, 0), 3)
+                
+                # Mostrar confianza
+                if len(box) > 4:
+                    conf = box[4]
+                    cv2.putText(display_frame, f"Conf: {conf:.2f}", (x1, y1 - 10),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+            
+            face_count = len(bboxes)
+            status = f"Detectados: {face_count}"
+        else:
+            status = "No se detectaron rostros"
+        
+        # Dibujar información en pantalla
+        h, w = display_frame.shape[:2]
+        
+        # Método de detección
+        cv2.putText(display_frame, f"Método: {method_text}", (10, 30),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
+        
+        # Estado de detección
+        cv2.putText(display_frame, status, (10, 70),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+        
+        # FPS
+        cv2.putText(display_frame, f"FPS: {fps:.1f}", (10, h - 20),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)
+        
+        # Rectángulo de prueba en la esquina superior derecha
+        cv2.rectangle(display_frame, (w-150, 50), (w-50, 150), (0, 0, 255), 3)
+        cv2.putText(display_frame, "TEST", (w-130, 40),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+        
+        # Mostrar resultado
+        cv2.imshow("Prueba de Detección Facial", display_frame)
+        
+        # Manejo de teclas
+        key = cv2.waitKey(1) & 0xFF
+        
+        # Salir si se presiona 'q'
+        if key == ord('q'):
+            break
+        # Cambiar umbral si se presiona 't'
+        elif key == ord('t'):
+            current_threshold_index = (current_threshold_index + 1) % len(confidence_thresholds)
+            current_threshold = confidence_thresholds[current_threshold_index]
+            print(f"Umbral cambiado a: {current_threshold}")
+        # Guardar imagen si se presiona 's'
+        elif key == ord('s'):
+            timestamp = time.strftime("%Y%m%d-%H%M%S")
+            filename = f"face_detection_{timestamp}.jpg"
+            cv2.imwrite(filename, display_frame)
+            print(f"Imagen guardada como {filename}")
+    
+    # Imprime estadísticas
+    print(f"Frames totales: {frame_count}")
+    print(f"Tiempo total: {elapsed:.2f} segundos")
+    print(f"FPS promedio: {fps:.1f}")
+    
+    # Liberar recursos
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main() 

direct_detection.py

@@ -0,0 +1,94 @@
+import cv2
+import time
+
+def main():
+    """
+    Script simple para probar la captura de cámara y dibujo de rectángulos en tiempo real.
+    Este script no realiza detección facial, solo dibuja rectángulos predefinidos
+    para verificar que el hardware y la visualización funcionan correctamente.
+    """
+    print("Iniciando prueba de cámara directa...")
+    
+    # Iniciar la cámara
+    cap = cv2.VideoCapture(0)
+    
+    if not cap.isOpened():
+        print("Error: No se pudo abrir la cámara. Verifica la conexión y permisos.")
+        return
+    
+    print("Cámara iniciada. Presiona 'q' para salir.")
+    
+    # Contador de frames
+    frame_count = 0
+    start_time = time.time()
+    
+    # Rectángulo fijo en el centro (simulando detección)
+    rect_size = 200
+    
+    while True:
+        # Capturar frame
+        ret, frame = cap.read()
+        
+        if not ret:
+            print("Error: No se pudo leer el frame. La cámara podría estar desconectada.")
+            break
+        
+        # Conteo de FPS
+        frame_count += 1
+        elapsed_time = time.time() - start_time
+        fps = frame_count / elapsed_time if elapsed_time > 0 else 0
+        
+        # Obtener dimensiones del frame
+        height, width, _ = frame.shape
+        
+        # Crear una copia para dibujar
+        display = frame.copy()
+        
+        # Dibujar rectángulo central fijo (simulando detección facial)
+        center_x, center_y = width // 2, height // 2
+        x1 = center_x - rect_size // 2
+        y1 = center_y - rect_size // 2
+        x2 = center_x + rect_size // 2
+        y2 = center_y + rect_size // 2
+        
+        # Dibujar con color verde y grosor 3
+        cv2.rectangle(display, (x1, y1), (x2, y2), (0, 255, 0), 3)
+        cv2.putText(display, "ROSTRO SIMULADO", (x1, y1 - 10), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+        
+        # Dibujar un segundo rectángulo en la esquina (para verificar que se dibujan correctamente)
+        cv2.rectangle(display, (50, 50), (200, 200), (0, 0, 255), 3)
+        cv2.putText(display, "PRUEBA", (50, 40), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+        
+        # Mostrar información de FPS
+        cv2.putText(display, f"FPS: {fps:.1f}", (10, height - 30), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        # Mostrar número de frame
+        cv2.putText(display, f"Frame: {frame_count}", (10, height - 60), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        # Mostrar timestamp
+        timestamp = time.strftime("%H:%M:%S")
+        cv2.putText(display, f"Hora: {timestamp}", (width - 200, height - 30), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        # Mostrar resultado
+        cv2.imshow("Prueba de Visualización", display)
+        
+        # Salir si se presiona 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    
+    # Mostrar estadísticas
+    print(f"Frames capturados: {frame_count}")
+    print(f"Tiempo de ejecución: {elapsed_time:.2f} segundos")
+    print(f"FPS promedio: {fps:.2f}")
+    
+    # Liberar recursos
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()