Agregar herramientas de diagnóstico y script de detección de rostros independiente

detect_face_continuous.py

@@ -0,0 +1,104 @@
+import cv2
+import numpy as np
+
+def detect_face_dnn(net, frame, conf_threshold=0.5):
+    """
+    Detecta rostros en una imagen utilizando un modelo DNN pre-entrenado
+    y devuelve los cuadros delimitadores.
+    """
+    frameHeight = frame.shape[0]
+    frameWidth = frame.shape[1]
+    
+    # Crear un blob a partir de la imagen
+    blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300), [104, 117, 123], False, False)
+    
+    # Establecer la entrada para la red neuronal
+    net.setInput(blob)
+    
+    # Ejecutar la detección
+    detections = net.forward()
+    
+    bboxes = []
+    
+    # Procesar las detecciones
+    for i in range(detections.shape[2]):
+        confidence = detections[0, 0, i, 2]
+        
+        # Filtrar por umbral de confianza
+        if confidence > conf_threshold:
+            x1 = int(detections[0, 0, i, 3] * frameWidth)
+            y1 = int(detections[0, 0, i, 4] * frameHeight)
+            x2 = int(detections[0, 0, i, 5] * frameWidth)
+            y2 = int(detections[0, 0, i, 6] * frameHeight)
+            
+            # Asegurarse de que las coordenadas están dentro de los límites de la imagen
+            x1 = max(0, min(x1, frameWidth - 1))
+            y1 = max(0, min(y1, frameHeight - 1))
+            x2 = max(0, min(x2, frameWidth - 1))
+            y2 = max(0, min(y2, frameHeight - 1))
+            
+            # Agregar los cuadros delimitadores y la confianza
+            bboxes.append([x1, y1, x2, y2, confidence])
+    
+    return np.array(bboxes)
+
+def main():
+    # Cargar el modelo de detección de rostros
+    modelFile = "models/opencv_face_detector_uint8.pb"
+    configFile = "models/opencv_face_detector.pbtxt"
+    net = cv2.dnn.readNetFromTensorflow(modelFile, configFile)
+    
+    # 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.")
+    
+    while True:
+        # Leer un frame de la cámara
+        ret, frame = cap.read()
+        
+        if not ret:
+            print("Error al capturar el frame.")
+            break
+        
+        # Detectar rostros con umbrales de confianza diferentes
+        for threshold in [0.5, 0.3, 0.1]:
+            bboxes = detect_face_dnn(net, frame, threshold)
+            
+            # Crear copia del frame para dibujar en ella
+            display_frame = frame.copy()
+            
+            # Dibujar los cuadros delimitadores
+            for i, bbox in enumerate(bboxes):
+                x1, y1, x2, y2, conf = bbox
+                # Usar color verde
+                color = (0, 255, 0)
+                # Dibujar el rectángulo
+                cv2.rectangle(display_frame, (int(x1), int(y1)), (int(x2), int(y2)), color, 2)
+                # Mostrar la confianza
+                label = f"Rostro: {conf:.2f}"
+                cv2.putText(display_frame, label, (int(x1), int(y1) - 10), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+            
+            # Mostrar el número de rostros detectados en la esquina
+            cv2.putText(display_frame, f"Umbral: {threshold} - Rostros: {len(bboxes)}", 
+                      (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+            
+            # Mostrar el resultado
+            window_name = f"Detección de Rostros (Umbral: {threshold})"
+            cv2.imshow(window_name, display_frame)
+        
+        # Salir si se presiona 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    
+    # Liberar recursos
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main() 

streamlit_app.py

@@ -2443,22 +2443,28 @@ def main():
                             const displayCtx = display.getContext('2d');
                             let captureInterval;
                             
+                            // Para depuración
+                            console.log('Componente de cámara inicializado');
+                            
                             // Configuración dinámica del FPS (desde Streamlit)
                             const captureDelay = 1000 / %s;
                             
                             // Iniciar la cámara
                             async function setupCamera() {
                                 try {
+                                    console.log('Intentando acceder a la cámara...');
                                     const stream = await navigator.mediaDevices.getUserMedia({
                                         'video': { width: 640, height: 480 },
                                         'audio': false
                                     });
                                     video.srcObject = stream;
+                                    console.log('Cámara iniciada correctamente');
                                     
                                     // Esperar a que la cámara esté lista
                                     return new Promise((resolve) => {
                                         video.onloadedmetadata = () => {
                                             video.play();
+                                            console.log('Video iniciado');
                                             resolve(video);
                                         };
                                     });
@@ -2489,6 +2495,11 @@ def main():
                                 }
                             }
                             
+                            // Debug para todos los mensajes recibidos
+                            window.addEventListener('message', function(event) {
+                                console.log('Mensaje recibido:', event.data);
+                            });
+                            
                             // Recibir datos de detección de rostros y dibujarlos
                             window.addEventListener('message', function(event) {
                                 try {
@@ -2504,6 +2515,7 @@ def main():
                                         
                                         // Dibujar cada caja
                                         if (boxes && boxes.length > 0) {
+                                            console.log(`Dibujando ${boxes.length} cajas de rostros`);
                                             boxes.forEach(box => {
                                                 if (box && box.length >= 5) {
                                                     const [x1, y1, x2, y2, confidence] = box;
@@ -2518,8 +2530,12 @@ def main():
                                                     displayCtx.fillStyle = '#00FF00';
                                                     displayCtx.font = '16px Arial';
                                                     displayCtx.fillText(`Rostro: ${confidence.toFixed(2)}`, x1, y1-5);
+                                                } else {
+                                                    console.warn('Formato de caja inválido:', box);
                                                 }
                                             });
+                                        } else {
+                                            console.log('No hay cajas para dibujar o formato inválido');
                                         }
                                     }
                                 } catch (error) {
@@ -2527,11 +2543,25 @@ def main():
                                 }
                             });
                             
+                            // Dibujar un rectángulo de prueba para verificar que el canvas funciona
+                            function drawTestRect() {
+                                displayCtx.strokeStyle = '#FF0000';
+                                displayCtx.lineWidth = 3;
+                                displayCtx.strokeRect(50, 50, 100, 100);
+                                displayCtx.fillStyle = '#FF0000';
+                                displayCtx.font = '16px Arial';
+                                displayCtx.fillText('Test Rectangle', 50, 40);
+                                console.log('Rectángulo de prueba dibujado');
+                            }
+                            
                             // Arrancar todo
                             async function initCapture() {
                                 await setupCamera();
+                                // Dibujar rectángulo de prueba
+                                setTimeout(drawTestRect, 1000);
                                 // Empezar a capturar frames periódicamente
                                 captureInterval = setInterval(captureFrame, captureDelay);
+                                console.log(`Captura iniciada con intervalo de ${captureDelay}ms`);
                             }
                             
                             // Limpiar al salir
@@ -2540,6 +2570,7 @@ def main():
                                 if (video.srcObject) {
                                     video.srcObject.getTracks().forEach(track => track.stop());
                                 }
+                                console.log('Captura detenida');
                             }
                             
                             // Iniciar captura automáticamente
@@ -2590,6 +2621,9 @@ def main():
                                             # Convertir a lista si es un array numpy
                                             bbox_list = bboxes.tolist() if isinstance(bboxes, np.ndarray) else bboxes
                                             
+                                            # Imprimir en el servidor para depuración
+                                            print(f"Cajas de rostros detectadas: {bbox_list}")
+                                            
                                             # Crear script para enviar datos al componente JavaScript
                                             face_boxes_js = f"""
                                             <script>
@@ -2600,6 +2634,17 @@ def main():
                                                         type: 'faceBoxes',
                                                         boxes: {json.dumps(bbox_list)}
                                                     }}, '*');
+                                                    
+                                                    // Intentar también con window.parent para casos en iframe
+                                                    try {{
+                                                        window.parent.postMessage({{
+                                                            type: 'faceBoxes',
+                                                            boxes: {json.dumps(bbox_list)}
+                                                        }}, '*');
+                                                        console.log('Mensaje también enviado a window.parent');
+                                                    }} catch(e) {{
+                                                        console.error('Error enviando a window.parent:', e);
+                                                    }}
                                                 }})();
                                             </script>
                                             """