finishing up defect logic

gradio_test.py

@@ -67,11 +67,15 @@ ONEFORMER_CONFIG = {
     }
 }
 
+# Blackspot model configuration for HF Spaces
+BLACKSPOT_MODEL_REPO = "sww35/neuronest-blackspot"  # Update with your HF repo
+BLACKSPOT_MODEL_FILE = "model_0004999.pth"
+
 ########################################
 # IMPORT UNIVERSAL CONTRAST ANALYZER
 ########################################
 
-from universal_contrast_analyzer import UniversalContrastAnalyzer
+from utils.universal_contrast_analyzer import UniversalContrastAnalyzer
 
 ########################################
 # ONEFORMER INTEGRATION
@@ -168,15 +172,44 @@ class OneFormerManager:
 class ImprovedBlackspotDetector:
     """Enhanced blackspot detector that only detects on floor surfaces"""
 
-    def __init__(self, model_path: str):
+    def __init__(self, model_path: str = None):
         self.model_path = model_path
         self.predictor = None
         # Expanded floor-related classes in ADE20K
         self.floor_classes = [3, 4, 13, 28, 78]  # floor, wood floor, rug, carpet, mat
 
+    def download_model(self) -> str:
+        """Download blackspot model from HuggingFace"""
+        try:
+            # Try to download from HF repo
+            model_path = hf_hub_download(
+                repo_id=BLACKSPOT_MODEL_REPO,
+                filename=BLACKSPOT_MODEL_FILE
+            )
+            logger.info(f"Downloaded blackspot model to: {model_path}")
+            return model_path
+        except Exception as e:
+            logger.warning(f"Could not download blackspot model from HF: {e}")
+            
+            # Fallback to local path
+            local_path = f"./output_floor_blackspot/{BLACKSPOT_MODEL_FILE}"
+            if os.path.exists(local_path):
+                logger.info(f"Using local blackspot model: {local_path}")
+                return local_path
+            
+            return None
+
     def initialize(self, threshold: float = 0.5) -> bool:
         """Initialize MaskRCNN model"""
         try:
+            # Get model path
+            if self.model_path is None:
+                self.model_path = self.download_model()
+                
+            if self.model_path is None:
+                logger.error("No blackspot model available")
+                return False
+            
             cfg = get_cfg()
             cfg.merge_from_file(
                 model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
@@ -363,18 +396,19 @@ class NeuroNestApp:
         self.contrast_analyzer = UniversalContrastAnalyzer(wcag_threshold=4.5)
         self.initialized = False
 
-    def initialize(self, blackspot_model_path: str = "./output_floor_blackspot/model_0004999.pth"):
+    def initialize(self):
         """Initialize all components"""
         logger.info("Initializing NeuroNest application...")
 
         oneformer_success = self.oneformer.initialize()
 
+        # Initialize blackspot detector with HF model
         blackspot_success = False
-        if os.path.exists(blackspot_model_path):
-            self.blackspot_detector = ImprovedBlackspotDetector(blackspot_model_path)
+        try:
+            self.blackspot_detector = ImprovedBlackspotDetector()
             blackspot_success = self.blackspot_detector.initialize()
-        else:
-            logger.warning(f"Blackspot model not found at {blackspot_model_path}")
+        except Exception as e:
+            logger.warning(f"Could not initialize blackspot detector: {e}")
 
         self.initialized = oneformer_success
         return oneformer_success, blackspot_success
@@ -595,6 +629,25 @@ def create_gradio_interface():
         if results['contrast'] and results['statistics']['contrast']['low_contrast_pairs'] > 0:
             has_issues = True
             report.append("\n### Contrast Improvements:")
+            
+            # Get specific recommendations based on issue types
+            contrast_issues = results['contrast']['issues']
+            critical_issues = [i for i in contrast_issues if i['severity'] == 'critical']
+            high_issues = [i for i in contrast_issues if i['severity'] == 'high']
+            
+            if critical_issues:
+                report.append("\n**CRITICAL - Immediate attention required:**")
+                for issue in critical_issues[:3]:
+                    cat1, cat2 = issue['categories']
+                    report.append(f"- {cat1.title()} ↔ {cat2.title()}: Increase contrast to 7:1 minimum")
+            
+            if high_issues:
+                report.append("\n**HIGH PRIORITY:**")
+                for issue in high_issues[:3]:
+                    cat1, cat2 = issue['categories']
+                    report.append(f"- {cat1.title()} ↔ {cat2.title()}: Increase contrast to 4.5:1 minimum")
+            
+            report.append("\n**General recommendations:**")
             report.append("- Paint furniture in colors that contrast with floors/walls")
             report.append("- Add colored tape or markers to furniture edges")
             report.append("- Install LED strip lighting under furniture edges")
@@ -622,6 +675,13 @@ def create_gradio_interface():
         gr.Markdown(f"# {title}")
         gr.Markdown(description)
 
+        # Information about model availability
+        if not blackspot_ok:
+            gr.Markdown("""
+            ⚠️ **Note:** Blackspot detection model not available. 
+            To enable blackspot detection, upload the model to HuggingFace or ensure it's in the local directory.
+            """)
+
         # Top row: toggles and sliders
         with gr.Row():
             enable_blackspot = gr.Checkbox(
@@ -730,4 +790,3 @@ if __name__ == "__main__":
     except Exception as e:
         logger.error(f"Failed to launch application: {e}")
         raise
-

output_floor_blackspot/model_0004999.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caa8e868334fbd8d14d8f576704be3b7ad8b1ef1473a68380ad0addd7ad56405
+size 351060772

universal_contrast_analyzer.py

@@ -83,17 +83,18 @@ class UniversalContrastAnalyzer:
         """Calculate WCAG 2.0 contrast ratio between two colors"""
         def relative_luminance(rgb):
             # Normalize to 0-1
-            rgb_norm = rgb / 255.0
+            rgb_norm = np.array(rgb) / 255.0
             
             # Apply gamma correction (linearize)
             rgb_linear = np.where(
                 rgb_norm <= 0.03928,
                 rgb_norm / 12.92,
-                ((rgb_norm + 0.055) / 1.055) ** 2.4
+                np.power((rgb_norm + 0.055) / 1.055, 2.4)
             )
             
             # Calculate luminance using ITU-R BT.709 coefficients
-            return np.dot(rgb_linear, [0.2126, 0.7152, 0.0722])
+            # L = 0.2126 * R + 0.7152 * G + 0.0722 * B
+            return 0.2126 * rgb_linear[0] + 0.7152 * rgb_linear[1] + 0.0722 * rgb_linear[2]
         
         lum1 = relative_luminance(color1)
         lum2 = relative_luminance(color2)
@@ -102,27 +103,37 @@ class UniversalContrastAnalyzer:
         lighter = max(lum1, lum2)
         darker = min(lum1, lum2)
         
-        return (lighter + 0.05) / (darker + 0.05)
+        # Calculate contrast ratio
+        contrast_ratio = (lighter + 0.05) / (darker + 0.05)
+        
+        return contrast_ratio
     
     def calculate_hue_difference(self, color1: np.ndarray, color2: np.ndarray) -> float:
         """Calculate hue difference in degrees (0-180)"""
-        # Convert RGB to HSV
-        hsv1 = cv2.cvtColor(color1.reshape(1, 1, 3).astype(np.uint8), cv2.COLOR_RGB2HSV)[0, 0]
-        hsv2 = cv2.cvtColor(color2.reshape(1, 1, 3).astype(np.uint8), cv2.COLOR_RGB2HSV)[0, 0]
+        # Convert RGB to HSV using colorsys for accuracy
+        rgb1 = color1 / 255.0
+        rgb2 = color2 / 255.0
+        
+        hsv1 = colorsys.rgb_to_hsv(rgb1[0], rgb1[1], rgb1[2])
+        hsv2 = colorsys.rgb_to_hsv(rgb2[0], rgb2[1], rgb2[2])
         
-        # Calculate circular hue difference (0-180 range in OpenCV)
-        hue_diff = abs(hsv1[0] - hsv2[0])
+        # Calculate circular hue difference (0-1 range converted to 0-180)
+        hue_diff = abs(hsv1[0] - hsv2[0]) * 180
         if hue_diff > 90:
             hue_diff = 180 - hue_diff
             
         return hue_diff
     
     def calculate_saturation_difference(self, color1: np.ndarray, color2: np.ndarray) -> float:
-        """Calculate saturation difference (0-255)"""
-        hsv1 = cv2.cvtColor(color1.reshape(1, 1, 3).astype(np.uint8), cv2.COLOR_RGB2HSV)[0, 0]
-        hsv2 = cv2.cvtColor(color2.reshape(1, 1, 3).astype(np.uint8), cv2.COLOR_RGB2HSV)[0, 0]
+        """Calculate saturation difference (0-100)"""
+        rgb1 = color1 / 255.0
+        rgb2 = color2 / 255.0
+        
+        hsv1 = colorsys.rgb_to_hsv(rgb1[0], rgb1[1], rgb1[2])
+        hsv2 = colorsys.rgb_to_hsv(rgb2[0], rgb2[1], rgb2[2])
         
-        return abs(int(hsv1[1]) - int(hsv2[1]))
+        # Return saturation difference as percentage
+        return abs(hsv1[1] - hsv2[1]) * 100
     
     def extract_dominant_color(self, image: np.ndarray, mask: np.ndarray, 
                              sample_size: int = 1000) -> np.ndarray:
@@ -239,13 +250,15 @@ class UniversalContrastAnalyzer:
             # Critical: require 7:1 contrast ratio
             if wcag_ratio < 7.0:
                 return False, 'critical'
-            if hue_diff < 30 and sat_diff < 50:
+            # Also check perceptual differences
+            if wcag_ratio < 10.0 and hue_diff < 30 and sat_diff < 50:
                 return False, 'critical'
                 
         elif relationship in high_priority_pairs:
             # High priority: require 4.5:1 contrast ratio
             if wcag_ratio < 4.5:
                 return False, 'high'
+            # Also check perceptual differences
             if wcag_ratio < 7.0 and hue_diff < 20 and sat_diff < 40:
                 return False, 'high'
                 
@@ -253,6 +266,7 @@ class UniversalContrastAnalyzer:
             # Standard: require 3:1 contrast ratio minimum
             if wcag_ratio < 3.0:
                 return False, 'medium'
+            # Also check perceptual differences
             if wcag_ratio < 4.5 and hue_diff < 15 and sat_diff < 30:
                 return False, 'medium'
         
@@ -440,12 +454,21 @@ class UniversalContrastAnalyzer:
                 severity = issue['severity'].upper()
                 
                 report.append(f"{i}. [{severity}] {cat1} ↔ {cat2}")
-                report.append(f"   - WCAG Contrast Ratio: {wcag:.2f}:1 (minimum: 4.5:1)")
+                report.append(f"   - WCAG Contrast Ratio: {wcag:.2f}:1")
+                
+                # Add recommended values based on severity
+                if severity == 'CRITICAL':
+                    report.append(f"   - Required: 7:1 minimum")
+                elif severity == 'HIGH':
+                    report.append(f"   - Required: 4.5:1 minimum")
+                else:
+                    report.append(f"   - Required: 3:1 minimum")
+                    
                 report.append(f"   - Hue Difference: {hue_diff:.1f}° (recommended: >30°)")
-                report.append(f"   - Saturation Difference: {sat_diff} (recommended: >50)")
+                report.append(f"   - Saturation Difference: {sat_diff:.1f}% (recommended: >50%)")
                 
                 if issue['is_floor_object']:
-                    report.append("   - ⚠️ Object on floor - requires high visibility!")
+                    report.append("   - ⚠️ Floor-object boundary - high visibility required!")
                 
                 report.append(f"   - Boundary size: {issue['boundary_pixels']} pixels")
                 report.append("")