Mejora deteccion facial

streamlit_app.py

@@ -117,6 +117,7 @@ def main():
     def detect_face_dnn(net, frame, conf_threshold=0.3):
         """
         Detecta rostros en una imagen utilizando un modelo DNN pre-entrenado.
+        Si no se detectan rostros, usa automáticamente Haar Cascades como respaldo.
         
         Args:
             net: Modelo DNN cargado
@@ -134,7 +135,7 @@ def main():
         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
+        internal_threshold = 0.05  # 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}")
@@ -156,7 +157,7 @@ def main():
             with open("diagnostico_deteccion.txt", "a") as f:
                 f.write(log_info)
             print(log_info)
-            return []
+            return detect_face_haar(frame, conf_threshold)
         
         # Pasar el blob a través de la red
         try:
@@ -167,7 +168,7 @@ def main():
             with open("diagnostico_deteccion.txt", "a") as f:
                 f.write(log_info)
             print(log_info)
-            return []
+            return detect_face_haar(frame, conf_threshold)
         
         # Realizar la detección (forward pass)
         try:
@@ -241,7 +242,7 @@ def main():
             # Verificar si hay detecciones con umbral más bajo para depuración
             for i in range(detections.shape[2]):
                 confidence = detections[0, 0, i, 2]
-                if confidence > 0.05:  # Umbral muy bajo para depuración
+                if confidence > 0.01:  # Umbral extremadamente bajo para depuración
                     box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
                     x1, y1, x2, y2 = box.astype("int")
                     log_info += f"Detección de baja confianza: {confidence:.3f} en [{x1},{y1},{x2},{y2}]\n"
@@ -295,38 +296,48 @@ def main():
             # Ecualizar el histograma para mejorar contraste
             gray = cv2.equalizeHist(gray)
             
-            # Detectar rostros - la confianza se controla con minNeighbors
-            # Usamos el umbral de confianza como guía para minNeighbors
-            min_neighbors = max(3, int(conf_threshold * 10))
+            # Parámetros más sensibles para la detección con Haar
+            scale_factor = 1.05  # Más lento pero más preciso (era 1.1)
+            min_neighbors = 3    # Valor más bajo, más detecciones pero más falsos positivos (era 5)
+            min_size = (20, 20)  # Tamaño mínimo más pequeño (era 30, 30)
+            
+            # Detectar rostros con clasificador Haar
             faces = st.session_state.haar_face_cascade.detectMultiScale(
                 gray,
-                scaleFactor=1.1,
+                scaleFactor=scale_factor,
                 minNeighbors=min_neighbors,
-                minSize=(30, 30),
+                minSize=min_size,
                 flags=cv2.CASCADE_SCALE_IMAGE
             )
             
-            print(f"Haar cascade found {len(faces)} faces")
-            
-            # Convertir al formato [x1, y1, x2, y2, confidence]
-            # Note que Haar Cascades no proporciona un valor de confianza real
+            # Convertir a formato bounding box [x1, y1, x2, y2, confianza]
             bboxes = []
             for (x, y, w, h) in faces:
-                # Usamos un valor fijo de confianza de 0.8 para Haar detections
-                # Esto es arbitrario pero útil para el procesamiento posterior
-                bboxes.append([x, y, x+w, y+h, 0.8])
+                # Usar un valor de confianza fijo para las detecciones Haar
+                confidence = 0.8  # Valor arbitrario alto
+                bboxes.append([x, y, x + w, y + h, confidence])
                 
-            return bboxes if bboxes else None
+            return bboxes
             
         except Exception as e:
-            print(f"Error en detect_face_haar: {str(e)}")
-            return None
+            print(f"Error en detección Haar: {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()
         
+        # Asegurar que bbox_color sea una tupla de 3 elementos para BGR
+        if isinstance(bbox_color, tuple) and len(bbox_color) == 3:
+            bbox_color_bgr = bbox_color
+        else:
+            # Usar verde como color predeterminado
+            bbox_color_bgr = (0, 255, 0)
+        
+        # Definir grosor para los rectángulos (más grueso para mejor visibilidad)
+        thickness = 3
+        
         # Procesar detecciones si son del formato original
         if isinstance(detections, np.ndarray) and len(detections.shape) == 4:
             bboxes = []
@@ -335,7 +346,12 @@ def main():
             
             for i in range(detections.shape[2]):
                 confidence = detections[0, 0, i, 2]
-                if confidence > conf_threshold:
+                print(f"Confidence: {confidence}, Threshold: {conf_threshold}")
+                
+                # Usar un umbral muy bajo para mejorar la detección
+                effective_threshold = max(0.05, conf_threshold)
+                
+                if confidence > effective_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)
@@ -347,29 +363,40 @@ def main():
                     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)
+                    # Verificar que el rectángulo es válido
+                    if x2 <= x1 or y2 <= y1:
+                        continue
+                    
+                    # Dibujar el bounding box con línea más gruesa
+                    cv2.rectangle(result_frame, (x1, y1), (x2, y2), bbox_color_bgr, thickness)
                     
                     # 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)
+                    cv2.putText(result_frame, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, bbox_color_bgr, 2)
                     
                     # 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
+            bboxes = detections if detections is not None else []
+            
             # 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)
+                    
+                    # Usar un umbral bajo para la visualización
+                    effective_threshold = max(0.05, conf_threshold)
+                    
+                    if confidence >= effective_threshold:
+                        # Verificar que las coordenadas son válidas
+                        if x1 >= 0 and y1 >= 0 and x2 > x1 and y2 > y1:
+                            # Dibujar el bounding box con línea más gruesa
+                            cv2.rectangle(result_frame, (x1, y1), (x2, y2), bbox_color_bgr, thickness)
+                            
+                            # Añadir texto con la confianza
+                            label = f"{confidence:.2f}"
+                            cv2.putText(result_frame, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, bbox_color_bgr, 2)
         
         return result_frame, bboxes
 
@@ -840,6 +867,19 @@ def main():
             # File uploader for images
             file_buffer = st.file_uploader("Upload an image", type=['jpg', 'jpeg', 'png'])
             
+            # Umbral de confianza ajustable
+            conf_threshold = st.slider(
+                "Umbral de confianza",
+                min_value=0.05,
+                max_value=0.95,
+                value=0.2,  # Valor por defecto más bajo (era 0.5)
+                step=0.05,
+                help="Ajusta este valor para controlar la sensibilidad de la detección facial. Un valor más bajo detecta más rostros pero puede tener falsos positivos."
+            )
+            
+            # Color del bounding box
+            bbox_color_bgr = (0, 255, 0)  # Verde brillante para mejor visibilidad
+            
             if file_buffer is not None:
                 # Read the file and convert it to OpenCV format
                 raw_bytes = np.asarray(bytearray(file_buffer.read()), dtype=np.uint8)
@@ -874,29 +914,18 @@ def main():
                     st.subheader("Processed Image")
                     st.image(processed_image, channels='BGR', use_container_width=True)
                     
+                    # Mostrar mensaje sobre lo que se está viendo
+                    if len(bboxes) > 0:
+                        st.success(f"Se detectaron {len(bboxes)} rostros en la imagen.")
+                    else:
+                        st.warning("No se detectaron rostros. Prueba ajustar el umbral de confianza o usar otra imagen.")
+                    
                     # Convert OpenCV image to PIL for download
                     pil_img = Image.fromarray(processed_image[:, :, ::-1])
                     st.markdown(
                         get_image_download_link(pil_img, "face_detection_result.jpg", "📥 Download Processed Image"),
                         unsafe_allow_html=True
                     )
-                
-                # Show metrics if enabled
-                if show_metrics:
-                    st.subheader("Processing Metrics")
-                    col1, col2, col3 = st.columns(3)
-                    col1.metric("Processing Time", f"{processing_time:.4f} seconds")
-                    col2.metric("Faces Detected", len(bboxes))
-                    col3.metric("Confidence Threshold", f"{conf_threshold:.2f}")
-                    
-                    # Display detailed metrics in an expandable section
-                    with st.expander("Detailed Detection Information"):
-                        if bboxes:
-                            st.write("Detected faces with confidence scores:")
-                            for i, bbox in enumerate(bboxes):
-                                st.write(f"Face #{i+1}: Confidence = {bbox[4]:.4f}")
-                        else:
-                            st.write("No faces detected in the image.")
         
         else:  # Video mode
             # Video mode options
@@ -1082,6 +1111,19 @@ def main():
             # File uploader for images
             file_buffer = st.file_uploader("Upload an image", type=['jpg', 'jpeg', 'png'])
             
+            # Umbral de confianza ajustable
+            conf_threshold = st.slider(
+                "Umbral de confianza",
+                min_value=0.05,
+                max_value=0.95,
+                value=0.2,  # Valor por defecto más bajo (era 0.5)
+                step=0.05,
+                help="Ajusta este valor para controlar la sensibilidad de la detección facial. Un valor más bajo detecta más rostros pero puede tener falsos positivos."
+            )
+            
+            # Color del bounding box
+            bbox_color_bgr = (0, 255, 0)  # Verde brillante para mejor visibilidad
+            
             if file_buffer is not None:
                 # Read the file and convert it to OpenCV format
                 raw_bytes = np.asarray(bytearray(file_buffer.read()), dtype=np.uint8)
@@ -1131,6 +1173,12 @@ def main():
                     st.subheader("Processed Image")
                     st.image(processed_image, channels='BGR', use_container_width=True)
                     
+                    # Mostrar mensaje sobre lo que se está viendo
+                    if len(bboxes) > 0:
+                        st.success(f"Se detectaron {len(bboxes)} rostros en la imagen.")
+                    else:
+                        st.warning("No se detectaron rostros. Prueba ajustar el umbral de confianza o usar otra imagen.")
+                    
                     # Convert OpenCV image to PIL for download
                     pil_img = Image.fromarray(processed_image[:, :, ::-1])
                     st.markdown(