import numpy as np import cv2 import logging import traceback from typing import Dict, Any, Optional from configuration_manager import ConfigurationManager class FeatureExtractor: """ Extracts comprehensive lighting and scene features from images.（主要從圖片提取光線資訊) This class handles all basic feature computation including brightness analysis, color characteristics, texture complexity, and structural features for lighting analysis and scene understanding. """ def __init__(self, config_manager: ConfigurationManager): """ Initialize the feature extractor. Args: config_manager: Configuration manager instance for accessing thresholds. """ self.config_manager = config_manager self.logger = self._setup_logger() def _setup_logger(self) -> logging.Logger: """Set up logger for feature extraction operations.""" logger = logging.getLogger(f"{__name__}.FeatureExtractor") if not logger.handlers: handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) return logger def extract_features(self, image_rgb: np.ndarray) -> Dict[str, Any]: """ Extract all features from an RGB image. Args: image_rgb: Input image as numpy array in RGB format. Returns: Dictionary containing all extracted features. """ try: # Validate input image if not self._validate_image(image_rgb): return self._get_default_features() # Get image dimensions and prepare processing parameters height, width = image_rgb.shape[:2] scale_factor = self._calculate_scale_factor(height, width) # Create processed image versions small_rgb = cv2.resize( image_rgb, (width // scale_factor, height // scale_factor), interpolation=cv2.INTER_AREA ) hsv_img = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2HSV) gray_img = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2GRAY) small_gray = cv2.cvtColor(small_rgb, cv2.COLOR_RGB2GRAY) # Extract features by category brightness_features = self.compute_brightness_features(hsv_img, height, width) color_features = self.compute_color_features(hsv_img, height, width) texture_features = self.compute_texture_features(small_gray, gray_img, height, width) structure_features = self.compute_structure_features( small_gray, gray_img, hsv_img, height, width, scale_factor ) # Combine all features features = {**brightness_features, **color_features, **texture_features, **structure_features} # Add compatibility features for legacy code legacy_features = self._compute_legacy_compatibility_features( hsv_img, small_gray, features, scale_factor ) features.update(legacy_features) self.logger.debug(f"Successfully extracted {len(features)} features from image") return features except Exception as e: self.logger.error(f"Error in feature extraction: {str(e)}") self.logger.error(f"Traceback: {traceback.format_exc()}") return self._get_default_features() def compute_brightness_features(self, hsv_img: np.ndarray, height: int, width: int) -> Dict[str, float]: """ Compute brightness-related features from HSV image. Args: hsv_img: Image in HSV color space. height: Image height. width: Image width. Returns: Dictionary containing brightness features. """ try: v_channel = hsv_img[:, :, 2] # Value channel represents brightness # 基本的亮度統計 avg_brightness = float(np.mean(v_channel)) brightness_std = float(np.std(v_channel)) # Pixel ratio calculations dark_threshold = self.config_manager.feature_thresholds.dark_pixel_threshold bright_threshold = self.config_manager.feature_thresholds.bright_pixel_threshold total_pixels = height * width dark_pixel_ratio = float(np.sum(v_channel < dark_threshold) / total_pixels) bright_pixel_ratio = float(np.sum(v_channel > bright_threshold) / total_pixels) # Brightness uniformity brightness_uniformity = 1.0 - min(1.0, brightness_std / max(avg_brightness, 1e-5)) return { "avg_brightness": avg_brightness, "brightness_std": brightness_std, "dark_pixel_ratio": dark_pixel_ratio, "bright_pixel_ratio": bright_pixel_ratio, "brightness_uniformity": brightness_uniformity } except Exception as e: self.logger.error(f"Error computing brightness features: {str(e)}") return { "avg_brightness": 100.0, "brightness_std": 50.0, "dark_pixel_ratio": 0.0, "bright_pixel_ratio": 0.0, "brightness_uniformity": 0.5 } def compute_color_features(self, hsv_img: np.ndarray, height: int, width: int) -> Dict[str, Any]: """ Compute color-related features from HSV image. Args: hsv_img: Image in HSV color space. height: Image height. width: Image width. Returns: Dictionary containing color features. """ try: h_channel, s_channel, v_channel = cv2.split(hsv_img) total_pixels = height * width # Color ratio calculations color_features = {} # Blue color detection (general and sky-specific) blue_mask = ((h_channel >= 90) & (h_channel <= 140)) color_features["blue_ratio"] = float(np.sum(blue_mask) / total_pixels) # Sky-like blue detection ft = self.config_manager.feature_thresholds sky_blue_mask = ( (h_channel >= ft.sky_blue_hue_min) & (h_channel <= ft.sky_blue_hue_max) & (s_channel > ft.sky_blue_sat_min) & (v_channel > ft.sky_blue_val_min) ) color_features["sky_like_blue_ratio"] = float(np.sum(sky_blue_mask) / total_pixels) # Yellow-orange detection yellow_orange_mask = ((h_channel >= 15) & (h_channel <= 45)) color_features["yellow_orange_ratio"] = float(np.sum(yellow_orange_mask) / total_pixels) # Gray detection gray_mask = ( (s_channel < ft.gray_sat_max) & (v_channel > ft.gray_val_min) & (v_channel < ft.gray_val_max) ) color_features["gray_ratio"] = float(np.sum(gray_mask) / total_pixels) # Saturation statistics color_features["avg_saturation"] = float(np.mean(s_channel)) # Sky region analysis sky_region_features = self._analyze_sky_region(h_channel, s_channel, v_channel, height) color_features.update(sky_region_features) # Color atmosphere analysis atmosphere_features = self._analyze_color_atmosphere(h_channel, s_channel, total_pixels) color_features.update(atmosphere_features) return color_features except Exception as e: self.logger.error(f"Error computing color features: {str(e)}") return self._get_default_color_features() def compute_texture_features(self, small_gray: np.ndarray, gray_img: np.ndarray, height: int, width: int) -> Dict[str, float]: """ Compute texture and gradient features. Args: small_gray: Downscaled grayscale image for efficient processing. gray_img: Full-resolution grayscale image. height: Original image height. width: Original image width. Returns: Dictionary containing texture features. """ try: # Compute gradients on small image for efficiency gx = cv2.Sobel(small_gray, cv2.CV_32F, 1, 0, ksize=3) gy = cv2.Sobel(small_gray, cv2.CV_32F, 0, 1, ksize=3) avg_abs_gx = float(np.mean(np.abs(gx))) avg_abs_gy = float(np.mean(np.abs(gy))) # Gradient ratio (vertical to horizontal) gradient_ratio_vertical_horizontal = avg_abs_gy / max(avg_abs_gx, 1e-5) # Top region texture complexity small_top_third_height = small_gray.shape[0] // 3 small_sky_region_gray = small_gray[:small_top_third_height, :] if small_sky_region_gray.size > 0: laplacian_var_sky = cv2.Laplacian(small_sky_region_gray, cv2.CV_64F).var() top_region_texture_complexity = min(1.0, laplacian_var_sky / 1000.0) else: top_region_texture_complexity = 0.5 # Shadow clarity estimation brightness_std = float(np.std(gray_img)) avg_brightness = float(np.mean(gray_img)) dark_pixel_ratio = float(np.sum(gray_img < 50) / (height * width)) if brightness_std > 60 and dark_pixel_ratio < 0.15 and avg_brightness > 100: shadow_clarity_score = 0.7 elif brightness_std < 30 and dark_pixel_ratio > 0.1: shadow_clarity_score = 0.3 else: shadow_clarity_score = 0.5 # Edge density edges_density = min(1.0, (avg_abs_gx + avg_abs_gy) / 100.0) return { "gradient_ratio_vertical_horizontal": gradient_ratio_vertical_horizontal, "top_region_texture_complexity": top_region_texture_complexity, "shadow_clarity_score": shadow_clarity_score, "vertical_strength": avg_abs_gy, "horizontal_strength": avg_abs_gx, "edges_density": edges_density } except Exception as e: self.logger.error(f"Error computing texture features: {str(e)}") return { "gradient_ratio_vertical_horizontal": 1.0, "top_region_texture_complexity": 0.5, "shadow_clarity_score": 0.5, "vertical_strength": 0.0, "horizontal_strength": 0.0, "edges_density": 0.0 } def compute_structure_features(self, small_gray: np.ndarray, gray_img: np.ndarray, hsv_img: np.ndarray, height: int, width: int, scale_factor: int) -> Dict[str, float]: """ Compute structural features including ceiling likelihood and boundary clarity. Args: small_gray: Downscaled grayscale image. gray_img: Full-resolution grayscale image. hsv_img: HSV image for brightness analysis. height: Original image height. width: Original image width. scale_factor: Downscaling factor used. Returns: Dictionary containing structural features. """ try: # Compute gradients gx = cv2.Sobel(small_gray, cv2.CV_32F, 1, 0, ksize=3) gy = cv2.Sobel(small_gray, cv2.CV_32F, 0, 1, ksize=3) avg_abs_gx = float(np.mean(np.abs(gx))) avg_abs_gy = float(np.mean(np.abs(gy))) # Ceiling likelihood analysis ceiling_features = self._analyze_ceiling_likelihood( small_gray, hsv_img, gx, avg_abs_gx, height, scale_factor ) # Boundary clarity analysis boundary_clarity = self._compute_boundary_clarity(small_gray, avg_abs_gx, avg_abs_gy) # Openness analysis openness_top_edge = self._compute_openness_top_edge(gy, avg_abs_gy) # Legacy compatibility features legacy_structure = self._compute_legacy_structure_features(gray_img, height) structure_features = { "ceiling_likelihood": ceiling_features["ceiling_likelihood"], "boundary_clarity": boundary_clarity, "openness_top_edge": openness_top_edge, **legacy_structure } return structure_features except Exception as e: self.logger.error(f"Error computing structure features: {str(e)}") return { "ceiling_likelihood": 0.0, "boundary_clarity": 0.0, "openness_top_edge": 0.5, "ceiling_uniformity": 0.5, "horizontal_line_ratio": 0.0 } def _analyze_sky_region(self, h_channel: np.ndarray, s_channel: np.ndarray, v_channel: np.ndarray, height: int) -> Dict[str, float]: """Analyze features specific to the sky region (top third of image).""" try: top_third_height = height // 3 sky_region_v = v_channel[:top_third_height, :] sky_region_s = s_channel[:top_third_height, :] sky_region_h = h_channel[:top_third_height, :] if sky_region_v.size == 0: return self._get_default_sky_features() # Sky region brightness analysis sky_region_avg_brightness = float(np.mean(sky_region_v)) overall_avg_brightness = float(np.mean(v_channel)) sky_region_brightness_ratio = sky_region_avg_brightness / max(overall_avg_brightness, 1e-5) sky_region_saturation = float(np.mean(sky_region_s)) # Sky blue dominance in sky region ft = self.config_manager.feature_thresholds sky_region_blue_pixels = np.sum( (sky_region_h >= ft.sky_blue_hue_min) & (sky_region_h <= ft.sky_blue_hue_max) & (sky_region_s > ft.sky_blue_sat_min) & (sky_region_v > ft.sky_blue_val_min) ) sky_region_blue_dominance = float(sky_region_blue_pixels / max(1, sky_region_v.size)) return { "sky_region_brightness_ratio": sky_region_brightness_ratio, "sky_region_saturation": sky_region_saturation, "sky_region_blue_dominance": sky_region_blue_dominance, "sky_brightness": sky_region_avg_brightness } except Exception as e: self.logger.error(f"Error analyzing sky region: {str(e)}") return self._get_default_sky_features() def _analyze_color_atmosphere(self, h_channel: np.ndarray, s_channel: np.ndarray, total_pixels: int) -> Dict[str, Any]: """Analyze warm/cool color atmosphere.""" try: cr = self.config_manager.color_ranges # Warm colors detection warm_mask = np.zeros_like(h_channel, dtype=bool) for h_min, h_max in cr.warm_hue_ranges: warm_mask |= ((h_channel >= h_min) & (h_channel <= h_max)) warm_ratio = float(np.sum(warm_mask & (s_channel > 30)) / total_pixels) # Cool colors detection cool_mask = np.zeros_like(h_channel, dtype=bool) for h_min, h_max in cr.cool_hue_ranges: cool_mask |= ((h_channel >= h_min) & (h_channel <= h_max)) cool_ratio = float(np.sum(cool_mask & (s_channel > 30)) / total_pixels) # Determine overall atmosphere if warm_ratio > cool_ratio and warm_ratio > 0.3: color_atmosphere = "warm" elif cool_ratio > warm_ratio and cool_ratio > 0.3: color_atmosphere = "cool" else: color_atmosphere = "neutral" return { "warm_ratio": warm_ratio, "cool_ratio": cool_ratio, "color_atmosphere": color_atmosphere } except Exception as e: self.logger.error(f"Error analyzing color atmosphere: {str(e)}") return { "warm_ratio": 0.0, "cool_ratio": 0.0, "color_atmosphere": "neutral" } def _analyze_ceiling_likelihood(self, small_gray: np.ndarray, hsv_img: np.ndarray, gx: np.ndarray, avg_abs_gx: float, height: int, scale_factor: int) -> Dict[str, float]: """Analyze likelihood of ceiling presence.""" try: ceiling_likelihood = 0.0 config = self.config_manager.indoor_outdoor_thresholds # Get sky region brightness for analysis v_channel = hsv_img[:, :, 2] top_third_height = height // 3 sky_region_v = v_channel[:top_third_height, :] sky_region_avg_brightness = float(np.mean(sky_region_v)) if sky_region_v.size > 0 else 0 # Get top region texture complexity small_top_third_height = small_gray.shape[0] // 3 small_sky_region_gray = small_gray[:small_top_third_height, :] if small_sky_region_gray.size > 0: laplacian_var = cv2.Laplacian(small_sky_region_gray, cv2.CV_64F).var() top_region_texture_complexity = min(1.0, laplacian_var / 1000.0) else: top_region_texture_complexity = 0.5 # Condition 1: Simple texture and moderate brightness ceiling_texture_thresh = getattr(config, 'ceiling_texture_thresh', 0.4) ceiling_brightness_min = getattr(config, 'ceiling_brightness_min', 60) ceiling_brightness_max = getattr(config, 'ceiling_brightness_max', 230) if (top_region_texture_complexity < ceiling_texture_thresh and ceiling_brightness_min < sky_region_avg_brightness < ceiling_brightness_max): ceiling_likelihood += 0.45 # Condition 2: Horizontal line strength top_horizontal_lines_strength = float(np.mean(np.abs(gx[:small_gray.shape[0]//3, :]))) ceiling_horizontal_line_factor = getattr(config, 'ceiling_horizontal_line_factor', 1.15) if top_horizontal_lines_strength > avg_abs_gx * ceiling_horizontal_line_factor: ceiling_likelihood += 0.35 # Condition 3: Central bright spot (lamp detection) center_y_sm, center_x_sm = small_gray.shape[0]//2, small_gray.shape[1]//2 lamp_check_radius_y = small_gray.shape[0] // 8 lamp_check_radius_x = small_gray.shape[1] // 8 center_region = small_gray[ max(0, center_y_sm - lamp_check_radius_y):min(small_gray.shape[0], center_y_sm + lamp_check_radius_y), max(0, center_x_sm - lamp_check_radius_x):min(small_gray.shape[1], center_x_sm + lamp_check_radius_x) ] if center_region.size > 0: avg_brightness = float(np.mean(small_gray)) center_brightness = float(np.mean(center_region)) ceiling_center_bright_factor = getattr(config, 'ceiling_center_bright_factor', 1.25) if center_brightness > avg_brightness * ceiling_center_bright_factor: ceiling_likelihood += 0.30 # Sky dominance analysis for penalty sky_region_blue_dominance = self._compute_sky_blue_dominance(hsv_img, height) sky_region_brightness_ratio = sky_region_avg_brightness / max(float(np.mean(v_channel)), 1e-5) # Penalties for strong sky signals ceiling_max_sky_blue_thresh = getattr(config, 'ceiling_max_sky_blue_thresh', 0.08) ceiling_max_sky_brightness_ratio = getattr(config, 'ceiling_max_sky_brightness_ratio', 1.15) if (sky_region_blue_dominance < ceiling_max_sky_blue_thresh and sky_region_brightness_ratio < ceiling_max_sky_brightness_ratio): ceiling_likelihood += 0.15 # Strong sky override sky_blue_dominance_strong_thresh = getattr(config, 'sky_blue_dominance_strong_thresh', 0.25) sky_brightness_strong_thresh = getattr(config, 'sky_brightness_strong_thresh', 1.25) ceiling_sky_override_factor = getattr(config, 'ceiling_sky_override_factor', 0.1) if (sky_region_blue_dominance > sky_blue_dominance_strong_thresh and sky_region_brightness_ratio > sky_brightness_strong_thresh): ceiling_likelihood *= ceiling_sky_override_factor ceiling_likelihood = min(1.0, ceiling_likelihood) return {"ceiling_likelihood": ceiling_likelihood} except Exception as e: self.logger.error(f"Error analyzing ceiling likelihood: {str(e)}") return {"ceiling_likelihood": 0.0} def _compute_sky_blue_dominance(self, hsv_img: np.ndarray, height: int) -> float: """Compute blue dominance in sky region.""" try: h_channel, s_channel, v_channel = cv2.split(hsv_img) top_third_height = height // 3 sky_region_h = h_channel[:top_third_height, :] sky_region_s = s_channel[:top_third_height, :] sky_region_v = v_channel[:top_third_height, :] if sky_region_h.size == 0: return 0.0 ft = self.config_manager.feature_thresholds sky_region_blue_pixels = np.sum( (sky_region_h >= ft.sky_blue_hue_min) & (sky_region_h <= ft.sky_blue_hue_max) & (sky_region_s > ft.sky_blue_sat_min) & (sky_region_v > ft.sky_blue_val_min) ) return float(sky_region_blue_pixels / max(1, sky_region_h.size)) except Exception as e: self.logger.error(f"Error computing sky blue dominance: {str(e)}") return 0.0 def _compute_boundary_clarity(self, small_gray: np.ndarray, avg_abs_gx: float, avg_abs_gy: float) -> float: """Compute boundary clarity score.""" try: edge_width_sm = max(1, small_gray.shape[1] // 10) edge_height_sm = max(1, small_gray.shape[0] // 10) # Edge gradients left_edge_grad_x = 0.0 right_edge_grad_x = 0.0 top_edge_grad_y = 0.0 if small_gray.shape[1] > edge_width_sm: left_edge = small_gray[:, :edge_width_sm] right_edge = small_gray[:, -edge_width_sm:] left_edge_grad_x = float(np.mean(np.abs(cv2.Sobel(left_edge, cv2.CV_32F, 1, 0, ksize=3)))) right_edge_grad_x = float(np.mean(np.abs(cv2.Sobel(right_edge, cv2.CV_32F, 1, 0, ksize=3)))) if small_gray.shape[0] > edge_height_sm: top_edge = small_gray[:edge_height_sm, :] top_edge_grad_y = float(np.mean(np.abs(cv2.Sobel(top_edge, cv2.CV_32F, 0, 1, ksize=3)))) # Normalize against average gradients boundary_clarity = (left_edge_grad_x + right_edge_grad_x + top_edge_grad_y) / ( 3 * max(avg_abs_gx, avg_abs_gy, 1e-5) ) boundary_clarity = min(1.0, boundary_clarity / 1.5) return boundary_clarity except Exception as e: self.logger.error(f"Error computing boundary clarity: {str(e)}") return 0.0 def _compute_openness_top_edge(self, gy: np.ndarray, avg_abs_gy: float) -> float: """Compute openness of top edge.""" try: top_edge_strip_gy = float(np.mean(np.abs(gy[:max(1, gy.shape[0]//20), :]))) openness_top_edge = 1.0 - min(1.0, top_edge_strip_gy / max(avg_abs_gy, 1e-5) / 0.5) return openness_top_edge except Exception as e: self.logger.error(f"Error computing top edge openness: {str(e)}") return 0.5 def _compute_legacy_compatibility_features(self, hsv_img: np.ndarray, small_gray: np.ndarray, features: Dict[str, Any], scale_factor: int) -> Dict[str, Any]: """Compute additional features for backward compatibility.""" try: v_channel = hsv_img[:, :, 2] # Light source detection light_features = self._detect_light_sources(v_channel, features["avg_brightness"], features["brightness_std"], scale_factor) # Street line detection street_score = self._compute_street_line_score(small_gray) # Additional legacy features legacy_features = { **light_features, "street_line_score": street_score, "sky_blue_ratio": features.get("sky_like_blue_ratio", 0.0), # Alias "gradient_ratio": features.get("gradient_ratio_vertical_horizontal", 1.0) # Alias } return legacy_features except Exception as e: self.logger.error(f"Error computing legacy compatibility features: {str(e)}") return {} def _detect_light_sources(self, v_channel: np.ndarray, avg_brightness: float, brightness_std: float, scale_factor: int) -> Dict[str, float]: """Detect artificial light sources in the image.""" try: # Sample pixels for efficiency sampled_v = v_channel[::scale_factor*2, ::scale_factor*2] # Light threshold light_threshold = min( self.config_manager.feature_thresholds.light_source_abs_thresh, avg_brightness + 2 * brightness_std ) is_bright_spots = sampled_v > light_threshold bright_spot_count = int(np.sum(is_bright_spots)) # Initialize light features circular_light_count = 0 indoor_light_score = 0.0 light_distribution_uniformity = 0.5 # Analyze light distribution if spots are found if 1 < bright_spot_count < 20: bright_y, bright_x = np.where(is_bright_spots) if len(bright_y) > 1: mean_x, mean_y = np.mean(bright_x), np.mean(bright_y) dist_from_center = np.sqrt((bright_x - mean_x)**2 + (bright_y - mean_y)**2) if np.std(dist_from_center) < np.mean(dist_from_center): circular_light_count = min(3, len(bright_y) // 2) light_distribution_uniformity = 0.7 if np.mean(bright_y) < sampled_v.shape[0] / 2: indoor_light_score = 0.6 else: indoor_light_score = 0.3 return { "bright_spot_count": bright_spot_count, "circular_light_count": circular_light_count, "indoor_light_score": indoor_light_score, "light_distribution_uniformity": light_distribution_uniformity } except Exception as e: self.logger.error(f"Error detecting light sources: {str(e)}") return { "bright_spot_count": 0, "circular_light_count": 0, "indoor_light_score": 0.0, "light_distribution_uniformity": 0.5 } def _compute_street_line_score(self, small_gray: np.ndarray) -> float: """Compute street line detection score.""" try: street_line_score = 0.0 bottom_half_sm = small_gray[small_gray.shape[0]//2:, :] if bottom_half_sm.size > 0: bottom_vert_gradient = cv2.Sobel(bottom_half_sm, cv2.CV_32F, 0, 1, ksize=3) strong_vert_lines = np.abs(bottom_vert_gradient) > 50 if np.sum(strong_vert_lines) > (bottom_half_sm.size * 0.05): street_line_score = 0.7 return street_line_score except Exception as e: self.logger.error(f"Error computing street line score: {str(e)}") return 0.0 def _compute_legacy_structure_features(self, gray_img: np.ndarray, height: int) -> Dict[str, float]: """Compute legacy structure features for backward compatibility.""" try: # Top region analysis for ceiling uniformity top_region = gray_img[:height//4, :] top_region_std = float(np.std(top_region)) if top_region.size > 0 else 0.0 ceiling_uniformity = 1.0 - min(1.0, top_region_std / max(float(np.mean(top_region)) if top_region.size > 0 else 1e-5, 1e-5)) # Horizontal line detection in top region if top_region.size > 0: top_gradients = np.abs(cv2.Sobel(top_region, cv2.CV_32F, 0, 1, ksize=3)) horizontal_lines_strength = float(np.mean(top_gradients)) horizontal_line_ratio = min(1.0, horizontal_lines_strength / 40.0) else: horizontal_line_ratio = 0.0 # Boundary edge score computation boundary_edge_score = self._compute_legacy_boundary_score(gray_img) return { "ceiling_uniformity": ceiling_uniformity, "horizontal_line_ratio": horizontal_line_ratio, "top_region_std": top_region_std, "boundary_edge_score": boundary_edge_score } except Exception as e: self.logger.error(f"Error computing legacy structure features: {str(e)}") return { "ceiling_uniformity": 0.5, "horizontal_line_ratio": 0.0, "top_region_std": 0.0, "boundary_edge_score": 0.0 } def _compute_legacy_boundary_score(self, gray_img: np.ndarray) -> float: """Compute legacy boundary edge score.""" try: height, width = gray_img.shape # Create small version for boundary analysis small_height, small_width = height // 4, width // 4 small_gray = cv2.resize(gray_img, (small_width, small_height), interpolation=cv2.INTER_AREA) # Edge regions left_edge_sm = small_gray[:, :small_width//6] if small_width > 6 else small_gray right_edge_sm = small_gray[:, 5*small_width//6:] if small_width > 6 else small_gray top_edge_sm = small_gray[:small_height//6, :] if small_height > 6 else small_gray # Compute gradients for each edge left_gradient = float(np.mean(np.abs(cv2.Sobel(left_edge_sm, cv2.CV_32F, 1, 0, ksize=3)))) if left_edge_sm.size > 0 else 0 right_gradient = float(np.mean(np.abs(cv2.Sobel(right_edge_sm, cv2.CV_32F, 1, 0, ksize=3)))) if right_edge_sm.size > 0 else 0 top_gradient = float(np.mean(np.abs(cv2.Sobel(top_edge_sm, cv2.CV_32F, 0, 1, ksize=3)))) if top_edge_sm.size > 0 else 0 # Combine and normalize boundary_edge_score = (min(1.0, left_gradient/50) + min(1.0, right_gradient/50) + min(1.0, top_gradient/50)) / 3 return boundary_edge_score except Exception as e: self.logger.error(f"Error computing legacy boundary score: {str(e)}") return 0.0 def _validate_image(self, image_rgb: np.ndarray) -> bool: """Validate input image format and dimensions.""" try: if not isinstance(image_rgb, np.ndarray): self.logger.error("Input is not a numpy array") return False if len(image_rgb.shape) != 3 or image_rgb.shape[2] != 3: self.logger.error(f"Invalid image shape: {image_rgb.shape}. Expected (H, W, 3)") return False height, width = image_rgb.shape[:2] if height == 0 or width == 0: self.logger.error(f"Invalid image dimensions: {height}x{width}") return False return True except Exception as e: self.logger.error(f"Error validating image: {str(e)}") return False def _calculate_scale_factor(self, height: int, width: int) -> int: """Calculate appropriate scale factor for image processing efficiency.""" try: base_scale = 4 scale_factor = base_scale + min(8, max(0, int((height * width) / (1000 * 1000)) if height * width > 0 else 0)) return max(1, scale_factor) except Exception as e: self.logger.error(f"Error calculating scale factor: {str(e)}") return 4 def _get_default_features(self) -> Dict[str, Any]: """Return default feature values in case of processing errors.""" return { "avg_brightness": 100.0, "brightness_std": 50.0, "dark_pixel_ratio": 0.0, "bright_pixel_ratio": 0.0, "brightness_uniformity": 0.5, "blue_ratio": 0.0, "sky_like_blue_ratio": 0.0, "yellow_orange_ratio": 0.0, "gray_ratio": 0.0, "avg_saturation": 100.0, "sky_region_brightness_ratio": 1.0, "sky_region_saturation": 0.0, "sky_region_blue_dominance": 0.0, "sky_brightness": 100.0, "warm_ratio": 0.0, "cool_ratio": 0.0, "color_atmosphere": "neutral", "gradient_ratio_vertical_horizontal": 1.0, "top_region_texture_complexity": 0.5, "shadow_clarity_score": 0.5, "vertical_strength": 0.0, "horizontal_strength": 0.0, "edges_density": 0.0, "ceiling_likelihood": 0.0, "boundary_clarity": 0.0, "openness_top_edge": 0.5, "ceiling_uniformity": 0.5, "horizontal_line_ratio": 0.0, "top_region_std": 0.0, "boundary_edge_score": 0.0, "bright_spot_count": 0, "circular_light_count": 0, "indoor_light_score": 0.0, "light_distribution_uniformity": 0.5, "street_line_score": 0.0, "sky_blue_ratio": 0.0, "gradient_ratio": 1.0 } def _get_default_color_features(self) -> Dict[str, Any]: """Return default color feature values.""" return { "blue_ratio": 0.0, "sky_like_blue_ratio": 0.0, "yellow_orange_ratio": 0.0, "gray_ratio": 0.0, "avg_saturation": 100.0, "sky_region_brightness_ratio": 1.0, "sky_region_saturation": 0.0, "sky_region_blue_dominance": 0.0, "sky_brightness": 100.0, "warm_ratio": 0.0, "cool_ratio": 0.0, "color_atmosphere": "neutral" } def _get_default_sky_features(self) -> Dict[str, float]: """Return default sky region feature values.""" return { "sky_region_brightness_ratio": 1.0, "sky_region_saturation": 0.0, "sky_region_blue_dominance": 0.0, "sky_brightness": 100.0 }