spatial_analyzer.py

import os
import numpy as np
from typing import Dict, List, Tuple, Any, Optional

from scene_type import SCENE_TYPES
from enhance_scene_describer import EnhancedSceneDescriber

class SpatialAnalyzer:
    """
    Analyzes spatial relationships between objects in an image.
    Handles region assignment, object positioning, and functional zone identification.
    """

    def __init__(self, class_names: Dict[int, str] = None, object_categories=None):
        """Initialize the spatial analyzer with image regions"""
        # Define regions of the image (3x3 grid)
        self.regions = {
            "top_left": (0, 0, 1/3, 1/3),
            "top_center": (1/3, 0, 2/3, 1/3),
            "top_right": (2/3, 0, 1, 1/3),
            "middle_left": (0, 1/3, 1/3, 2/3),
            "middle_center": (1/3, 1/3, 2/3, 2/3),
            "middle_right": (2/3, 1/3, 1, 2/3),
            "bottom_left": (0, 2/3, 1/3, 1),
            "bottom_center": (1/3, 2/3, 2/3, 1),
            "bottom_right": (2/3, 2/3, 1, 1)
        }

        self.class_names = class_names
        self.OBJECT_CATEGORIES = object_categories or {}
        self.enhance_descriptor = EnhancedSceneDescriber(scene_types=SCENE_TYPES)

        # Distances thresholds for proximity analysis (normalized)
        self.proximity_threshold = 0.2


    def _determine_region(self, x: float, y: float) -> str:
        """
        Determine which region a point falls into.

        Args:
            x: Normalized x-coordinate (0-1)
            y: Normalized y-coordinate (0-1)

        Returns:
            Region name
        """
        for region_name, (x1, y1, x2, y2) in self.regions.items():
            if x1 <= x < x2 and y1 <= y < y2:
                return region_name

        return "unknown"

    def _analyze_regions(self, detected_objects: List[Dict]) -> Dict:
        """
        Analyze object distribution across image regions.

        Args:
            detected_objects: List of detected objects with position information

        Returns:
            Dictionary with region analysis
        """
        # Count objects in each region
        region_counts = {region: 0 for region in self.regions.keys()}
        region_objects = {region: [] for region in self.regions.keys()}

        for obj in detected_objects:
            region = obj["region"]
            if region in region_counts:
                region_counts[region] += 1
                region_objects[region].append({
                    "class_id": obj["class_id"],
                    "class_name": obj["class_name"]
                })

        # Determine main focus regions (top 1-2 regions by object count)
        sorted_regions = sorted(region_counts.items(), key=lambda x: x[1], reverse=True)
        main_regions = [region for region, count in sorted_regions if count > 0][:2]

        return {
            "counts": region_counts,
            "main_focus": main_regions,
            "objects_by_region": region_objects
        }

    def _extract_detected_objects(self, detection_result: Any, confidence_threshold: float = 0.25) -> List[Dict]:
        """
        Extract detected objects from detection result with position information.

        Args:
            detection_result: Detection result from YOLOv8
            confidence_threshold: Minimum confidence threshold

        Returns:
            List of dictionaries with detected object information
        """
        boxes = detection_result.boxes.xyxy.cpu().numpy()
        classes = detection_result.boxes.cls.cpu().numpy().astype(int)
        confidences = detection_result.boxes.conf.cpu().numpy()

        # Image dimensions
        img_height, img_width = detection_result.orig_shape[:2]

        detected_objects = []
        for box, class_id, confidence in zip(boxes, classes, confidences):
            # Skip objects with confidence below threshold
            if confidence < confidence_threshold:
                continue

            x1, y1, x2, y2 = box
            width = x2 - x1
            height = y2 - y1

            # Center point
            center_x = (x1 + x2) / 2
            center_y = (y1 + y2) / 2

            # Normalized positions (0-1)
            norm_x = center_x / img_width
            norm_y = center_y / img_height
            norm_width = width / img_width
            norm_height = height / img_height

            # Area calculation
            area = width * height
            norm_area = area / (img_width * img_height)

            # Region determination
            object_region = self._determine_region(norm_x, norm_y)

            detected_objects.append({
                "class_id": int(class_id),
                "class_name": self.class_names[int(class_id)],
                "confidence": float(confidence),
                "box": [float(x1), float(y1), float(x2), float(y2)],
                "center": [float(center_x), float(center_y)],
                "normalized_center": [float(norm_x), float(norm_y)],
                "size": [float(width), float(height)],
                "normalized_size": [float(norm_width), float(norm_height)],
                "area": float(area),
                "normalized_area": float(norm_area),
                "region": object_region
            })

        return detected_objects


    def _detect_scene_viewpoint(self, detected_objects: List[Dict]) -> Dict:
        """
        檢測場景視角並識別特殊場景模式。

        Args:
            detected_objects: 檢測到的物體列表

        Returns:
            Dict: 包含視角和場景模式信息的字典
        """
        if not detected_objects:
            return {"viewpoint": "eye_level", "patterns": []}

        # 從物體位置中提取信息
        patterns = []

        # 檢測行人位置模式
        pedestrian_objs = [obj for obj in detected_objects if obj["class_id"] == 0]

        # 檢查是否有足夠的行人來識別模式
        if len(pedestrian_objs) >= 4:
            pedestrian_positions = [obj["normalized_center"] for obj in pedestrian_objs]

            # 檢測十字交叉模式
            if self._detect_cross_pattern(pedestrian_positions):
                patterns.append("crosswalk_intersection")

            # 檢測多方向行人流
            directions = self._analyze_movement_directions(pedestrian_positions)
            if len(directions) >= 2:
                patterns.append("multi_directional_movement")

        # 檢查物體的大小一致性 - 在空中俯視圖中，物體大小通常更一致
        if len(detected_objects) >= 5:
            sizes = [obj.get("normalized_area", 0) for obj in detected_objects]
            size_variance = np.var(sizes) / (np.mean(sizes) ** 2)  # 標準化變異數，不會受到平均值影響

            if size_variance < 0.3:  # 低變異表示大小一致
                patterns.append("consistent_object_size")

        # 基本視角檢測
        viewpoint = self.enhance_descriptor._detect_viewpoint(detected_objects)

        # 根據檢測到的模式增強視角判斷
        if "crosswalk_intersection" in patterns and viewpoint != "aerial":
            # 如果檢測到斑馬線交叉但視角判斷不是空中視角，優先採用模式判斷
            viewpoint = "aerial"

        return {
            "viewpoint": viewpoint,
            "patterns": patterns
        }

    def _detect_cross_pattern(self, positions):
        """
        檢測位置中的十字交叉模式

        Args:
            positions: 位置列表 [[x1, y1], [x2, y2], ...]

        Returns:
            bool: 是否檢測到十字交叉模式
        """
        if len(positions) < 8:  # 需要足夠多的點
            return False

        # 提取 x 和 y 坐標
        x_coords = [pos[0] for pos in positions]
        y_coords = [pos[1] for pos in positions]

        # 檢測 x 和 y 方向的聚類
        x_clusters = []
        y_clusters = []

        # 簡化的聚類分析
        x_mean = np.mean(x_coords)
        y_mean = np.mean(y_coords)

        # 計算在中心線附近的點
        near_x_center = sum(1 for x in x_coords if abs(x - x_mean) < 0.1)
        near_y_center = sum(1 for y in y_coords if abs(y - y_mean) < 0.1)

        # 如果有足夠的點在中心線附近，可能是十字交叉
        return near_x_center >= 3 and near_y_center >= 3

    def _analyze_movement_directions(self, positions):
        """
        分析位置中的移動方向

        Args:
            positions: 位置列表 [[x1, y1], [x2, y2], ...]

        Returns:
            list: 檢測到的主要方向
        """
        if len(positions) < 6:
            return []

        # extract x 和 y 坐標
        x_coords = [pos[0] for pos in positions]
        y_coords = [pos[1] for pos in positions]

        directions = []

        # horizontal move (left --> right)
        x_std = np.std(x_coords)
        x_range = max(x_coords) - min(x_coords)

        # vertical move(up --> down)
        y_std = np.std(y_coords)
        y_range = max(y_coords) - min(y_coords)

        # 足夠大的範圍表示該方向有運動
        if x_range > 0.4:
            directions.append("horizontal")
        if y_range > 0.4:
            directions.append("vertical")

        return directions

    def _identify_functional_zones(self, detected_objects: List[Dict], scene_type: str) -> Dict:
        """
        Identify functional zones within the scene with improved detection for different viewpoints
        and cultural contexts.

        Args:
            detected_objects: List of detected objects
            scene_type: Identified scene type

        Returns:
            Dictionary of functional zones with their descriptions
        """
        # Group objects by category and region
        category_regions = {}

        if not getattr(self, 'enable_landmark', True):
            detected_objects = [obj for obj in detected_objects if not obj.get("is_landmark", False)]

        # 過濾地標相關場景類型
        if scene_type in ["tourist_landmark", "natural_landmark", "historical_monument"]:
            scene_type = "city_street"

        # MODIFIED: Smart threshold evaluation instead of fixed values
        should_identify = self._evaluate_zone_identification_feasibility(detected_objects, scene_type)

        if not should_identify:
            return {}

        # MODIFIED: Build category_regions mapping (was missing in original)
        for obj in detected_objects:
            category = self._categorize_object(obj)
            if not category:
                continue

            if category not in category_regions:
                category_regions[category] = {}

            region = obj.get("region", "center")
            if region not in category_regions[category]:
                category_regions[category][region] = []

            category_regions[category][region].append(obj)

        # Identify zones based on object groupings
        zones = {}

        # Detect viewpoint to adjust zone identification strategy
        viewpoint = self._detect_scene_viewpoint(detected_objects)

        # Choose appropriate zone identification strategy based on scene type and viewpoint
        if scene_type in ["living_room", "bedroom", "dining_area", "kitchen", "office_workspace", "meeting_room"]:
            # Indoor scenes
            zones.update(self._identify_indoor_zones(category_regions, detected_objects, scene_type))
        elif scene_type in ["city_street", "parking_lot", "park_area"]:
            # Outdoor general scenes
            zones.update(self._identify_outdoor_general_zones(category_regions, detected_objects, scene_type))
        elif "aerial" in scene_type or viewpoint == "aerial":
            # Aerial viewpoint scenes
            zones.update(self._identify_aerial_view_zones(category_regions, detected_objects, scene_type))
        elif "asian" in scene_type:
            # Asian cultural context scenes
            zones.update(self._identify_asian_cultural_zones(category_regions, detected_objects, scene_type))
        elif scene_type == "urban_intersection":
            # Specific urban intersection logic
            zones.update(self._identify_intersection_zones(category_regions, detected_objects, viewpoint))
        elif scene_type == "financial_district":
            # Financial district specific logic
            zones.update(self._identify_financial_district_zones(category_regions, detected_objects))
        elif scene_type == "upscale_dining":
            # Upscale dining specific logic
            zones.update(self._identify_upscale_dining_zones(category_regions, detected_objects))
        elif scene_type == "tourist_landmark" or "landmark" in scene_type:
            # 處理地標場景類型
            landmark_objects = [obj for obj in detected_objects if obj.get("is_landmark", False)]
            if landmark_objects:
                landmark_zones = self._identify_landmark_zones(landmark_objects)
                zones.update(landmark_zones)
        else:
            # Default zone identification for other scene types
            zones.update(self._identify_default_zones(category_regions, detected_objects))

        # 檢查是否有地標物體但場景類型不是地標類型
        if scene_type != "tourist_landmark" and "landmark" not in scene_type:
            landmark_objects = [obj for obj in detected_objects if obj.get("is_landmark", False)]
            if landmark_objects:
                # 添加地標功能區，但不覆蓋已有的功能區
                landmark_zones = self._identify_landmark_zones(landmark_objects)
                # 確保地標區域不會覆蓋已識別的其他重要功能區
                for zone_id, zone_info in landmark_zones.items():
                    if zone_id not in zones:
                        zones[zone_id] = zone_info

        # MODIFIED: Enhanced fallback strategy - try simplified identification if no zones found
        if not zones:
            zones.update(self._identify_default_zones(category_regions, detected_objects))

            # Final fallback: create basic zones from high-confidence objects
            if not zones:
                zones.update(self._create_basic_zones_from_objects(detected_objects, scene_type))

        return zones

    def _identify_core_objects_for_scene(self, detected_objects: List[Dict], scene_type: str) -> List[Dict]:
        """
        Identify core objects that define a particular scene type.

        Args:
            detected_objects: List of detected objects
            scene_type: Scene type

        Returns:
            List of core objects for the scene
        """
        core_objects = []

        scene_core_mapping = {
            "bedroom": [59],  # bed
            "kitchen": [68, 69, 71, 72],  # microwave, oven, sink, refrigerator
            "living_room": [57, 58, 62],  # sofa, chair, tv
            "dining_area": [60, 46, 47],  # dining table, fork, knife
            "office_workspace": [63, 64, 66, 73]  # laptop, mouse, keyboard, book
        }

        if scene_type in scene_core_mapping:
            core_class_ids = scene_core_mapping[scene_type]
            for obj in detected_objects:
                if obj["class_id"] in core_class_ids and obj.get("confidence", 0) >= 0.4:
                    core_objects.append(obj)

        return core_objects

    def _get_object_categories(self, detected_objects: List[Dict]) -> set:
        """Get unique object categories from detected objects."""
        object_categories = set()
        for obj in detected_objects:
            category = self._categorize_object(obj)
            if category:
                object_categories.add(category)
        return object_categories

    def _create_basic_zones_from_objects(self, detected_objects: List[Dict], scene_type: str) -> Dict:
        """
        Create basic functional zones from individual high-confidence objects.
        This is a fallback when standard zone identification fails.

        Args:
            detected_objects: List of detected objects
            scene_type: Scene type

        Returns:
            Dictionary of basic zones
        """
        zones = {}

        # Focus on high-confidence objects
        high_conf_objects = [obj for obj in detected_objects if obj.get("confidence", 0) >= 0.6]

        if not high_conf_objects:
            high_conf_objects = detected_objects  # Fallback to all objects

        # Create zones based on individual important objects
        for i, obj in enumerate(high_conf_objects[:3]):  # Limit to top 3 objects
            class_name = obj["class_name"]
            region = obj.get("region", "center")

            # Create descriptive zone based on object type
            zone_description = self._get_basic_zone_description(class_name, scene_type)

            if zone_description:
                zones[f"functional_area_{i+1}"] = {
                    "region": region,
                    "objects": [class_name],
                    "description": zone_description
                }

        return zones

    def _get_basic_zone_description(self, class_name: str, scene_type: str) -> str:
        """Generate basic zone description based on object and scene type."""

        # Object-specific descriptions
        descriptions = {
            "bed": "Sleeping and rest area",
            "sofa": "Seating and relaxation area",
            "chair": "Seating area",
            "dining table": "Dining and meal area",
            "tv": "Entertainment and media area",
            "laptop": "Work and computing area",
            "potted plant": "Decorative and green space area",
            "refrigerator": "Food storage and kitchen area",
            "car": "Vehicle and transportation area",
            "person": "Activity and social area"
        }

        return descriptions.get(class_name, f"Functional area with {class_name}")

    def _categorize_object(self, obj: Dict) -> str:
        """
        Categorize detected objects into functional categories for zone identification.
        """
        class_id = obj.get("class_id", -1)
        class_name = obj.get("class_name", "").lower()

        # Use existing category mapping if available
        if hasattr(self, 'OBJECT_CATEGORIES') and self.OBJECT_CATEGORIES:
            for category, ids in self.OBJECT_CATEGORIES.items():
                if class_id in ids:
                    return category

        # Fallback categorization based on class names for common COCO classes
        furniture_items = ["chair", "couch", "bed", "dining table", "toilet"]
        plant_items = ["potted plant"]
        electronic_items = ["tv", "laptop", "mouse", "remote", "keyboard", "cell phone"]
        vehicle_items = ["bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat"]
        person_items = ["person"]
        kitchen_items = ["bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl",
                        "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog",
                        "pizza", "donut", "cake", "refrigerator", "oven", "toaster", "sink", "microwave"]
        sports_items = ["frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
                    "baseball glove", "skateboard", "surfboard", "tennis racket"]
        personal_items = ["handbag", "tie", "suitcase", "umbrella", "backpack"]

        if any(item in class_name for item in furniture_items):
            return "furniture"
        elif any(item in class_name for item in plant_items):
            return "plant"
        elif any(item in class_name for item in electronic_items):
            return "electronics"
        elif any(item in class_name for item in vehicle_items):
            return "vehicle"
        elif any(item in class_name for item in person_items):
            return "person"
        elif any(item in class_name for item in kitchen_items):
            return "kitchen_items"
        elif any(item in class_name for item in sports_items):
            return "sports"
        elif any(item in class_name for item in personal_items):
            return "personal_items"
        else:
            return "misc"

    def _evaluate_zone_identification_feasibility(self, detected_objects: List[Dict], scene_type: str) -> bool:
        """
        基於物件關聯性和分布特徵的彈性可行性評估
        """
        if len(detected_objects) < 2:
            return False

        # 計算不同置信度層級的物件分布
        high_conf_objects = [obj for obj in detected_objects if obj.get("confidence", 0) >= 0.6]
        medium_conf_objects = [obj for obj in detected_objects if obj.get("confidence", 0) >= 0.4]

        # 基礎條件：至少需要一定數量的可信物件
        if len(medium_conf_objects) < 2:
            return False

        # evalure relationships
        functional_relationships = self._calculate_functional_relationships(detected_objects)

        # 評估space的分布多樣性
        spatial_diversity = self._calculate_spatial_diversity(detected_objects)

        # 綜合評分機制
        feasibility_score = 0

        # 物件數量的貢獻值（權重30%）
        object_count_score = min(len(detected_objects) / 5.0, 1.0) * 0.3

        # 信心度質量貢獻（權重25%）
        confidence_score = len(high_conf_objects) / max(len(detected_objects), 1) * 0.25

        # 功能關聯性貢獻（權重25%）
        relationship_score = functional_relationships * 0.25

        # space多樣性貢獻（權重20%）
        diversity_score = spatial_diversity * 0.20

        feasibility_score = object_count_score + confidence_score + relationship_score + diversity_score

        # 動態閾值：基於場景複雜度調整
        complexity_threshold = self._get_complexity_threshold(scene_type)

        return feasibility_score >= complexity_threshold

    def _calculate_functional_relationships(self, detected_objects: List[Dict]) -> float:
        """
        計算物件間的功能關聯性評分
        基於常見的物件組合模式評估功能相關性
        """
        relationship_pairs = {
            # 家具組合關係
            frozenset([56, 60]): 1.0,  # 椅子+桌子 (dining/work area)
            frozenset([57, 62]): 0.9,  # 沙發+電視 (living area)
            frozenset([59, 58]): 0.7,  # 床+植物 (bedroom decor)

            # 工作相關組合
            frozenset([63, 66]): 0.9,  # 筆電+鍵盤 (workspace)
            frozenset([63, 64]): 0.8,  # 筆電+滑鼠 (workspace)
            frozenset([60, 63]): 0.8,  # 桌子+筆電 (workspace)

            # 廚房相關組合
            frozenset([68, 72]): 0.9,  # 微波爐+冰箱 (kitchen)
            frozenset([69, 71]): 0.8,  # 烤箱+水槽 (kitchen)

            # 用餐相關組合
            frozenset([60, 40]): 0.8,  # 桌子+酒杯 (dining)
            frozenset([60, 41]): 0.8,  # 桌子+杯子 (dining)
            frozenset([56, 40]): 0.7,  # 椅子+酒杯 (dining)

            # 交通相關組合
            frozenset([2, 9]): 0.8,   # 汽車+交通燈 (traffic)
            frozenset([0, 9]): 0.7,   # 行人+交通燈 (crosswalk)
        }

        detected_class_ids = set(obj["class_id"] for obj in detected_objects)
        max_possible_score = 0
        actual_score = 0

        for pair, score in relationship_pairs.items():
            max_possible_score += score
            if pair.issubset(detected_class_ids):
                actual_score += score

        return actual_score / max_possible_score if max_possible_score > 0 else 0

    def _calculate_spatial_diversity(self, detected_objects: List[Dict]) -> float:
        """
        計算物件空間分布的多樣性
        評估物件是否分散在不同區域，避免所有物件集中在單一區域
        """
        regions = set(obj.get("region", "center") for obj in detected_objects)
        unique_regions = len(regions)

        return min(unique_regions / 2.0, 1.0)

    def _get_complexity_threshold(self, scene_type: str) -> float:
        """
        可根據場景類型返回適當的複雜度閾值
        平衡不同場景的區域劃分需求
        """
        # 較簡單場景需要較高分數才進行區域劃分
        simple_scenes = ["bedroom", "bathroom", "closet"]
        # 較複雜場景可以較低分數進行區域劃分
        complex_scenes = ["living_room", "kitchen", "office_workspace", "dining_area"]

        if scene_type in simple_scenes:
            return 0.65  # 較高閾值，避免過度細分
        elif scene_type in complex_scenes:
            return 0.45  # 較低閾值，允許合理劃分
        else:
            return 0.55  # 中等閾值，平衡策略

    def _identify_indoor_zones(self, category_regions: Dict, detected_objects: List[Dict], scene_type: str) -> Dict:
        """
        平衡化的室內功能區域識別
        採用通用的物件關聯性分析，避免場景特定的硬編碼
        """
        zones = {}

        # 辨識到主要功能區域（基於物件關聯性而非場景類型）
        primary_zone = self._identify_primary_functional_area(detected_objects)
        if primary_zone:
            zones["primary_area"] = primary_zone

        # 只有明確證據且物件數量足夠時創建次要功能區域
        if len(zones) >= 1 and len(detected_objects) >= 6:
            secondary_zone = self._identify_secondary_functional_area(detected_objects, zones)
            if secondary_zone:
                zones["secondary_area"] = secondary_zone

        return zones

    def _identify_primary_functional_area(self, detected_objects: List[Dict]) -> Dict:
        """
        辨識主要功能區域，基於最強的物件關聯性組合
        採用通用邏輯處理各種室內場景
        """
        # 用餐區域檢測（桌椅組合）
        dining_area = self._detect_functional_combination(
            detected_objects,
            primary_objects=[60],  # dining table
            supporting_objects=[56, 40, 41, 42, 43],  # chair, wine glass, cup, fork, knife
            min_supporting=2,
            description_template="Dining area with table and seating arrangement"
        )
        if dining_area:
            return dining_area

        # 休息區域檢測（沙發電視組合或床）
        seating_area = self._detect_functional_combination(
            detected_objects,
            primary_objects=[57, 59],  # sofa, bed
            supporting_objects=[62, 58, 56],  # tv, potted plant, chair
            min_supporting=1,
            description_template="Seating and relaxation area"
        )
        if seating_area:
            return seating_area

        # 工作區域檢測（電子設備與家具組合）
        work_area = self._detect_functional_combination(
            detected_objects,
            primary_objects=[63, 66],  # laptop, keyboard
            supporting_objects=[60, 56, 64],  # dining table, chair, mouse
            min_supporting=2,
            description_template="Workspace area with electronics and furniture"
        )
        if work_area:
            return work_area

        return None

    def _identify_secondary_functional_area(self, detected_objects: List[Dict], existing_zones: Dict) -> Dict:
        """
        識別次要功能區域，避免與主要區域重疊
        """
        # 獲取已使用的區域
        used_regions = set(zone["region"] for zone in existing_zones.values())

        # 裝飾區域檢測（植物集中區域）
        decorative_area = self._detect_functional_combination(
            detected_objects,
            primary_objects=[58],  # potted plant
            supporting_objects=[75],  # vase
            min_supporting=0,
            min_primary=3,  # 至少需要3個植物
            description_template="Decorative area with plants and ornamental items",
            exclude_regions=used_regions
        )
        if decorative_area:
            return decorative_area

        # 儲存區域檢測（廚房電器組合）
        storage_area = self._detect_functional_combination(
            detected_objects,
            primary_objects=[72, 68, 69],  # refrigerator, microwave, oven
            supporting_objects=[71],  # sink
            min_supporting=0,
            min_primary=2,
            description_template="Kitchen appliance and storage area",
            exclude_regions=used_regions
        )
        if storage_area:
            return storage_area

        return None

    def _detect_functional_combination(self, detected_objects: List[Dict], primary_objects: List[int],
                                    supporting_objects: List[int], min_supporting: int,
                                    description_template: str, min_primary: int = 1,
                                    exclude_regions: set = None) -> Dict:
        """
        通用的功能組合檢測方法
        基於主要物件和支持物件的組合判斷功能區域

        Args:
            detected_objects: 檢測到的物件列表
            primary_objects: 主要物件的class_id列表
            supporting_objects: 支持物件的class_id列表
            min_supporting: 最少需要的支持物件數量
            description_template: 描述模板
            min_primary: 最少需要的主要物件數量
            exclude_regions: 需要排除的區域集合

        Returns:
            Dict: 功能區域資訊，如果不符合條件則返回None
        """
        if exclude_regions is None:
            exclude_regions = set()

        # 收集主要物件
        primary_objs = [obj for obj in detected_objects
                    if obj["class_id"] in primary_objects and obj.get("confidence", 0) >= 0.4]

        # 收集支持物件
        supporting_objs = [obj for obj in detected_objects
                        if obj["class_id"] in supporting_objects and obj.get("confidence", 0) >= 0.4]

        # 檢查是否滿足最少數量要求
        if len(primary_objs) < min_primary or len(supporting_objs) < min_supporting:
            return None

        # 按區域組織物件
        region_combinations = {}
        all_relevant_objs = primary_objs + supporting_objs

        for obj in all_relevant_objs:
            region = obj["region"]

            # 排除指定區域
            if region in exclude_regions:
                continue

            if region not in region_combinations:
                region_combinations[region] = {"primary": [], "supporting": [], "all": []}

            region_combinations[region]["all"].append(obj)

            if obj["class_id"] in primary_objects:
                region_combinations[region]["primary"].append(obj)
            else:
                region_combinations[region]["supporting"].append(obj)

        # 找到最佳區域組合
        best_region = None
        best_score = 0

        for region, objs in region_combinations.items():
            # 計算該區域的評分
            primary_count = len(objs["primary"])
            supporting_count = len(objs["supporting"])

            # 必須滿足最低要求
            if primary_count < min_primary or supporting_count < min_supporting:
                continue

            # 計算組合評分（主要物件權重較高）
            score = primary_count * 2 + supporting_count

            if score > best_score:
                best_score = score
                best_region = region

        if best_region is None:
            return None

        best_combination = region_combinations[best_region]
        all_objects = [obj["class_name"] for obj in best_combination["all"]]

        return {
            "region": best_region,
            "objects": all_objects,
            "description": description_template
        }

    def _identify_intersection_zones(self, category_regions: Dict, detected_objects: List[Dict], viewpoint: str) -> Dict:
        """
        Identify functional zones for urban intersections with enhanced spatial awareness.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects
            viewpoint: Detected viewpoint

        Returns:
            Dict: Refined intersection functional zones
        """
        zones = {}

        # Get pedestrians, vehicles and traffic signals
        pedestrian_objs = [obj for obj in detected_objects if obj["class_id"] == 0]
        vehicle_objs = [obj for obj in detected_objects if obj["class_id"] in [1, 2, 3, 5, 7]]  # bicycle, car, motorcycle, bus, truck
        traffic_light_objs = [obj for obj in detected_objects if obj["class_id"] == 9]

        # Create distribution maps for better spatial understanding
        regions_distribution = self._create_distribution_map(detected_objects)

        # Analyze pedestrian crossing patterns
        crossing_zones = self._analyze_crossing_patterns(pedestrian_objs, traffic_light_objs, regions_distribution)
        zones.update(crossing_zones)

        # Analyze vehicle traffic zones with directional awareness
        traffic_zones = self._analyze_traffic_zones(vehicle_objs, regions_distribution)
        zones.update(traffic_zones)

        # Identify traffic control zones based on signal placement
        if traffic_light_objs:
            # Group traffic lights by region for better organization
            signal_regions = {}
            for obj in traffic_light_objs:
                region = obj["region"]
                if region not in signal_regions:
                    signal_regions[region] = []
                signal_regions[region].append(obj)

            # Create traffic control zones for each region with signals
            for idx, (region, signals) in enumerate(signal_regions.items()):
                # Check if this region has a directional name
                direction = self._get_directional_description(region)

                zones[f"traffic_control_zone_{idx+1}"] = {
                    "region": region,
                    "objects": ["traffic light"] * len(signals),
                    "description": f"Traffic control area with {len(signals)} traffic signals" +
                                (f" in {direction} area" if direction else "")
                }

        return zones

    def _identify_landmark_zones(self, landmark_objects: List[Dict]) -> Dict:
        """
        識別與地標相關的功能區域

        Args:
            landmark_objects: 被識別為地標的物體列表

        Returns:
            Dict: 地標相關的功能區域
        """
        landmark_zones = {}

        if not landmark_objects:
            print("Warning: No landmark objects provided to _identify_landmark_zones")
            return landmark_zones

        try:
            for i, landmark in enumerate(landmark_objects):
                if not isinstance(landmark, dict):
                    print(f"Warning: Landmark object at index {i} is not a dictionary: {type(landmark)}")
                    continue

                landmark_id = landmark.get("landmark_id")
                if not landmark_id:
                    print(f"Warning: Missing landmark_id for landmark at index {i}")
                    landmark_id = f"unknown_landmark_{i}"

                landmark_name = landmark.get("class_name", "Landmark")
                landmark_type = landmark.get("landmark_type", "architectural")
                landmark_region = landmark.get("region", "middle_center")

                # 為地標創建主要觀景區
                zone_id = f"landmark_zone_{i+1}"
                zone_name = f"{landmark_name} Viewing Area"

                # 根據地標類型調整描述
                if landmark_type == "natural":
                    zone_description = f"Scenic viewpoint for observing {landmark_name}, a notable natural landmark in {landmark.get('location', 'this area')}."
                    primary_function = "Nature observation and photography"
                elif landmark_type == "monument":
                    zone_description = f"Viewing area around {landmark_name}, a significant monument in {landmark.get('location', 'this area')}."
                    primary_function = "Historical appreciation and cultural tourism"
                else:  # architectural
                    zone_description = f"Area centered around {landmark_name}, where visitors can observe and appreciate this iconic structure in {landmark.get('location', 'this area')}."
                    primary_function = "Architectural tourism and photography"

                # 確定與地標相關的物體
                related_objects = ["person", "camera", "cell phone", "backpack"]

                # 創建功能區域
                landmark_zones[zone_id] = {
                    "name": zone_name,
                    "description": zone_description,
                    "objects": ["landmark"] + [obj for obj in related_objects if obj in [o.get("class_name") for o in landmark_objects]],
                    "region": landmark_region,
                    "primary_function": primary_function
                }

                # 如果有建造年份信息，加到描述中
                if "year_built" in landmark:
                    landmark_zones[zone_id]["description"] += f" Built in {landmark['year_built']}."

                # 如果有建築風格信息，加到描述中
                if "architectural_style" in landmark:
                    landmark_zones[zone_id]["description"] += f" Features {landmark['architectural_style']} architectural style."

                # 如果有重要性信息，加到描述中
                if "significance" in landmark:
                    landmark_zones[zone_id]["description"] += f" {landmark['significance']}."

                try:
                    # 創建照相區
                    photo_region = landmark_region  # 默認與地標在同一區域

                    # 根據地標位置調整照相區位置（地標前方通常是照相區）
                    region_mapping = {
                        "top_left": "bottom_right",
                        "top_center": "bottom_center",
                        "top_right": "bottom_left",
                        "middle_left": "middle_right",
                        "middle_center": "bottom_center",
                        "middle_right": "middle_left",
                        "bottom_left": "top_right",
                        "bottom_center": "top_center",
                        "bottom_right": "top_left"
                    }

                    if landmark_region in region_mapping:
                        photo_region = region_mapping[landmark_region]

                    landmark_zones[f"photo_spot_{i+1}"] = {
                        "name": f"{landmark_name} Photography Spot",
                        "description": f"Popular position for photographing {landmark_name} with optimal viewing angle.",
                        "objects": ["camera", "person", "cell phone"],
                        "region": photo_region,
                        "primary_function": "Tourist photography"
                    }
                except Exception as e:
                    print(f"Error creating photo spot zone: {e}")

                try:
                    # 如果是著名地標，可能有紀念品販售區
                    if landmark.get("confidence", 0) > 0.7:  # 高置信度地標更可能有紀念品區
                        # 根據地標位置找到適合的紀念品區位置（通常在地標附近但不直接在地標上）
                        adjacent_regions = {
                            "top_left": ["top_center", "middle_left"],
                            "top_center": ["top_left", "top_right"],
                            "top_right": ["top_center", "middle_right"],
                            "middle_left": ["top_left", "bottom_left"],
                            "middle_center": ["middle_left", "middle_right"],
                            "middle_right": ["top_right", "bottom_right"],
                            "bottom_left": ["middle_left", "bottom_center"],
                            "bottom_center": ["bottom_left", "bottom_right"],
                            "bottom_right": ["bottom_center", "middle_right"]
                        }

                        if landmark_region in adjacent_regions:
                            souvenir_region = adjacent_regions[landmark_region][0]  # 選擇第一個相鄰區域

                            landmark_zones[f"souvenir_area_{i+1}"] = {
                                "name": f"{landmark_name} Souvenir Area",
                                "description": f"Area where visitors can purchase souvenirs and memorabilia related to {landmark_name}.",
                                "objects": ["person", "handbag", "backpack"],
                                "region": souvenir_region,
                                "primary_function": "Tourism commerce"
                            }
                except Exception as e:
                    print(f"Error creating souvenir area zone: {e}")

        except Exception as e:
            print(f"Error in _identify_landmark_zones: {e}")
            import traceback
            traceback.print_exc()

        return landmark_zones

    def _analyze_crossing_patterns(self, pedestrians: List[Dict], traffic_lights: List[Dict],
                                region_distribution: Dict) -> Dict:
        """
        Analyze pedestrian crossing patterns to identify crosswalk zones.

        Args:
            pedestrians: List of pedestrian objects
            traffic_lights: List of traffic light objects
            region_distribution: Distribution of objects by region

        Returns:
            Dict: Identified crossing zones
        """
        crossing_zones = {}

        if not pedestrians:
            return crossing_zones

        # Group pedestrians by region
        pedestrian_regions = {}
        for p in pedestrians:
            region = p["region"]
            if region not in pedestrian_regions:
                pedestrian_regions[region] = []
            pedestrian_regions[region].append(p)

        # Sort regions by pedestrian count to find main crossing areas
        sorted_regions = sorted(pedestrian_regions.items(), key=lambda x: len(x[1]), reverse=True)

        # Create crossing zones for regions with pedestrians
        for idx, (region, peds) in enumerate(sorted_regions[:2]):  # Focus on top 2 regions
            # Check if there are traffic lights nearby to indicate a crosswalk
            has_nearby_signals = any(t["region"] == region for t in traffic_lights)

            # Create crossing zone with descriptive naming
            zone_name = f"crossing_zone_{idx+1}"
            direction = self._get_directional_description(region)

            description = f"Pedestrian crossing area with {len(peds)} "
            description += "person" if len(peds) == 1 else "people"
            if direction:
                description += f" in {direction} direction"
            if has_nearby_signals:
                description += " near traffic signals"

            crossing_zones[zone_name] = {
                "region": region,
                "objects": ["pedestrian"] * len(peds),
                "description": description
            }

        return crossing_zones

    def _analyze_traffic_zones(self, vehicles: List[Dict], region_distribution: Dict) -> Dict:
        """
        Analyze vehicle distribution to identify traffic zones with directional awareness.

        Args:
            vehicles: List of vehicle objects
            region_distribution: Distribution of objects by region

        Returns:
            Dict: Identified traffic zones
        """
        traffic_zones = {}

        if not vehicles:
            return traffic_zones

        # 把運輸工具歸成一區
        vehicle_regions = {}
        for v in vehicles:
            region = v["region"]
            if region not in vehicle_regions:
                vehicle_regions[region] = []
            vehicle_regions[region].append(v)

        # Create traffic zones for regions with vehicles
        main_traffic_region = max(vehicle_regions.items(), key=lambda x: len(x[1]), default=(None, []))

        if main_traffic_region[0] is not None:
            region = main_traffic_region[0]
            vehicles_in_region = main_traffic_region[1]

            # Get a list of vehicle types for description
            vehicle_types = [v["class_name"] for v in vehicles_in_region]
            unique_types = list(set(vehicle_types))

            # Get directional description
            direction = self._get_directional_description(region)

            # Create descriptive zone
            traffic_zones["vehicle_zone"] = {
                "region": region,
                "objects": vehicle_types,
                "description": f"Vehicle traffic area with {', '.join(unique_types[:3])}" +
                            (f" in {direction} area" if direction else "")
            }

            # If vehicles are distributed across multiple regions, create secondary zones
            if len(vehicle_regions) > 1:
                # Get second most populated region
                sorted_regions = sorted(vehicle_regions.items(), key=lambda x: len(x[1]), reverse=True)
                if len(sorted_regions) > 1:
                    second_region, second_vehicles = sorted_regions[1]
                    direction = self._get_directional_description(second_region)
                    vehicle_types = [v["class_name"] for v in second_vehicles]
                    unique_types = list(set(vehicle_types))

                    traffic_zones["secondary_vehicle_zone"] = {
                        "region": second_region,
                        "objects": vehicle_types,
                        "description": f"Secondary traffic area with {', '.join(unique_types[:2])}" +
                                    (f" in {direction} direction" if direction else "")
                    }

        return traffic_zones

    def _get_directional_description(self, region: str) -> str:
        """
        把方向轉換成方位(東西南北)

        Args:
            region: Region name from the grid

        Returns:
            str: Directional description
        """
        if "top" in region and "left" in region:
            return "northwest"
        elif "top" in region and "right" in region:
            return "northeast"
        elif "bottom" in region and "left" in region:
            return "southwest"
        elif "bottom" in region and "right" in region:
            return "southeast"
        elif "top" in region:
            return "north"
        elif "bottom" in region:
            return "south"
        elif "left" in region:
            return "west"
        elif "right" in region:
            return "east"
        else:
            return "central"

    def _create_distribution_map(self, detected_objects: List[Dict]) -> Dict:
        """
        Create a distribution map of objects across regions for spatial analysis.

        Args:
            detected_objects: List of detected objects

        Returns:
            Dict: Distribution map of objects by region and class
        """
        distribution = {}

        # Initialize all regions
        for region in self.regions.keys():
            distribution[region] = {
                "total": 0,
                "objects": {},
                "density": 0
            }

        # Populate the distribution
        for obj in detected_objects:
            region = obj["region"]
            class_id = obj["class_id"]
            class_name = obj["class_name"]

            distribution[region]["total"] += 1

            if class_id not in distribution[region]["objects"]:
                distribution[region]["objects"][class_id] = {
                    "name": class_name,
                    "count": 0,
                    "positions": []
                }

            distribution[region]["objects"][class_id]["count"] += 1

            # Store position for spatial relationship analysis
            if "normalized_center" in obj:
                distribution[region]["objects"][class_id]["positions"].append(obj["normalized_center"])

        # Calculate object density for each region
        for region, data in distribution.items():
            # Assuming all regions are equal size in the grid
            data["density"] = data["total"] / 1

        return distribution

    def _identify_asian_cultural_zones(self, category_regions: Dict, detected_objects: List[Dict], scene_type: str) -> Dict:
        """
        Identify functional zones for scenes with Asian cultural context.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects
            scene_type: Specific scene type

        Returns:
            Dict: Asian cultural functional zones
        """
        zones = {}

        # Identify storefront zone
        storefront_items = []
        storefront_regions = {}

        # Since storefronts aren't directly detectable, infer from context
        # For example, look for regions with signs, people, and smaller objects
        sign_regions = set()
        for obj in detected_objects:
            if obj["class_id"] == 0:  # Person
                region = obj["region"]
                if region not in storefront_regions:
                    storefront_regions[region] = []
                storefront_regions[region].append(obj)

                # Add regions with people as potential storefront areas
                sign_regions.add(region)

        # Use the areas with most people as storefront zones
        if storefront_regions:
            main_storefront_regions = sorted(storefront_regions.items(),
                                        key=lambda x: len(x[1]),
                                        reverse=True)[:2]  # Top 2 regions

            for idx, (region, objs) in enumerate(main_storefront_regions):
                zones[f"commercial_zone_{idx+1}"] = {
                    "region": region,
                    "objects": [obj["class_name"] for obj in objs],
                    "description": f"Asian commercial storefront with pedestrian activity"
                }

        # Identify pedestrian pathway - enhanced to better detect linear pathways
        pathway_items = []
        pathway_regions = {}

        # Extract people for pathway analysis
        people_objs = [obj for obj in detected_objects if obj["class_id"] == 0]

        # Analyze if people form a line (typical of shopping streets)
        people_positions = [obj["normalized_center"] for obj in people_objs]

        structured_path = False
        if len(people_positions) >= 3:
            # Check if people are arranged along a similar y-coordinate (horizontal path)
            y_coords = [pos[1] for pos in people_positions]
            y_mean = sum(y_coords) / len(y_coords)
            y_variance = sum((y - y_mean)**2 for y in y_coords) / len(y_coords)

            horizontal_path = y_variance < 0.05  # Low variance indicates horizontal alignment

            # Check if people are arranged along a similar x-coordinate (vertical path)
            x_coords = [pos[0] for pos in people_positions]
            x_mean = sum(x_coords) / len(x_coords)
            x_variance = sum((x - x_mean)**2 for x in x_coords) / len(x_coords)

            vertical_path = x_variance < 0.05  # Low variance indicates vertical alignment

            structured_path = horizontal_path or vertical_path
            path_direction = "horizontal" if horizontal_path else "vertical" if vertical_path else "meandering"

        # Collect pathway objects (people, bicycles, motorcycles in middle area)
        for obj in detected_objects:
            if obj["class_id"] in [0, 1, 3]:  # Person, bicycle, motorcycle
                y_pos = obj["normalized_center"][1]
                # Group by vertical position (middle of image likely pathway)
                if 0.25 <= y_pos <= 0.75:
                    region = obj["region"]
                    if region not in pathway_regions:
                        pathway_regions[region] = []
                    pathway_regions[region].append(obj)
                    pathway_items.append(obj["class_name"])

        if pathway_items:
            path_desc = "Pedestrian walkway with people moving through the commercial area"
            if structured_path:
                path_desc = f"{path_direction.capitalize()} pedestrian walkway with organized foot traffic"

            zones["pedestrian_pathway"] = {
                "region": "middle_center",  # Assumption: pathway often in middle
                "objects": list(set(pathway_items)),
                "description": path_desc
            }

        # Identify vendor zone (small stalls/shops - inferred from context)
        has_small_objects = any(obj["class_id"] in [24, 26, 39, 41] for obj in detected_objects)  # bags, bottles, cups
        has_people = any(obj["class_id"] == 0 for obj in detected_objects)

        if has_small_objects and has_people:
            # Likely vendor areas are where people and small objects cluster
            small_obj_regions = {}

            for obj in detected_objects:
                if obj["class_id"] in [24, 26, 39, 41, 67]:  # bags, bottles, cups, phones
                    region = obj["region"]
                    if region not in small_obj_regions:
                        small_obj_regions[region] = []
                    small_obj_regions[region].append(obj)

            if small_obj_regions:
                main_vendor_region = max(small_obj_regions.items(),
                                    key=lambda x: len(x[1]),
                                    default=(None, []))

                if main_vendor_region[0] is not None:
                    vendor_items = [obj["class_name"] for obj in main_vendor_region[1]]
                    zones["vendor_zone"] = {
                        "region": main_vendor_region[0],
                        "objects": list(set(vendor_items)),
                        "description": "Vendor or market stall area with small merchandise"
                    }

        # For night markets, identify illuminated zones
        if scene_type == "asian_night_market":
            # Night markets typically have bright spots for food stalls
            # This would be enhanced with lighting analysis integration
            zones["food_stall_zone"] = {
                "region": "middle_center",
                "objects": ["inferred food stalls"],
                "description": "Food stall area typical of Asian night markets"
            }

        return zones

    def _identify_upscale_dining_zones(self, category_regions: Dict, detected_objects: List[Dict]) -> Dict:
        """
        Identify functional zones for upscale dining settings.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects

        Returns:
            Dict: Upscale dining functional zones
        """
        zones = {}

        # Identify dining table zone
        dining_items = []
        dining_regions = {}

        for obj in detected_objects:
            if obj["class_id"] in [40, 41, 42, 43, 44, 45, 60]:  # Wine glass, cup, fork, knife, spoon, bowl, table
                region = obj["region"]
                if region not in dining_regions:
                    dining_regions[region] = []
                dining_regions[region].append(obj)
                dining_items.append(obj["class_name"])

        if dining_items:
            main_dining_region = max(dining_regions.items(),
                                key=lambda x: len(x[1]),
                                default=(None, []))

            if main_dining_region[0] is not None:
                zones["formal_dining_zone"] = {
                    "region": main_dining_region[0],
                    "objects": list(set(dining_items)),
                    "description": f"Formal dining area with {', '.join(list(set(dining_items))[:3])}"
                }

        # Identify decorative zone with enhanced detection
        decor_items = []
        decor_regions = {}

        # Look for decorative elements (vases, wine glasses, unused dishes)
        for obj in detected_objects:
            if obj["class_id"] in [75, 40]:  # Vase, wine glass
                region = obj["region"]
                if region not in decor_regions:
                    decor_regions[region] = []
                decor_regions[region].append(obj)
                decor_items.append(obj["class_name"])

        if decor_items:
            main_decor_region = max(decor_regions.items(),
                                key=lambda x: len(x[1]),
                                default=(None, []))

            if main_decor_region[0] is not None:
                zones["decorative_zone"] = {
                    "region": main_decor_region[0],
                    "objects": list(set(decor_items)),
                    "description": f"Decorative area with {', '.join(list(set(decor_items)))}"
                }

        # Identify seating arrangement zone
        chairs = [obj for obj in detected_objects if obj["class_id"] == 56]  # chairs
        if len(chairs) >= 2:
            chair_regions = {}
            for obj in chairs:
                region = obj["region"]
                if region not in chair_regions:
                    chair_regions[region] = []
                chair_regions[region].append(obj)

            if chair_regions:
                main_seating_region = max(chair_regions.items(),
                                    key=lambda x: len(x[1]),
                                    default=(None, []))

                if main_seating_region[0] is not None:
                    zones["dining_seating_zone"] = {
                        "region": main_seating_region[0],
                        "objects": ["chair"] * len(main_seating_region[1]),
                        "description": f"Formal dining seating arrangement with {len(main_seating_region[1])} chairs"
                    }

        # Identify serving area (if different from dining area)
        serving_items = []
        serving_regions = {}

        # Serving areas might have bottles, bowls, containers
        for obj in detected_objects:
            if obj["class_id"] in [39, 45]:  # Bottle, bowl
                # Check if it's in a different region from the main dining table
                if "formal_dining_zone" in zones and obj["region"] != zones["formal_dining_zone"]["region"]:
                    region = obj["region"]
                    if region not in serving_regions:
                        serving_regions[region] = []
                    serving_regions[region].append(obj)
                    serving_items.append(obj["class_name"])

        if serving_items:
            main_serving_region = max(serving_regions.items(),
                                key=lambda x: len(x[1]),
                                default=(None, []))

            if main_serving_region[0] is not None:
                zones["serving_zone"] = {
                    "region": main_serving_region[0],
                    "objects": list(set(serving_items)),
                    "description": f"Serving or sideboard area with {', '.join(list(set(serving_items)))}"
                }

        return zones

    def _identify_financial_district_zones(self, category_regions: Dict, detected_objects: List[Dict]) -> Dict:
        """
        Identify functional zones for financial district scenes.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects

        Returns:
            Dict: Financial district functional zones
        """
        zones = {}

        # Identify traffic zone
        traffic_items = []
        traffic_regions = {}

        for obj in detected_objects:
            if obj["class_id"] in [1, 2, 3, 5, 6, 7, 9]:  # Various vehicles and traffic lights
                region = obj["region"]
                if region not in traffic_regions:
                    traffic_regions[region] = []
                traffic_regions[region].append(obj)
                traffic_items.append(obj["class_name"])

        if traffic_items:
            main_traffic_region = max(traffic_regions.items(),
                                key=lambda x: len(x[1]),
                                default=(None, []))

            if main_traffic_region[0] is not None:
                zones["traffic_zone"] = {
                    "region": main_traffic_region[0],
                    "objects": list(set(traffic_items)),
                    "description": f"Urban traffic area with {', '.join(list(set(traffic_items))[:3])}"
                }

        # Building zones on the sides (inferred from scene context)
        # Enhanced to check if there are actual regions that might contain buildings
        # Check for regions without vehicles or pedestrians - likely building areas
        left_side_regions = ["top_left", "middle_left", "bottom_left"]
        right_side_regions = ["top_right", "middle_right", "bottom_right"]

        # Check left side
        left_building_evidence = True
        for region in left_side_regions:
            # If many vehicles or people in this region, less likely to be buildings
            vehicle_in_region = any(obj["region"] == region and obj["class_id"] in [1, 2, 3, 5, 7]
                                for obj in detected_objects)
            people_in_region = any(obj["region"] == region and obj["class_id"] == 0
                                for obj in detected_objects)

            if vehicle_in_region or people_in_region:
                left_building_evidence = False
                break

        # Check right side
        right_building_evidence = True
        for region in right_side_regions:
            # If many vehicles or people in this region, less likely to be buildings
            vehicle_in_region = any(obj["region"] == region and obj["class_id"] in [1, 2, 3, 5, 7]
                                for obj in detected_objects)
            people_in_region = any(obj["region"] == region and obj["class_id"] == 0
                                for obj in detected_objects)

            if vehicle_in_region or people_in_region:
                right_building_evidence = False
                break

        # Add building zones if evidence supports them
        if left_building_evidence:
            zones["building_zone_left"] = {
                "region": "middle_left",
                "objects": ["building"],  # Inferred
                "description": "Tall buildings line the left side of the street"
            }

        if right_building_evidence:
            zones["building_zone_right"] = {
                "region": "middle_right",
                "objects": ["building"],  # Inferred
                "description": "Tall buildings line the right side of the street"
            }

        # Identify pedestrian zone if people are present
        people_objs = [obj for obj in detected_objects if obj["class_id"] == 0]
        if people_objs:
            people_regions = {}
            for obj in people_objs:
                region = obj["region"]
                if region not in people_regions:
                    people_regions[region] = []
                people_regions[region].append(obj)

            if people_regions:
                main_pedestrian_region = max(people_regions.items(),
                                        key=lambda x: len(x[1]),
                                        default=(None, []))

                if main_pedestrian_region[0] is not None:
                    zones["pedestrian_zone"] = {
                        "region": main_pedestrian_region[0],
                        "objects": ["person"] * len(main_pedestrian_region[1]),
                        "description": f"Pedestrian area with {len(main_pedestrian_region[1])} people navigating the financial district"
                    }

        return zones

    def _identify_aerial_view_zones(self, category_regions: Dict, detected_objects: List[Dict], scene_type: str) -> Dict:
        """
        Identify functional zones for scenes viewed from an aerial perspective.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects
            scene_type: Specific scene type

        Returns:
            Dict: Aerial view functional zones
        """
        zones = {}

        # For aerial views, we focus on patterns and flows rather than specific zones

        # Identify pedestrian patterns
        people_objs = [obj for obj in detected_objects if obj["class_id"] == 0]
        if people_objs:
            # Convert positions to arrays for pattern analysis
            positions = np.array([obj["normalized_center"] for obj in people_objs])

            if len(positions) >= 3:
                # Calculate distribution metrics
                x_coords = positions[:, 0]
                y_coords = positions[:, 1]

                x_mean = np.mean(x_coords)
                y_mean = np.mean(y_coords)
                x_std = np.std(x_coords)
                y_std = np.std(y_coords)

                # Determine if people are organized in a linear pattern
                if x_std < 0.1 or y_std < 0.1:
                    # Linear distribution along one axis
                    pattern_direction = "vertical" if x_std < y_std else "horizontal"

                    zones["pedestrian_pattern"] = {
                        "region": "central",
                        "objects": ["person"] * len(people_objs),
                        "description": f"Aerial view shows a {pattern_direction} pedestrian movement pattern"
                    }
                else:
                    # More dispersed pattern
                    zones["pedestrian_distribution"] = {
                        "region": "wide",
                        "objects": ["person"] * len(people_objs),
                        "description": f"Aerial view shows pedestrians distributed across the area"
                    }

        # Identify vehicle patterns for traffic analysis
        vehicle_objs = [obj for obj in detected_objects if obj["class_id"] in [1, 2, 3, 5, 6, 7]]
        if vehicle_objs:
            # Convert positions to arrays for pattern analysis
            positions = np.array([obj["normalized_center"] for obj in vehicle_objs])

            if len(positions) >= 2:
                # Calculate distribution metrics
                x_coords = positions[:, 0]
                y_coords = positions[:, 1]

                x_mean = np.mean(x_coords)
                y_mean = np.mean(y_coords)
                x_std = np.std(x_coords)
                y_std = np.std(y_coords)

                # Determine if vehicles are organized in lanes
                if x_std < y_std * 0.5:
                    # Vehicles aligned vertically - indicates north-south traffic
                    zones["vertical_traffic_flow"] = {
                        "region": "central_vertical",
                        "objects": [obj["class_name"] for obj in vehicle_objs[:5]],
                        "description": "North-south traffic flow visible from aerial view"
                    }
                elif y_std < x_std * 0.5:
                    # Vehicles aligned horizontally - indicates east-west traffic
                    zones["horizontal_traffic_flow"] = {
                        "region": "central_horizontal",
                        "objects": [obj["class_name"] for obj in vehicle_objs[:5]],
                        "description": "East-west traffic flow visible from aerial view"
                    }
                else:
                    # Vehicles in multiple directions - indicates intersection
                    zones["intersection_traffic"] = {
                        "region": "central",
                        "objects": [obj["class_name"] for obj in vehicle_objs[:5]],
                        "description": "Multi-directional traffic at intersection visible from aerial view"
                    }

        # For intersection specific aerial views, identify crossing patterns
        if "intersection" in scene_type:
            # Check for traffic signals
            traffic_light_objs = [obj for obj in detected_objects if obj["class_id"] == 9]
            if traffic_light_objs:
                zones["traffic_control_pattern"] = {
                    "region": "intersection",
                    "objects": ["traffic light"] * len(traffic_light_objs),
                    "description": f"Intersection traffic control with {len(traffic_light_objs)} signals visible from above"
                }

            # Crosswalks are inferred from context in aerial views
            zones["crossing_pattern"] = {
                "region": "central",
                "objects": ["inferred crosswalk"],
                "description": "Crossing pattern visible from aerial perspective"
            }

        # For plaza aerial views, identify gathering patterns
        if "plaza" in scene_type:
            # Plazas typically have central open area with people
            if people_objs:
                # Check if people are clustered in central region
                central_people = [obj for obj in people_objs
                                if "middle" in obj["region"]]

                if central_people:
                    zones["central_gathering"] = {
                        "region": "middle_center",
                        "objects": ["person"] * len(central_people),
                        "description": f"Central plaza gathering area with {len(central_people)} people viewed from above"
                    }

        return zones

    def _identify_outdoor_general_zones(self, category_regions: Dict, detected_objects: List[Dict], scene_type: str) -> Dict:
        """
        Identify functional zones for general outdoor scenes.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects
            scene_type: Specific outdoor scene type

        Returns:
            Dict: Outdoor functional zones
        """
        zones = {}

        # Identify pedestrian zones
        people_objs = [obj for obj in detected_objects if obj["class_id"] == 0]
        if people_objs:
            people_regions = {}
            for obj in people_objs:
                region = obj["region"]
                if region not in people_regions:
                    people_regions[region] = []
                people_regions[region].append(obj)

            if people_regions:
                # Find main pedestrian areas
                main_people_regions = sorted(people_regions.items(),
                                        key=lambda x: len(x[1]),
                                        reverse=True)[:2]  # Top 2 regions

                for idx, (region, objs) in enumerate(main_people_regions):
                    if len(objs) > 0:
                        zones[f"pedestrian_zone_{idx+1}"] = {
                            "region": region,
                            "objects": ["person"] * len(objs),
                            "description": f"Pedestrian area with {len(objs)} {'people' if len(objs) > 1 else 'person'}"
                        }

        # Identify vehicle zones for streets and parking lots
        vehicle_objs = [obj for obj in detected_objects if obj["class_id"] in [1, 2, 3, 5, 6, 7]]
        if vehicle_objs:
            vehicle_regions = {}
            for obj in vehicle_objs:
                region = obj["region"]
                if region not in vehicle_regions:
                    vehicle_regions[region] = []
                vehicle_regions[region].append(obj)

            if vehicle_regions:
                main_vehicle_region = max(vehicle_regions.items(),
                                    key=lambda x: len(x[1]),
                                    default=(None, []))

                if main_vehicle_region[0] is not None:
                    vehicle_types = [obj["class_name"] for obj in main_vehicle_region[1]]
                    zones["vehicle_zone"] = {
                        "region": main_vehicle_region[0],
                        "objects": vehicle_types,
                        "description": f"Traffic area with {', '.join(list(set(vehicle_types))[:3])}"
                    }

        # For park areas, identify recreational zones
        if scene_type == "park_area":
            # Look for recreational objects (sports balls, kites, etc.)
            rec_items = []
            rec_regions = {}

            for obj in detected_objects:
                if obj["class_id"] in [32, 33, 34, 35, 38]:  # sports ball, kite, baseball bat, glove, tennis racket
                    region = obj["region"]
                    if region not in rec_regions:
                        rec_regions[region] = []
                    rec_regions[region].append(obj)
                    rec_items.append(obj["class_name"])

            if rec_items:
                main_rec_region = max(rec_regions.items(),
                                key=lambda x: len(x[1]),
                                default=(None, []))

                if main_rec_region[0] is not None:
                    zones["recreational_zone"] = {
                        "region": main_rec_region[0],
                        "objects": list(set(rec_items)),
                        "description": f"Recreational area with {', '.join(list(set(rec_items)))}"
                    }

        # For parking lots, identify parking zones
        if scene_type == "parking_lot":
            # Look for parked cars with consistent spacing
            car_objs = [obj for obj in detected_objects if obj["class_id"] == 2]  # cars

            if len(car_objs) >= 3:
                # Check if cars are arranged in patterns (simplified)
                car_positions = [obj["normalized_center"] for obj in car_objs]

                # Check for row patterns by analyzing vertical positions
                y_coords = [pos[1] for pos in car_positions]
                y_clusters = {}

                # Simplified clustering - group cars by similar y-coordinates
                for i, y in enumerate(y_coords):
                    assigned = False
                    for cluster_y in y_clusters.keys():
                        if abs(y - cluster_y) < 0.1:  # Within 10% of image height
                            y_clusters[cluster_y].append(i)
                            assigned = True
                            break

                    if not assigned:
                        y_clusters[y] = [i]

                # If we have row patterns
                if max(len(indices) for indices in y_clusters.values()) >= 2:
                    zones["parking_row"] = {
                        "region": "central",
                        "objects": ["car"] * len(car_objs),
                        "description": f"Organized parking area with vehicles arranged in rows"
                    }
                else:
                    zones["parking_area"] = {
                        "region": "wide",
                        "objects": ["car"] * len(car_objs),
                        "description": f"Parking area with {len(car_objs)} vehicles"
                    }

        return zones

    def _identify_default_zones(self, category_regions: Dict, detected_objects: List[Dict]) -> Dict:
        """
        Identify general functional zones when no specific scene type is matched.

        Args:
            category_regions: Objects grouped by category and region
            detected_objects: List of detected objects

        Returns:
            Dict: Default functional zones
        """
        zones = {}

        # Group objects by category and find main concentrations
        for category, regions in category_regions.items():
            if not regions:
                continue

            # Find region with most objects in this category
            main_region = max(regions.items(),
                        key=lambda x: len(x[1]),
                        default=(None, []))

            if main_region[0] is None or len(main_region[1]) < 2:
                continue

            # Create zone based on object category
            zone_objects = [obj["class_name"] for obj in main_region[1]]

            # Skip if too few objects
            if len(zone_objects) < 2:
                continue

            # Create appropriate zone name and description based on category
            if category == "furniture":
                zones["furniture_zone"] = {
                    "region": main_region[0],
                    "objects": zone_objects,
                    "description": f"Area with furniture including {', '.join(zone_objects[:3])}"
                }
            elif category == "electronics":
                zones["electronics_zone"] = {
                    "region": main_region[0],
                    "objects": zone_objects,
                    "description": f"Area with electronic devices including {', '.join(zone_objects[:3])}"
                }
            elif category == "kitchen_items":
                zones["dining_zone"] = {
                    "region": main_region[0],
                    "objects": zone_objects,
                    "description": f"Dining or food area with {', '.join(zone_objects[:3])}"
                }
            elif category == "vehicles":
                zones["vehicle_zone"] = {
                    "region": main_region[0],
                    "objects": zone_objects,
                    "description": f"Area with vehicles including {', '.join(zone_objects[:3])}"
                }
            elif category == "personal_items":
                zones["personal_items_zone"] = {
                    "region": main_region[0],
                    "objects": zone_objects,
                    "description": f"Area with personal items including {', '.join(zone_objects[:3])}"
                }

        # Check for people groups
        people_objs = [obj for obj in detected_objects if obj["class_id"] == 0]
        if len(people_objs) >= 2:
            people_regions = {}
            for obj in people_objs:
                region = obj["region"]
                if region not in people_regions:
                    people_regions[region] = []
                people_regions[region].append(obj)

            if people_regions:
                main_people_region = max(people_regions.items(),
                                    key=lambda x: len(x[1]),
                                    default=(None, []))

                if main_people_region[0] is not None:
                    zones["people_zone"] = {
                        "region": main_people_region[0],
                        "objects": ["person"] * len(main_people_region[1]),
                        "description": f"Area with {len(main_people_region[1])} people"
                    }

        return zones

    def _find_main_region(self, region_objects_dict: Dict) -> str:
        """Find the main region with the most objects"""
        if not region_objects_dict:
            return "unknown"

        return max(region_objects_dict.items(),
                key=lambda x: len(x[1]),
                default=("unknown", []))[0]