Corregido cálculo de brillo y contraste para evitar valores cero

services/image_service.py

@@ -249,88 +249,124 @@ class ImageService:
             "recommendations": []  # For compatibility
         }
         
+        # Debug para ver si llega una imagen válida
+        import logging
+        logging.warning(f"Image shape: {img.shape if img is not None and hasattr(img, 'shape') else 'No shape'}")
+        
         if img is None:
             result["warnings"].append("Could not evaluate image quality.")
+            # Valores por defecto para evitar 0%
+            result["brightness"] = 50.0
+            result["contrast"] = 30.0
+            result["score"] = 40
+            result["label"] = "Fair"
+            result["sharpness_label"] = "Fair"
             return result
         
-        # Convert to grayscale for some metrics
-        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) if len(img.shape) == 3 else img
-        
-        # Evaluate sharpness (using Laplacian variance)
-        laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
-        result["is_blurry"] = laplacian_var < 100
-        
-        # Calculate brightness (pixel average)
-        brightness = np.mean(gray)
-        result["brightness"] = brightness / 255.0  # Normalized to 0-1
-        
-        # Calculate contrast (pixel standard deviation)
-        contrast = np.std(gray)
-        result["contrast"] = contrast / 255.0  # Normalized to 0-1
-        
-        # General quality evaluation (weighted combination)
-        sharpness_score = min(1.0, laplacian_var / 500)
-        brightness_score = 1.0 - abs(0.5 - result["brightness"]) * 2  # optimal near 0.5
-        contrast_score = min(1.0, result["contrast"] * 3)  # higher contrast is better
-        
-        # Total quality (0-1)
-        quality_value = (sharpness_score * 0.5 + brightness_score * 0.25 + contrast_score * 0.25)
-        result["quality_score"] = quality_value
-        
-        # Add backwards compatibility: convert to 0-100 scale and add label
-        result["score"] = int(quality_value * 100)  # For compatibility with previous code
-        
-        # Add a text label for the quality
-        if result["score"] >= 80:
-            result["label"] = "Excellent"
-        elif result["score"] >= 60:
-            result["label"] = "Good"
-        elif result["score"] >= 40:
+        try:
+            # Intentar trabajar con la imagen como RGB
+            # Convert to grayscale for some metrics
+            if len(img.shape) == 3:
+                # Probar directamente con la conversión a gris sin importar si es RGB o BGR
+                gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+            else:
+                gray = img.copy()
+            
+            # Evaluate sharpness (using Laplacian variance)
+            laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
+            result["is_blurry"] = laplacian_var < 100
+            
+            # Calculate brightness (pixel average)
+            brightness = np.mean(gray)
+            normalized_brightness = brightness / 255.0  # Normalized to 0-1
+            
+            # Calculate contrast (pixel standard deviation)
+            contrast = np.std(gray)
+            normalized_contrast = contrast / 255.0  # Normalized to 0-1
+            
+            # General quality evaluation (weighted combination)
+            sharpness_score = min(1.0, laplacian_var / 500)
+            brightness_score = 1.0 - abs(0.5 - normalized_brightness) * 2  # optimal near 0.5
+            contrast_score = min(1.0, normalized_contrast * 3)  # higher contrast is better
+            
+            # Total quality (0-1)
+            quality_value = (sharpness_score * 0.5 + brightness_score * 0.25 + contrast_score * 0.25)
+            result["quality_score"] = quality_value
+            
+            # Add backwards compatibility: convert to 0-100 scale and add label
+            result["score"] = int(quality_value * 100)  # For compatibility with previous code
+            
+            # Add a text label for the quality
+            if result["score"] >= 80:
+                result["label"] = "Excellent"
+            elif result["score"] >= 60:
+                result["label"] = "Good"
+            elif result["score"] >= 40:
+                result["label"] = "Fair"
+            elif result["score"] >= 20:
+                result["label"] = "Poor"
+            else:
+                result["label"] = "Very Poor"
+                
+            # Add sharpness label for UI
+            if sharpness_score >= 0.8:
+                result["sharpness_label"] = "Excellent"
+            elif sharpness_score >= 0.6:
+                result["sharpness_label"] = "Good"
+            elif sharpness_score >= 0.4:
+                result["sharpness_label"] = "Fair"
+            elif sharpness_score >= 0.2:
+                result["sharpness_label"] = "Poor"
+            else:
+                result["sharpness_label"] = "Very Poor"
+            
+            # Generate warnings and suggestions based on metrics
+            if result["is_blurry"]:
+                result["warnings"].append("The image appears to be blurry.")
+                suggestion = "Use a sharper image to improve facial detection accuracy."
+                result["suggestions"].append(suggestion)
+                result["recommendations"].append(suggestion)  # For compatibility
+            
+            if normalized_brightness < 0.2:
+                result["warnings"].append("The image is too dark.")
+                suggestion = "Try using a better illuminated image."
+                result["suggestions"].append(suggestion)
+                result["recommendations"].append(suggestion)  # For compatibility
+            elif normalized_brightness > 0.8:
+                result["warnings"].append("The image is too bright.")
+                suggestion = "Try using an image with more balanced lighting."
+                result["suggestions"].append(suggestion)
+                result["recommendations"].append(suggestion)  # For compatibility
+            
+            if normalized_contrast < 0.1:
+                result["warnings"].append("The image has very low contrast.")
+                suggestion = "An image with higher contrast will improve facial feature detection."
+                result["suggestions"].append(suggestion)
+                result["recommendations"].append(suggestion)  # For compatibility
+            
+            # Convert brightness and contrast to percentage for UI display
+            # Asegurarnos de que son valores numéricos válidos y no cero
+            result["brightness"] = max(1.0, float(normalized_brightness) * 100)
+            result["contrast"] = max(1.0, float(normalized_contrast) * 100)
+            
+            # Log de debug
+            logging.warning(f"Calculated brightness: {result['brightness']}, contrast: {result['contrast']}")
+            
+        except Exception as e:
+            # Log del error
+            import traceback
+            logging.error(f"Error in check_image_quality: {e}")
+            logging.error(traceback.format_exc())
+            
+            # Establecer valores por defecto en caso de error
+            result["brightness"] = 50.0 
+            result["contrast"] = 30.0
+            result["score"] = 40
             result["label"] = "Fair"
-        elif result["score"] >= 20:
-            result["label"] = "Poor"
-        else:
-            result["label"] = "Very Poor"
-            
-        # Add sharpness label for UI
-        if sharpness_score >= 0.8:
-            result["sharpness_label"] = "Excellent"
-        elif sharpness_score >= 0.6:
-            result["sharpness_label"] = "Good"
-        elif sharpness_score >= 0.4:
             result["sharpness_label"] = "Fair"
-        elif sharpness_score >= 0.2:
-            result["sharpness_label"] = "Poor"
-        else:
-            result["sharpness_label"] = "Very Poor"
-        
-        # Generate warnings and suggestions based on metrics
-        if result["is_blurry"]:
-            result["warnings"].append("The image appears to be blurry.")
-            suggestion = "Use a sharper image to improve facial detection accuracy."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-        
-        if result["brightness"] < 0.2:
-            result["warnings"].append("The image is too dark.")
-            suggestion = "Try using a better illuminated image."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-        elif result["brightness"] > 0.8:
-            result["warnings"].append("The image is too bright.")
-            suggestion = "Try using an image with more balanced lighting."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-        
-        if result["contrast"] < 0.1:
-            result["warnings"].append("The image has very low contrast.")
-            suggestion = "An image with higher contrast will improve facial feature detection."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-        
-        # Convert brightness and contrast to percentage for UI display
-        result["brightness"] = float(result["brightness"]) * 100
-        result["contrast"] = float(result["contrast"]) * 100
+            
+            # Añadir mensaje de error a las recomendaciones
+            result["recommendations"].append("Error analyzing image quality. Try with another image.")
         
         return result
     
@@ -792,155 +828,6 @@ class ImageService:
         
         return result
 
-    def check_image_quality(self, img: np.ndarray) -> Dict[str, Any]:
-        """
-        Evaluates the overall image quality for facial detection.
-        Part of Step 3: Validation of dimensions and size.
-        
-        This method performs various quality assessments including:
-        - Blurriness detection using Laplacian variance
-        - Brightness level measurement
-        - Contrast calculation
-        
-        These metrics are combined into an overall quality score and
-        specific recommendations are provided for improving quality.
-        
-        Args:
-            img: The image as a numpy array
-            
-        Returns:
-            Dict with quality metrics and recommendations
-        """
-        result = {
-            "quality_score": 0.0,
-            "is_blurry": False,
-            "brightness": 0.0,
-            "contrast": 0.0,
-            "warnings": [],
-            "suggestions": [],
-            "recommendations": []  # For compatibility
-        }
-        
-        if img is None:
-            result["warnings"].append("Could not evaluate image quality.")
-            return result
-        
-        # Convert to grayscale for some metrics
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if len(img.shape) == 3 else img
-        
-        # Evaluate sharpness (using Laplacian variance)
-        laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
-        result["is_blurry"] = laplacian_var < 100
-        
-        # Calculate brightness (pixel average)
-        brightness = np.mean(gray)
-        result["brightness"] = brightness / 255.0  # Normalized to 0-1
-        
-        # Calculate contrast (pixel standard deviation)
-        contrast = np.std(gray)
-        result["contrast"] = contrast / 255.0  # Normalized to 0-1
-        
-        # General quality evaluation (weighted combination)
-        sharpness_score = min(1.0, laplacian_var / 500)
-        brightness_score = 1.0 - abs(0.5 - result["brightness"]) * 2  # optimal near 0.5
-        contrast_score = min(1.0, result["contrast"] * 3)  # higher contrast is better
-        
-        # Total quality (0-1)
-        quality_value = (sharpness_score * 0.5 + brightness_score * 0.25 + contrast_score * 0.25)
-        result["quality_score"] = quality_value
-        
-        # Add backwards compatibility: convert to 0-100 scale and add label
-        result["score"] = int(quality_value * 100)  # For compatibility with previous code
-        
-        # Add a text label for the quality
-        if result["score"] >= 80:
-            result["label"] = "Excellent"
-        elif result["score"] >= 60:
-            result["label"] = "Good"
-        elif result["score"] >= 40:
-            result["label"] = "Fair"
-        elif result["score"] >= 20:
-            result["label"] = "Poor"
-        else:
-            result["label"] = "Very Poor"
-            
-        # Add sharpness label for UI
-        if sharpness_score >= 0.8:
-            result["sharpness_label"] = "Excellent"
-        elif sharpness_score >= 0.6:
-            result["sharpness_label"] = "Good"
-        elif sharpness_score >= 0.4:
-            result["sharpness_label"] = "Fair"
-        elif sharpness_score >= 0.2:
-            result["sharpness_label"] = "Poor"
-        else:
-            result["sharpness_label"] = "Very Poor"
-        
-        # Generate warnings and suggestions based on metrics
-        if result["is_blurry"]:
-            result["warnings"].append("The image appears to be blurry.")
-            suggestion = "Use a sharper image to improve facial detection accuracy."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-        
-        if result["brightness"] < 0.2:
-            result["warnings"].append("The image is too dark.")
-            suggestion = "Try using a better illuminated image."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-        elif result["brightness"] > 0.8:
-            result["warnings"].append("The image is too bright.")
-            suggestion = "Try using an image with more balanced lighting."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-            
-        if result["contrast"] < 0.1:
-            result["warnings"].append("The image has very low contrast.")
-            suggestion = "Use an image with better contrast between features."
-            result["suggestions"].append(suggestion)
-            result["recommendations"].append(suggestion)  # For compatibility
-            
-        return result
-
-    def validate_dimensions(self, width: int, height: int) -> Dict[str, Any]:
-        """
-        Validates image dimensions against the defined constraints.
-        Part of Step 3: Validation of dimensions.
-        
-        Args:
-            width: Image width in pixels
-            height: Image height in pixels
-            
-        Returns:
-            Dictionary with validation results
-        """
-        result = {
-            "valid": True,
-            "issues": [],
-            "is_optimal": False,
-            "width": width,
-            "height": height
-        }
-        
-        # Check minimum dimensions
-        if width < self.min_width or height < self.min_height:
-            result["valid"] = False
-            result["issues"].append(
-                f"Image dimensions too small. Minimum: {self.min_width}x{self.min_height}."
-            )
-            
-        # Check maximum dimensions
-        if width > self.max_width or height > self.max_height:
-            result["valid"] = False
-            result["issues"].append(
-                f"Image dimensions too large. Maximum: {self.max_width}x{self.max_height}."
-            )
-            
-        # Check if dimensions are optimal
-        result["is_optimal"] = width >= self.optimal_width and height >= self.optimal_height
-        
-        return result
-    
     def validate_image_file(self, file, check_content: bool = True, check_dimensions: bool = True) -> Dict[str, Any]:
         """
         Complete validation of an image file, checking format, dimensions and quality.
@@ -1159,3 +1046,132 @@ class ImageService:
                         return None
         
         return uploaded_file
+
+    def validate_dimensions(self, width: int, height: int) -> Dict[str, Any]:
+        """
+        Validates image dimensions against the defined constraints.
+        Part of Step 3: Validation of dimensions.
+        
+        Args:
+            width: Image width in pixels
+            height: Image height in pixels
+            
+        Returns:
+            Dictionary with validation results
+        """
+        result = {
+            "valid": True,
+            "issues": [],
+            "is_optimal": False,
+            "width": width,
+            "height": height
+        }
+        
+        # Check minimum dimensions
+        if width < self.min_width or height < self.min_height:
+            result["valid"] = False
+            result["issues"].append(
+                f"Image dimensions too small. Minimum: {self.min_width}x{self.min_height}."
+            )
+            
+        # Check maximum dimensions
+        if width > self.max_width or height > self.max_height:
+            result["valid"] = False
+            result["issues"].append(
+                f"Image dimensions too large. Maximum: {self.max_width}x{self.max_height}."
+            )
+            
+        # Check if dimensions are optimal
+        result["is_optimal"] = width >= self.optimal_width and height >= self.optimal_height
+        
+        return result
+    
+    def validate_image_file(self, file, check_content: bool = True, check_dimensions: bool = True) -> Dict[str, Any]:
+        """
+        Complete validation of an image file, checking format, dimensions and quality.
+        Combines Steps 1, 2 & 3: Interface design, format validation,
+        and dimension/quality validation.
+        
+        Args:
+            file: The uploaded file object from Streamlit
+            check_content: Whether to also validate the file content
+            check_dimensions: Whether to validate image dimensions and quality
+            
+        Returns:
+            Dict with validation results and messages
+        """
+        result = {
+            "valid": False,
+            "messages": [],
+            "warnings": [],
+            "file_info": {},
+            "dimensions": {},
+            "quality": {}
+        }
+        
+        if file is None:
+            result["messages"].append("No file selected.")
+            return result
+            
+        # Validate file extension
+        ext_valid, ext_msg = self.validate_file_extension(file.name)
+        result["messages"].append(ext_msg)
+        
+        if not ext_valid:
+            return result
+            
+        # Check file size
+        file_size = len(file.getvalue())
+        result["file_info"]["size"] = file_size
+        result["file_info"]["name"] = file.name
+        
+        if file_size > self.max_file_size:
+            result["messages"].append(f"File is too large. Maximum size: {self.max_file_size/1024/1024:.1f}MB")
+            return result
+            
+        # Validate MIME type if requested
+        if check_content:
+            mime_valid, mime_msg = self.validate_file_mime(file.getvalue())
+            result["messages"].append(mime_msg)
+            
+            if not mime_valid:
+                return result
+        
+        # STEP 3: Validate dimensions and quality if requested
+        if check_dimensions:
+            try:
+                # Convert file to image for analysis
+                file_bytes = np.asarray(bytearray(file.getvalue()), dtype=np.uint8)
+                img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+                
+                # Validate dimensions
+                dimension_results = self.validate_image_dimensions(img)
+                result["dimensions"] = dimension_results
+                
+                # Add dimension warnings to main result
+                result["warnings"].extend(dimension_results.get("warnings", []))
+                result["messages"].extend(dimension_results.get("messages", []))
+                
+                # If dimensions are invalid, mark the entire result as invalid
+                if not dimension_results.get("valid", True):
+                    result["valid"] = False
+                    return result
+                
+                # Check quality
+                quality_results = self.check_image_quality(img)
+                result["quality"] = quality_results
+                
+                # Add quality warnings
+                result["warnings"].extend(quality_results.get("warnings", []))
+                
+                # Add suggestions as messages
+                for suggestion in quality_results.get("suggestions", []):
+                    result["messages"].append(suggestion)
+                
+            except Exception as e:
+                logger.error(f"Error validating image dimensions/quality: {e}")
+                result["warnings"].append(f"Could not validate dimensions or quality: {str(e)}")
+                
+        # All validations passed
+        result["valid"] = True
+        return result