Corregir error OpenCV de resize en detección de rostros

streamlit_app.py

@@ -114,45 +114,75 @@ def main():
 
     # Function for detecting faces in an image
     def detect_face_dnn(net, frame, conf_threshold=0.5):
-        blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300), [104, 117, 123], False, False)
-        net.setInput(blob)
-        detections = net.forward()
-        
-        # Procesar las detecciones para devolver una lista de bounding boxes
-        bboxes = []
-        frame_h = frame.shape[0]
-        frame_w = frame.shape[1]
-        
-        for i in range(detections.shape[2]):
-            confidence = detections[0, 0, i, 2]
-            if confidence > conf_threshold:
-                x1 = int(detections[0, 0, i, 3] * frame_w)
-                y1 = int(detections[0, 0, i, 4] * frame_h)
-                x2 = int(detections[0, 0, i, 5] * frame_w)
-                y2 = int(detections[0, 0, i, 6] * frame_h)
-                
-                # Asegurarse de que las coordenadas estén dentro de los límites de la imagen
-                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))
+        """
+        Detecta rostros usando el modelo DNN y devuelve las detecciones.
+        """
+        try:
+            # Verificar que el frame sea válido
+            if frame is None or frame.size == 0 or frame.shape[0] == 0 or frame.shape[1] == 0:
+                return []
                 
-                # Añadir el bounding box y la confianza
-                bboxes.append([x1, y1, x2, y2, confidence])
-        
-        return bboxes
+            # Crear blob a partir del frame (redimensionar a 300x300, escalar, etc.)
+            blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300), [104, 117, 123], False, False)
+            
+            # Establecer la entrada para la red neuronal
+            net.setInput(blob)
+            
+            # Realizar la detección
+            detections = net.forward()
+            
+            # Procesar las detecciones para devolver una lista de bounding boxes
+            bboxes = []
+            frame_h = frame.shape[0]
+            frame_w = frame.shape[1]
+            
+            for i in range(detections.shape[2]):
+                confidence = detections[0, 0, i, 2]
+                if confidence > conf_threshold:
+                    x1 = int(detections[0, 0, i, 3] * frame_w)
+                    y1 = int(detections[0, 0, i, 4] * frame_h)
+                    x2 = int(detections[0, 0, i, 5] * frame_w)
+                    y2 = int(detections[0, 0, i, 6] * frame_h)
+                    
+                    # Asegurarse de que las coordenadas estén dentro de los límites
+                    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))
+                    
+                    # Añadir el bounding box y la confianza
+                    bboxes.append([x1, y1, x2, y2, confidence])
+            
+            return bboxes
+        except Exception as e:
+            st.error(f"Error en la detección de rostros: {e}")
+            return []
 
     # Function for processing face detections
     def process_face_detections(frame, detections, conf_threshold=0.5, bbox_color=(0, 255, 0)):
         # Create a copy for drawing on
         result_frame = frame.copy()
         
-        # Filtrar detecciones por umbral de confianza
-        bboxes = []
-        for detection in detections:
-            if len(detection) == 5:  # Asegurarse de que la detección tiene el formato correcto
-                x1, y1, x2, y2, confidence = detection
-                if confidence >= conf_threshold:
+        # Procesar detecciones si son del formato original
+        if isinstance(detections, np.ndarray) and len(detections.shape) == 4:
+            bboxes = []
+            frame_h = frame.shape[0]
+            frame_w = frame.shape[1]
+            
+            for i in range(detections.shape[2]):
+                confidence = detections[0, 0, i, 2]
+                if confidence > conf_threshold:
+                    x1 = int(detections[0, 0, i, 3] * frame_w)
+                    y1 = int(detections[0, 0, i, 4] * frame_h)
+                    x2 = int(detections[0, 0, i, 5] * frame_w)
+                    y2 = int(detections[0, 0, i, 6] * frame_h)
+                    
+                    # Asegurarse de que las coordenadas estén dentro de los límites
+                    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))
+                    
                     # Dibujar el bounding box
                     cv2.rectangle(result_frame, (x1, y1), (x2, y2), bbox_color, 2)
                     
@@ -162,6 +192,20 @@ def main():
                     
                     # Añadir a la lista de bounding boxes
                     bboxes.append([x1, y1, x2, y2, confidence])
+        else:
+            # Si ya es una lista de bounding boxes (formato nuevo)
+            bboxes = detections
+            # Dibujar bounding boxes
+            for bbox in bboxes:
+                if len(bbox) == 5:  # Asegurarse de que el bounding box tiene el formato correcto
+                    x1, y1, x2, y2, confidence = bbox
+                    if confidence >= conf_threshold:
+                        # Dibujar el bounding box
+                        cv2.rectangle(result_frame, (x1, y1), (x2, y2), bbox_color, 2)
+                        
+                        # Añadir texto con la confianza
+                        label = f"{confidence:.2f}"
+                        cv2.putText(result_frame, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, bbox_color, 2)
         
         return result_frame, bboxes
 
@@ -2171,13 +2215,21 @@ def main():
                             return av.VideoFrame.from_ndarray(img, format="bgr24")
                         
                         try:
+                            # Verificar que la imagen no sea nula
+                            if img is None or img.size == 0 or img.shape[0] == 0 or img.shape[1] == 0:
+                                # Si la imagen es inválida, devolver un frame en blanco
+                                blank_frame = np.ones((480, 640, 3), dtype=np.uint8) * 255
+                                cv2.putText(blank_frame, "Error: Invalid frame", (50, 240), 
+                                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+                                return av.VideoFrame.from_ndarray(blank_frame, format="bgr24")
+                                
                             # Reducir tamaño del frame para procesamiento más rápido
                             scale_factor = 0.5
-                            small_img = cv2.resize(img, (0, 0), fx=scale_factor, fy=scale_factor)
+                            h, w = img.shape[:2]
+                            small_img = cv2.resize(img, (int(w * scale_factor), int(h * scale_factor)))
                             
-                            # Detect faces
-                            detections = detect_face_dnn(face_net, small_img, confidence_threshold)
-                            _, bboxes = process_face_detections(small_img, detections, confidence_threshold)
+                            # Detect faces - la función ahora devuelve directamente los bboxes
+                            bboxes = detect_face_dnn(face_net, small_img, confidence_threshold)
                             
                             # Ajustar bounding boxes al tamaño original
                             original_bboxes = []
@@ -2216,8 +2268,14 @@ def main():
                             return av.VideoFrame.from_ndarray(result_frame, format="bgr24")
                         
                         except Exception as e:
-                            print(f"Error en procesamiento de video: {e}")
-                            return av.VideoFrame.from_ndarray(img, format="bgr24")
+                            # En caso de cualquier error, mostrar mensaje en la imagen
+                            error_frame = np.ones((480, 640, 3), dtype=np.uint8) * 255
+                            error_msg = f"Error: {str(e)}"
+                            cv2.putText(error_frame, error_msg[:50], (20, 240), 
+                                      cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                            cv2.putText(error_frame, "Intente usar opciones alternativas", (20, 280), 
+                                      cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                            return av.VideoFrame.from_ndarray(error_frame, format="bgr24")
                 
                 # Display WebRTC streamer
                 webrtc_ctx = webrtc_streamer(