import logging import traceback from typing import Dict, List, Any, Optional logger = logging.getLogger(__name__) class FunctionalZoneIdentifier: """ 作為功能區域辨識的主要窗口 整合區域評估和場景特定的區域辨識邏輯，提供統一的功能區域辨識接口 """ def __init__(self, zone_evaluator=None, scene_zone_identifier=None, scene_viewpoint_analyzer=None, object_categories=None): """ 初始化功能區域識別器 Args: zone_evaluator: 區域評估器實例 scene_zone_identifier: 場景區域辨識器實例 scene_viewpoint_analyzer: 場景視角分析器 """ try: self.zone_evaluator = zone_evaluator self.scene_zone_identifier = scene_zone_identifier self.scene_viewpoint_analyzer = scene_viewpoint_analyzer self.viewpoint_detector = scene_viewpoint_analyzer self.OBJECT_CATEGORIES = object_categories or {} logger.info("FunctionalZoneIdentifier initialized successfully with SceneViewpointAnalyzer") except Exception as e: logger.error(f"Failed to initialize FunctionalZoneIdentifier: {str(e)}") logger.error(traceback.format_exc()) raise def identify_functional_zones(self, detected_objects: List[Dict], scene_type: str) -> Dict: """ 識別場景內的功能區域，具有針對不同視角和文化背景的改進檢測能力。 如果偵測到 is_landmark=True 的物件，則優先直接呼叫 identify_landmark_zones 並回傳結果。 """ try: # 1. 如果沒有啟用地標功能，就先把所有有 is_landmark=True 的物件過濾掉 if not getattr(self, 'enable_landmark', True): detected_objects = [obj for obj in detected_objects if not obj.get("is_landmark", False)] # 2. 只要檢測到任何 is_landmark=True 的物件，立即優先使用 identify_landmark_zones landmark_objects = [obj for obj in detected_objects if obj.get("is_landmark", False)] if landmark_objects and self.scene_zone_identifier: lm_zones = self.scene_zone_identifier.identify_landmark_zones(landmark_objects) return self._standardize_zone_keys_and_descriptions(lm_zones) # 3. city_street if scene_type in ["tourist_landmark", "natural_landmark", "historical_monument"]: scene_type = "city_street" # 4. 判斷與物件數量檢查 if self.zone_evaluator: should_identify = self.zone_evaluator.evaluate_zone_identification_feasibility( detected_objects, scene_type ) if not should_identify: logger.info(f"Zone identification not feasible for scene type '{scene_type}'") return {} else: if len(detected_objects) < 2: logger.info("Insufficient objects for zone identification") return {} # 5. 建立 category_regions category_regions = self._build_category_regions_mapping(detected_objects) zones = {} # 6. 檢測場景視角 viewpoint_info = {"viewpoint": "eye_level"} if self.scene_viewpoint_analyzer: viewpoint_info = self.scene_viewpoint_analyzer.detect_scene_viewpoint(detected_objects) # 7. 根據不同 scene_type 使用各種自己的區域辨識 if scene_type in ["living_room", "bedroom", "dining_area", "kitchen", "office_workspace", "meeting_room"]: if self.scene_zone_identifier: raw_zones = self.scene_zone_identifier.identify_indoor_zones( category_regions, detected_objects, scene_type ) zones.update(self._standardize_zone_keys_and_descriptions(raw_zones)) elif scene_type in ["city_street", "parking_lot", "park_area"]: if self.scene_zone_identifier: raw_zones = self.scene_zone_identifier.identify_outdoor_general_zones( category_regions, detected_objects, scene_type ) zones.update(self._standardize_zone_keys_and_descriptions(raw_zones)) elif "aerial" in scene_type or viewpoint_info.get("viewpoint") == "aerial": if self.scene_zone_identifier: raw_zones = self.scene_zone_identifier.identify_aerial_view_zones( category_regions, detected_objects, scene_type ) zones.update(self._standardize_zone_keys_and_descriptions(raw_zones)) elif "asian" in scene_type: if self.scene_zone_identifier: asian_zones = self.scene_zone_identifier.identify_asian_cultural_zones( category_regions, detected_objects, scene_type ) zones.update(self._standardize_zone_keys_and_descriptions(asian_zones)) elif scene_type == "urban_intersection": if self.scene_zone_identifier: raw_zones = self.scene_zone_identifier.identify_intersection_zones( category_regions, detected_objects, viewpoint_info.get("viewpoint") ) zones.update(self._standardize_zone_keys_and_descriptions(raw_zones)) used_tl_count_per_region = {} for zone_info in raw_zones.values(): obj_list = zone_info.get("objects", []) if "traffic light" in obj_list: rg = zone_info.get("region", "") count_in_zone = obj_list.count("traffic light") used_tl_count_per_region[rg] = used_tl_count_per_region.get(rg, 0) + count_in_zone signal_regions = {} for t in [obj for obj in detected_objects if obj.get("class_id") == 9]: region = t.get("region", "") signal_regions.setdefault(region, []).append(t) for idx, (region, signals) in enumerate(signal_regions.items()): total_in_region = len(signals) used_in_region = used_tl_count_per_region.get(region, 0) remaining_in_region = total_in_region - used_in_region if remaining_in_region > 0: direction = self._get_directional_description(region) if direction and direction != "central": zone_key = f"{direction} traffic control area" else: zone_key = "primary traffic control area" if idx == 0 else "auxiliary traffic control area" if zone_key in zones: suffix = 1 new_key = f"{zone_key} ({suffix})" while new_key in zones: suffix += 1 new_key = f"{zone_key} ({suffix})" zone_key = new_key zones[zone_key] = { "region": region, "objects": ["traffic light"] * remaining_in_region, "description": f"Traffic control area with {remaining_in_region} traffic lights in {region}" } for region, signals in signal_regions.items(): used = used_tl_count_per_region.get(region, 0) total = len(signals) remaining = total - used # print(f"[DEBUG] Region '{region}': Total TL = {total}, Used in crossing = {used}, Remaining = {remaining}") elif scene_type == "financial_district": if self.scene_zone_identifier: fd_zones = self.scene_zone_identifier.identify_financial_district_zones( category_regions, detected_objects ) zones.update(self._standardize_zone_keys_and_descriptions(fd_zones)) elif scene_type == "upscale_dining": if self.scene_zone_identifier: ud_zones = self.scene_zone_identifier.identify_upscale_dining_zones( category_regions, detected_objects ) zones.update(self._standardize_zone_keys_and_descriptions(ud_zones)) else: # 如果不是上述任何一種場景，就用「預設功能區」 default_zones = self._identify_default_zones(category_regions, detected_objects) zones.update(self._standardize_zone_keys_and_descriptions(default_zones)) # 8. 如果此時 zones 仍為空，就會變成 default → basic → fallback if not zones: default_zones = self._identify_default_zones(category_regions, detected_objects) if default_zones: zones.update(self._standardize_zone_keys_and_descriptions(default_zones)) else: basic_zones = self._create_basic_zones_from_objects(detected_objects, scene_type) zones.update(self._standardize_zone_keys_and_descriptions(basic_zones)) # 通用 fallback：把所有還沒被列出的 (class_name, region) 通通補進去 fallback_zones = self._generate_category_fallback_zones(detected_objects, zones) zones.update(fallback_zones) # Debug: 列印出各功能區的 traffic light 統計 total_tl_in_zones = 0 for zone_key, zone_info in zones.items(): if isinstance(zone_info, dict): sub_objs = zone_info.get("objects", []) else: sub_objs = [] t_in_zone = [obj for obj in sub_objs if obj == "traffic light"] # print(f"[DEBUG] identify_functional_zones - Zone '{zone_key}' has {len(t_in_zone)} traffic light(s).") total_tl_in_zones += len(t_in_zone) # print(f"[DEBUG] identify_functional_zones - Total traffic lights in zones: {total_tl_in_zones}") logger.info(f"Identified {len(zones)} functional zones for scene type '{scene_type}'") return zones except Exception as e: logger.error(f"Error identifying functional zones: {str(e)}") logger.error(traceback.format_exc()) return {} def _standardize_zone_keys_and_descriptions(self, raw_zones: Dict) -> Dict: """ 標準化區域鍵名和描述，將內部標識符轉換為描述性名稱 Args: raw_zones: 原始區域識別結果 Returns: Dict: 標準化後的區域字典 """ try: standardized_zones = {} for zone_key, zone_data in raw_zones.items(): # 生成描述性的區域鍵名 descriptive_key = self._generate_descriptive_zone_key(zone_key, zone_data) # 確保區域描述也經過標準化 if isinstance(zone_data, dict) and "description" in zone_data: zone_data["description"] = self._enhance_zone_description(zone_data["description"], zone_data) standardized_zones[descriptive_key] = zone_data return standardized_zones except Exception as e: logger.error(f"Error standardizing zone keys and descriptions: {str(e)}") return raw_zones def _generate_descriptive_zone_key(self, original_key: str, zone_data: Dict) -> str: """ 基於區域內容生成描述性的鍵名 核心修改：只要該區域內有任一個 'traffic light'，就優先回傳 'traffic control zone'， """ try: objects = zone_data.get("objects", []) region = zone_data.get("region", "") # 優先檢查是否含有 traffic light if any(obj == "traffic light" or "traffic light" in obj for obj in objects): return "traffic control zone" # 如果沒有 traffic light，才繼續分析「主要物件」順序 primary_objects = self._analyze_primary_objects(objects) # 依序檢查人、車、家具、紅綠燈等 if "person" in primary_objects: if len([o for o in objects if o == "person"]) > 1: return "pedestrian activity area" else: return "individual activity zone" elif any(vehicle in primary_objects for vehicle in ["car", "truck", "bus", "motorcycle"]): return "vehicle movement area" elif any(furniture in primary_objects for furniture in ["chair", "table", "sofa", "bed"]): return "furniture arrangement area" # 若上述都不符合，改用「基於位置」做 fallback position_descriptions = { "top_left": "upper left area", "top_center": "upper central area", "top_right": "upper right area", "middle_left": "left side area", "middle_center": "main crossing area", "middle_right": "right side area", "bottom_left": "lower left area", "bottom_center": "lower central area", "bottom_right": "lower right area" } if region in position_descriptions: return position_descriptions[region] # 再次檢查主要物件，給出另一種 fallback 命名 if primary_objects: if "traffic light" in primary_objects: return "traffic control zone" elif any(vehicle in primary_objects for vehicle in ["car", "truck", "bus"]): return "vehicle movement area" elif "person" in primary_objects: return "pedestrian activity area" # 最後最後的備用名稱 return "activity area" except Exception as e: logger.warning(f"Error generating descriptive key for '{original_key}': {str(e)}") return "activity area" def _analyze_primary_objects(self, objects: List[str]) -> List[str]: """ 分析區域中的主要物件類型 Args: objects: 物件名稱列表 Returns: List[str]: 主要物件類型列表 """ try: # 計算物件出現頻率 object_counts = {} for obj in objects: normalized_obj = obj.replace('_', ' ').lower().strip() object_counts[normalized_obj] = object_counts.get(normalized_obj, 0) + 1 # 按出現頻率排序，返回前三個主要物件 sorted_objects = sorted(object_counts.items(), key=lambda x: x[1], reverse=True) return [obj[0] for obj in sorted_objects[:3]] except Exception as e: logger.warning(f"Error analyzing primary objects: {str(e)}") return [] def _enhance_zone_description(self, original_description: str, zone_data: Dict) -> str: """ 增強區域描述的自然性和完整性 """ try: if not original_description or not original_description.strip(): return self._generate_fallback_description(zone_data) import re enhanced = original_description.strip() # 改善技術性表達為自然語言 enhanced = re.sub(r'\bin central direction\b', 'in the center', enhanced) enhanced = re.sub(r'\bin west area\b', 'on the left side', enhanced) enhanced = re.sub(r'\bin east direction\b', 'on the right side', enhanced) enhanced = re.sub(r'\bnear traffic signals\b', 'near the traffic lights', enhanced) enhanced = re.sub(r'\bwith (\d+) (\w+)\b', r'where \1 \2 can be seen', enhanced) # 移除重複和冗餘表達 enhanced = re.sub(r'\barea with.*?in.*?area\b', lambda m: m.group(0).split(' in ')[0], enhanced) enhanced = enhanced.replace('traffic area', 'area').replace('crossing area', 'crossing') # 標準化描述結構 if enhanced.startswith('Pedestrian'): enhanced = re.sub(r'^Pedestrian crossing area', 'The main pedestrian crossing', enhanced) elif enhanced.startswith('Vehicle'): enhanced = re.sub(r'^Vehicle traffic area', 'The vehicle movement area', enhanced) elif enhanced.startswith('Traffic control'): enhanced = re.sub(r'^Traffic control area', 'Traffic management elements', enhanced) # 移除內部標識符格式 enhanced = re.sub(r'\b\w+_\w+(?:_\w+)*\b', lambda m: m.group(0).replace('_', ' '), enhanced) # 確保描述的完整性 if not enhanced.endswith('.'): enhanced += '.' # 改善描述的自然性 enhanced = enhanced.replace('with with', 'with') enhanced = re.sub(r'\s{2,}', ' ', enhanced) return enhanced except Exception as e: logger.warning(f"Error enhancing zone description: {str(e)}") return original_description if original_description else "A functional area within the scene." def _generate_fallback_description(self, zone_data: Dict) -> str: """ 為缺少描述的區域生成備用描述 Args: zone_data: 區域數據 Returns: str: 備用描述 """ try: objects = zone_data.get("objects", []) region = zone_data.get("region", "") if objects: object_count = len(objects) unique_objects = list(set(objects)) if object_count == 1: return f"Area containing {unique_objects[0].replace('_', ' ')}." elif len(unique_objects) <= 3: obj_list = ", ".join([obj.replace('_', ' ') for obj in unique_objects]) return f"Area featuring {obj_list}." else: return f"Multi-functional area with {object_count} elements including various objects." return "Functional area within the scene." except Exception as e: logger.warning(f"Error generating fallback description: {str(e)}") return "Activity area." def _build_category_regions_mapping(self, detected_objects: List[Dict]) -> Dict: """ 建立物件按類別和區域的分組映射 Args: detected_objects: 檢測到的物件列表 Returns: 按類別和區域分組的物件字典 """ try: category_regions = {} 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) logger.debug(f"Built category regions mapping with {len(category_regions)} categories") return category_regions except Exception as e: logger.error(f"Error building category regions mapping: {str(e)}") logger.error(traceback.format_exc()) return {} def _categorize_object(self, obj: Dict) -> str: """ 將檢測到的物件分類到功能類別中，用於區域識別 確保所有返回值都使用自然語言格式，避免底線或技術性標識符 """ try: class_id = obj.get("class_id", -1) class_name = obj.get("class_name", "").lower().strip() # 優先處理 traffic light # 只要 class_id == 9 或 class_name 包含 "traffic light"，就分類為 "traffic light" if class_id == 9 or "traffic light" in class_name: return "traffic light" # 如果有自訂的 OBJECT_CATEGORIES 映射，優先使用它 if hasattr(self, 'OBJECT_CATEGORIES') and self.OBJECT_CATEGORIES: for category, ids in self.OBJECT_CATEGORIES.items(): if class_id in ids: # 確保返回的類別名稱使用自然語言格式 return self._clean_category_name(category) # COCO class default name 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"] # fallback natural language 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" except Exception as e: logger.error(f"Error categorizing object: {str(e)}") logger.error(traceback.format_exc()) return "misc" def _clean_category_name(self, category: str) -> str: """ 清理類別名稱，移除底線並轉換為較自然的格式 Args: category: 原始類別名稱 Returns: str: 清理後的類別名稱 """ try: if not category: return "misc" # 將底線替換為空格 cleaned = category.replace('_', ' ') # 處理常見的技術性命名模式 replacements = { 'kitchen items': 'kitchen items', 'personal items': 'personal items', 'traffic light': 'traffic light', 'misc items': 'misc' } # 應用特定的替換規則 for old_term, new_term in replacements.items(): if cleaned == old_term: return new_term return cleaned.strip() except Exception as e: logger.warning(f"Error cleaning category name '{category}': {str(e)}") return "misc" def _identify_default_zones(self, category_regions: Dict, detected_objects: List[Dict]) -> Dict: """ 當沒有匹配到特定場景類型時的一般功能區域識別 Args: category_regions: 按類別和區域分組的物件字典 detected_objects: 檢測到的物件列表 Returns: 預設功能區域字典 """ try: zones = {} # 按類別分組物件並找到主要集中區域 for category, regions in category_regions.items(): if not regions: continue # 找到此類別中物件最多的區域 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 # 創建基於物件類別的區域 zone_objects = [obj["class_name"] for obj in main_region[1]] # 如果物件太少，跳過 if len(zone_objects) < 2: continue # 根據類別創建區域名稱和描述 if category == "furniture": zones["furniture arrangement area"] = { "region": main_region[0], "objects": zone_objects, "description": f"Furniture arrangement area featuring {self._format_object_list_naturally(zone_objects[:3])}" } elif category == "electronics": zones["electronics area"] = { "region": main_region[0], "objects": zone_objects, "description": f"Electronics area containing {self._format_object_list_naturally(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 == "vehicle": 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])}" } # 檢查人群聚集 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" } logger.debug(f"Identified {len(zones)} default zones") return zones except Exception as e: logger.error(f"Error identifying default zones: {str(e)}") logger.error(traceback.format_exc()) return {} def _format_object_list_naturally(self, object_list: List[str]) -> str: """ 將物件列表格式化為自然語言表達 Args: object_list: 物件名稱列表 Returns: str: 自然語言格式的物件列表 """ try: if not object_list: return "various items" # 標準化物件名稱 normalized_objects = [] for obj in object_list: normalized = obj.replace('_', ' ').strip() if normalized: normalized_objects.append(normalized) if not normalized_objects: return "various items" # 格式化列表 if len(normalized_objects) == 1: return normalized_objects[0] elif len(normalized_objects) == 2: return f"{normalized_objects[0]} and {normalized_objects[1]}" else: return ", ".join(normalized_objects[:-1]) + f", and {normalized_objects[-1]}" except Exception as e: logger.warning(f"Error formatting object list naturally: {str(e)}") return "various items" def _create_basic_zones_from_objects(self, detected_objects: List[Dict], scene_type: str) -> Dict: """ 從個別高置信度物件創建基本功能區域 這是標準區域識別失敗時的後備方案 Args: detected_objects: 檢測到的物件列表 scene_type: 場景類型 Returns: 基本區域字典 """ try: zones = {} # 專注於高置信度物件 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 # 後備到所有物件 # 基於個別重要物件創建區域 processed_objects = set() # 避免重複處理相同類型的物件 for obj in high_conf_objects[:3]: # 限制為前3個物件 class_name = obj["class_name"] region = obj.get("region", "center") # 避免為同一類型物件創建多個區域 if class_name in processed_objects: continue processed_objects.add(class_name) # 基於物件類型創建描述性區域 zone_description = self._get_basic_zone_description(class_name, scene_type) descriptive_key = self._generate_object_based_zone_key(class_name, region) if zone_description and descriptive_key: zones[descriptive_key] = { "region": region, "objects": [class_name], "description": zone_description } logger.debug(f"Created {len(zones)} basic zones from high confidence objects") return zones except Exception as e: logger.error(f"Error creating basic zones from objects: {str(e)}") logger.error(traceback.format_exc()) return {} def _generate_object_based_zone_key(self, class_name: str, region: str) -> str: """ 基於物件類型和位置生成描述性的區域鍵名 Args: class_name: 物件類別名稱 region: 區域位置 Returns: str: 描述性區域鍵名 """ try: # 標準化物件名稱 normalized_class = class_name.replace('_', ' ').lower().strip() # 物件類型對應的區域描述 object_zone_mapping = { 'person': 'activity area', 'car': 'vehicle area', 'truck': 'vehicle area', 'bus': 'vehicle area', 'motorcycle': 'vehicle area', 'bicycle': 'cycling area', 'traffic light': 'traffic control area', 'chair': 'seating area', 'sofa': 'seating area', 'bed': 'rest area', 'dining table': 'dining area', 'tv': 'entertainment area', 'laptop': 'workspace area', 'potted plant': 'decorative area' } base_description = object_zone_mapping.get(normalized_class, f"{normalized_class} area") # 添加位置信息以提供更具體的描述 position_modifiers = { 'top_left': 'upper left', 'top_center': 'upper central', 'top_right': 'upper right', 'middle_left': 'left side', 'middle_center': 'central', 'middle_right': 'right side', 'bottom_left': 'lower left', 'bottom_center': 'lower central', 'bottom_right': 'lower right' } if region in position_modifiers: return f"{position_modifiers[region]} {base_description}" return base_description except Exception as e: logger.warning(f"Error generating object-based zone key for '{class_name}': {str(e)}") return "activity area" def _get_basic_zone_description(self, class_name: str, scene_type: str) -> str: """ 基於物件和場景類型生成基本區域描述 Args: class_name: 物件類別名稱 scene_type: 場景類型 Returns: 區域描述字串 """ try: # 物件特定描述 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}") except Exception as e: logger.error(f"Error getting basic zone description for '{class_name}': {str(e)}") return f"Functional area with {class_name}" def _generate_category_fallback_zones(self, all_detected_objects: List[Dict], current_zones: Dict) -> Dict: """ 通用 fallback：針對 all_detected_objects 裡，每一個 (class_name, region) 組合是否已經 在 current_zones 裡出現過。如果還沒，就為它們產生一個 fallback zone。 """ general_fallback = { 0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 4: 'airplane', 5: 'bus', 6: 'train', 7: 'truck', 8: 'boat', 9: 'traffic light', 10: 'fire hydrant', 11: 'stop sign', 12: 'parking meter', 13: 'bench', 14: 'bird', 15: 'cat', 16: 'dog', 17: 'horse', 18: 'sheep', 19: 'cow', 20: 'elephant', 21: 'bear', 22: 'zebra', 23: 'giraffe', 24: 'backpack', 25: 'umbrella', 26: 'handbag', 27: 'tie', 28: 'suitcase', 29: 'frisbee', 30: 'skis', 31: 'snowboard', 32: 'sports ball', 33: 'kite', 34: 'baseball bat', 35: 'baseball glove', 36: 'skateboard', 37: 'surfboard', 38: 'tennis racket', 39: 'bottle', 40: 'wine glass', 41: 'cup', 42: 'fork', 43: 'knife', 44: 'spoon', 45: 'bowl', 46: 'banana', 47: 'apple', 48: 'sandwich', 49: 'orange', 50: 'broccoli', 51: 'carrot', 52: 'hot dog', 53: 'pizza', 54: 'donut', 55: 'cake', 56: 'chair', 57: 'couch', 58: 'potted plant', 59: 'bed', 60: 'dining table', 61: 'toilet', 62: 'tv', 63: 'laptop', 64: 'mouse', 65: 'remote', 66: 'keyboard', 67: 'cell phone', 68: 'microwave', 69: 'oven', 70: 'toaster', 71: 'sink', 72: 'refrigerator', 73: 'book', 74: 'clock', 75: 'vase', 76: 'scissors', 77: 'teddy bear', 78: 'hair drier', 79: 'toothbrush' } # 1. 統計 current_zones 裡，已使用掉的 (class_name, region) 次數 used_count = {} for zone_info in current_zones.values(): rg = zone_info.get("region", "") for obj_name in zone_info.get("objects", []): key = (obj_name, rg) used_count[key] = used_count.get(key, 0) + 1 # 2. 統計 all_detected_objects 裡的 (class_name, region) 總次數 total_count = {} for obj in all_detected_objects: cname = obj.get("class_name", "") rg = obj.get("region", "") key = (cname, rg) total_count[key] = total_count.get(key, 0) + 1 # 3. 把 default_classes 轉換成「class_name → fallback 區域 type」的對照表 category_to_fallback = { # 行人與交通工具 "person": "pedestrian area", "bicycle": "vehicle movement area", "car": "vehicle movement area", "motorcycle": "vehicle movement area", "airplane": "vehicle movement area", "bus": "vehicle movement area", "train": "vehicle movement area", "truck": "vehicle movement area", "boat": "vehicle movement area", "traffic light": "traffic control area", "fire hydrant": "traffic control area", "stop sign": "traffic control area", "parking meter": "traffic control area", "bench": "public furniture area", # 動物類、鳥類 "bird": "animal area", "cat": "animal area", "dog": "animal area", "horse": "animal area", "sheep": "animal area", "cow": "animal area", "elephant": "animal area", "bear": "animal area", "zebra": "animal area", "giraffe": "animal area", # 托運與行李 "backpack": "personal items area", "umbrella": "personal items area", "handbag": "personal items area", "tie": "personal items area", "suitcase": "personal items area", # 運動器材 "frisbee": "sports area", "skis": "sports area", "snowboard": "sports area", "sports ball": "sports area", "kite": "sports area", "baseball bat": "sports area", "baseball glove":"sports area", "skateboard": "sports area", "surfboard": "sports area", "tennis racket": "sports area", # 廚房與食品（Kitchen） "bottle": "kitchen area", "wine glass": "kitchen area", "cup": "kitchen area", "fork": "kitchen area", "knife": "kitchen area", "spoon": "kitchen area", "bowl": "kitchen area", "banana": "kitchen area", "apple": "kitchen area", "sandwich": "kitchen area", "orange": "kitchen area", "broccoli": "kitchen area", "carrot": "kitchen area", "hot dog": "kitchen area", "pizza": "kitchen area", "donut": "kitchen area", "cake": "kitchen area", "dining table": "furniture arrangement area", "refrigerator": "kitchen area", "oven": "kitchen area", "microwave": "kitchen area", "toaster": "kitchen area", "sink": "kitchen area", "book": "miscellaneous area", "clock": "miscellaneous area", "vase": "decorative area", "scissors": "miscellaneous area", "teddy bear": "miscellaneous area", "hair drier": "miscellaneous area", "toothbrush": "miscellaneous area", # 電子產品 "tv": "electronics area", "laptop": "electronics area", "mouse": "electronics area", "remote": "electronics area", "keyboard": "electronics area", "cell phone": "electronics area", # 家具類 "chair": "furniture arrangement area", "couch": "furniture arrangement area", "bed": "furniture arrangement area", "toilet": "furniture arrangement area", # 植物（室內植物或戶外綠化） "potted plant": "decorative area", } # 4. 計算缺少的 (class_name, region) 並建立 fallback zone for (cname, rg), total in total_count.items(): used = used_count.get((cname, rg), 0) missing = total - used if missing <= 0: continue # (A) 決定這個 cname 在 fallback 裡屬於哪個大 class（zone_type） zone_type = category_to_fallback.get(cname, "miscellaneous area") # (B) 根據 region 與 zone_type 組合成 fallback_key fallback_key = f"{rg} {zone_type}" # (C) 如果名稱重複，就在後面加 (1),(2),… 避免掉衝突 if fallback_key in current_zones or fallback_key in general_fallback: suffix = 1 new_key = f"{fallback_key} ({suffix})" while new_key in current_zones or new_key in general_fallback: suffix += 1 new_key = f"{fallback_key} ({suffix})" fallback_key = new_key # (D) 建立這支 fallback zone，objects 裡放 missing 個 cname general_fallback[fallback_key] = { "region": rg, "objects": [cname] * missing, "description": f"{missing} {cname}(s) placed in fallback {zone_type} for region {rg}" } return general_fallback