Mejorado detector facial y control de flujo para imágenes con demasiados rostros

app.py

@@ -302,100 +302,103 @@ elif page == "Visual Analysis":
             display_face_validation_result(face_validation_result, img_array)
             
             # Only continue if we don't have too many faces
-            if should_continue_processing():
-                # 2. Validar dimensiones (como en la versión local)
-                try:
-                    dimension_result = img_service.validate_image_dimensions(img_array)
-                    # Asegurarnos de que dimension_result contiene las claves necesarias
-                    if not isinstance(dimension_result, dict):
-                        dimension_result = {}
-                    
-                    # Asegurarnos de que contiene las claves necesarias
-                    if "width" not in dimension_result:
-                        height, width = img_array.shape[:2]
-                        dimension_result["width"] = width
-                        dimension_result["height"] = height
-                    
-                    # Verificar si es óptimo basado en las dimensiones (si no existe ya la clave)
-                    if "is_optimal" not in dimension_result:
-                        width = dimension_result["width"]
-                        height = dimension_result["height"]
-                        dimension_result["is_optimal"] = width >= 640 and height >= 480
-                except Exception as e:
-                    st.error(f"Error validating dimensions: {str(e)}")
-                    # Crear un resultado predeterminado si hay un error
+            if not should_continue_processing():
+                # Si hay demasiados rostros, terminamos la ejecución aquí
+                st.stop()
+                
+            # 2. Validar dimensiones (como en la versión local)
+            try:
+                dimension_result = img_service.validate_image_dimensions(img_array)
+                # Asegurarnos de que dimension_result contiene las claves necesarias
+                if not isinstance(dimension_result, dict):
+                    dimension_result = {}
+                
+                # Asegurarnos de que contiene las claves necesarias
+                if "width" not in dimension_result:
                     height, width = img_array.shape[:2]
-                    dimension_result = {
-                        "width": width,
-                        "height": height,
-                        "is_optimal": width >= 640 and height >= 480
-                    }
+                    dimension_result["width"] = width
+                    dimension_result["height"] = height
                 
-                # 3. Evaluar calidad (como en la versión local)
-                try:
-                    quality_result = img_service.check_image_quality(img_array)
-                    # Asegurarnos de que quality_result contiene las claves necesarias
-                    if not isinstance(quality_result, dict):
-                        quality_result = {}
-                    
-                    # Añadir claves faltantes si es necesario
-                    if "score" not in quality_result:
-                        quality_result["score"] = 50  # Valor predeterminado
-                    
-                    if "label" not in quality_result:
-                        score = quality_result["score"]
-                        if score >= 70:
-                            quality_result["label"] = "Good"
-                        elif score >= 40:
-                            quality_result["label"] = "Fair"
-                        else:
-                            quality_result["label"] = "Poor"
-                    
-                    if "brightness" not in quality_result:
-                        # Calcular brillo si no existe
-                        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-                        quality_result["brightness"] = np.mean(gray) / 2.55  # Convertir a porcentaje
-                    
-                    if "contrast" not in quality_result:
-                        # Calcular contraste si no existe
-                        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-                        quality_result["contrast"] = np.std(gray) / 2.55  # Convertir a porcentaje
-                    
-                    if "sharpness_label" not in quality_result:
-                        quality_result["sharpness_label"] = "Good"  # Valor predeterminado
-                    
-                    if "recommendations" not in quality_result:
-                        quality_result["recommendations"] = []
-                except Exception as e:
-                    st.error(f"Error checking quality: {str(e)}")
-                    # Crear un resultado predeterminado si hay un error
-                    quality_result = {
-                        "score": 50,
-                        "label": "Fair",
-                        "brightness": 50,
-                        "contrast": 30,
-                        "sharpness_label": "Fair",
-                        "recommendations": ["Use a clearer image for better analysis."]
-                    }
+                # Verificar si es óptimo basado en las dimensiones (si no existe ya la clave)
+                if "is_optimal" not in dimension_result:
+                    width = dimension_result["width"]
+                    height = dimension_result["height"]
+                    dimension_result["is_optimal"] = width >= 640 and height >= 480
+            except Exception as e:
+                st.error(f"Error validating dimensions: {str(e)}")
+                # Crear un resultado predeterminado si hay un error
+                height, width = img_array.shape[:2]
+                dimension_result = {
+                    "width": width,
+                    "height": height,
+                    "is_optimal": width >= 640 and height >= 480
+                }
+            
+            # 3. Evaluar calidad (como en la versión local)
+            try:
+                quality_result = img_service.check_image_quality(img_array)
+                # Asegurarnos de que quality_result contiene las claves necesarias
+                if not isinstance(quality_result, dict):
+                    quality_result = {}
+                
+                # Añadir claves faltantes si es necesario
+                if "score" not in quality_result:
+                    quality_result["score"] = 50  # Valor predeterminado
+                
+                if "label" not in quality_result:
+                    score = quality_result["score"]
+                    if score >= 70:
+                        quality_result["label"] = "Good"
+                    elif score >= 40:
+                        quality_result["label"] = "Fair"
+                    else:
+                        quality_result["label"] = "Poor"
                 
-                # Guardar la imagen en session_state para mantener consistencia
-                st.session_state.original_image = img_array
+                if "brightness" not in quality_result:
+                    # Calcular brillo si no existe
+                    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+                    quality_result["brightness"] = np.mean(gray) / 2.55  # Convertir a porcentaje
                 
-                # 4. Verificar si se debe usar imagen mejorada
-                use_improved = "use_improved_image" in st.session_state and st.session_state["use_improved_image"]
-                img_to_process = img_array  # Por defecto usamos la imagen original
+                if "contrast" not in quality_result:
+                    # Calcular contraste si no existe
+                    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+                    quality_result["contrast"] = np.std(gray) / 2.55  # Convertir a porcentaje
                 
-                if use_improved:
-                    try:
-                        # Convertir a BGR para procesamiento OpenCV
-                        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
-                        # Aplicar técnicas avanzadas de preprocesamiento
-                        enhanced_bgr = img_service.enhance_image_for_facial_detection(img_bgr)
-                        # Convertir de vuelta a RGB
-                        img_to_process = cv2.cvtColor(enhanced_bgr, cv2.COLOR_BGR2RGB)
-                    except Exception as e:
-                        st.warning(f"Could not apply advanced image enhancements: {str(e)}")
-                        # Ya tenemos img_to_process = img_array por defecto, no necesitamos asignarlo de nuevo
+                if "sharpness_label" not in quality_result:
+                    quality_result["sharpness_label"] = "Good"  # Valor predeterminado
+                
+                if "recommendations" not in quality_result:
+                    quality_result["recommendations"] = []
+            except Exception as e:
+                st.error(f"Error checking quality: {str(e)}")
+                # Crear un resultado predeterminado si hay un error
+                quality_result = {
+                    "score": 50,
+                    "label": "Fair",
+                    "brightness": 50,
+                    "contrast": 30,
+                    "sharpness_label": "Fair",
+                    "recommendations": ["Use a clearer image for better analysis."]
+                }
+            
+            # Guardar la imagen en session_state para mantener consistencia
+            st.session_state.original_image = img_array
+            
+            # 4. Verificar si se debe usar imagen mejorada
+            use_improved = "use_improved_image" in st.session_state and st.session_state["use_improved_image"]
+            img_to_process = img_array  # Por defecto usamos la imagen original
+            
+            if use_improved:
+                try:
+                    # Convertir a BGR para procesamiento OpenCV
+                    img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+                    # Aplicar técnicas avanzadas de preprocesamiento
+                    enhanced_bgr = img_service.enhance_image_for_facial_detection(img_bgr)
+                    # Convertir de vuelta a RGB
+                    img_to_process = cv2.cvtColor(enhanced_bgr, cv2.COLOR_BGR2RGB)
+                except Exception as e:
+                    st.warning(f"Could not apply advanced image enhancements: {str(e)}")
+                    # Ya tenemos img_to_process = img_array por defecto, no necesitamos asignarlo de nuevo
         
         except Exception as e:
             st.error(f"Error processing image: {str(e)}")

services/face_service.py

@@ -64,9 +64,9 @@ class FaceDetectionService:
             # Detect faces with optimized parameters for better detection
             faces = self.face_cascade.detectMultiScale(
                 gray,
-                scaleFactor=1.1,
-                minNeighbors=5,
-                minSize=(30, 30),
+                scaleFactor=1.2,  # Aumentado de 1.1 a 1.2 para reducir falsos positivos
+                minNeighbors=6,   # Aumentado de 5 a 6 para ser más selectivo
+                minSize=(50, 50), # Aumentado tamaño mínimo de 30x30 a 50x50
                 flags=cv2.CASCADE_SCALE_IMAGE
             )
             

utils/face_validation.py

@@ -97,4 +97,5 @@ def should_continue_processing() -> bool:
     Returns:
         Boolean indicating whether to continue processing
     """
-    return st.session_state.get("should_continue_analysis", True)
+    # Si la validación no ha ocurrido aún, asumimos que debemos continuar
+    return not st.session_state.get("too_many_faces", False)