Upload 5 files

content_generator.py

@@ -15,7 +15,7 @@ class ContentGenerator:
         """初始化內容生成器"""
         self.logger = logging.getLogger(self.__class__.__name__)
 
-        # 預載入默認替換內容
+        # 預載入默認替換內容 
         self.default_replacements = self._generate_default_replacements()
 
         self.logger.debug("ContentGenerator initialized successfully")
@@ -238,7 +238,7 @@ class ContentGenerator:
             if not detected_objects:
                 return "various elements"
 
-            # 計算物件統計
+            # 計算物件統計 
             object_counts = {}
             total_confidence = 0
 
@@ -277,40 +277,21 @@ class ContentGenerator:
                 else:
                     descriptions.append(f"{count} {clean_name}s")
 
-            # === 修正組合描述邏輯，增加驗證機制 ===
-            # 過濾掉空的或無效的描述
-            valid_descriptions = [desc.strip() for desc in descriptions if desc and desc.strip()]
-            
-            # 確保有有效的描述項目
-            if not valid_descriptions:
-                return "various elements"
-
-            # 組合描述 - 修正邏輯以避免不完整的結尾
-            if len(valid_descriptions) == 1:
-                return valid_descriptions[0]
-            elif len(valid_descriptions) == 2:
-                return f"{valid_descriptions[0]} and {valid_descriptions[1]}"
+            # 組合描述
+            if len(descriptions) == 1:
+                return descriptions[0]
+            elif len(descriptions) == 2:
+                return f"{descriptions[0]} and {descriptions[1]}"
             else:
-                # 對於3個或以上的項目，確保正確的語法結構
-                main_items = ", ".join(valid_descriptions[:-1])
-                last_item = valid_descriptions[-1]
-                # 確保 main_items 和 last_item 都不為空
-                if main_items and last_item:
-                    return f"{main_items}, and {last_item}"
-                elif main_items:
-                    return main_items
-                elif last_item:
-                    return last_item
-                else:
-                    return "various elements"
+                return ", ".join(descriptions[:-1]) + f", and {descriptions[-1]}"
 
         except Exception as e:
             self.logger.warning(f"Error generating objects summary: {str(e)}")
             return "various elements"
 
     def get_placeholder_replacement(self, placeholder: str, fillers: Dict,
-                               all_replacements: Dict, detected_objects: List[Dict],
-                               scene_type: str) -> str:
+                                   all_replacements: Dict, detected_objects: List[Dict],
+                                   scene_type: str) -> str:
         """
         獲取特定佔位符的替換內容，確保永遠不返回空值
 
@@ -324,36 +305,18 @@ class ContentGenerator:
         Returns:
             str: 替換內容
         """
-        try:                      
-            # 動態佔位符的差異化處理策略
-            dynamic_placeholders_mapping = {
-                'primary_objects': 'full_summary',
-                'detected_objects_summary': 'full_summary', 
-                'main_objects': 'simple_summary',
-                'functional_area': 'area_focus',
-                'functional_zones_description': 'zones_focus',
-                'scene_elements': 'elements_focus'
-            }
-            
-            if placeholder in dynamic_placeholders_mapping:
-                content_type = dynamic_placeholders_mapping[placeholder]
-                
-                # 根據內容類型和當前檢測物件生成不同的描述
-                if content_type == 'full_summary':
-                    return self.generate_objects_summary(detected_objects)
-                elif content_type == 'simple_summary':
-                    # 避免重複敘述
-                    return self._generate_simplified_objects_summary(detected_objects)
-                elif content_type == 'area_focus':
-                    # 以圖片中的area 作為重點描述
-                    return self._generate_area_focused_summary(detected_objects)
-                elif content_type == 'zones_focus':
-                    # 以圖片中的zones 作為重點描述
-                    return self._generate_zones_summary(detected_objects)
-                elif content_type == 'elements_focus':
-                    # 以圖片中物品作為重點描述
-                    return self._generate_elements_summary(detected_objects)
-          
+        try:
+            # 優先處理動態內容生成的佔位符
+            dynamic_placeholders = [
+                'primary_objects', 'detected_objects_summary', 'main_objects',
+                'functional_area', 'functional_zones_description', 'scene_elements'
+            ]
+
+            if placeholder in dynamic_placeholders:
+                dynamic_content = self.generate_objects_summary(detected_objects)
+                if dynamic_content and dynamic_content.strip():
+                    return dynamic_content.strip()
+
             # 檢查預定義替換內容
             if placeholder in all_replacements:
                 replacement = all_replacements[placeholder]
@@ -383,7 +346,7 @@ class ContentGenerator:
             if scene_specific_replacement and scene_specific_replacement.strip():
                 return scene_specific_replacement.strip()
 
-            # 通用備用字典
+            # 通用備用字典 
             fallback_replacements = {
                 # 交通和城市相關
                 "crossing_pattern": "pedestrian crosswalks",
@@ -442,7 +405,7 @@ class ContentGenerator:
             # 最終備用：將下劃線轉換為有意義的短語
             cleaned_placeholder = placeholder.replace('_', ' ')
 
-            # 對常見模式提供更全面的defualt value
+            # 對常見模式提供更好的默認值
             if placeholder.endswith('_pattern'):
                 return f"{cleaned_placeholder.replace(' pattern', '')} arrangement"
             elif placeholder.endswith('_behavior'):
@@ -458,94 +421,9 @@ class ContentGenerator:
 
         except Exception as e:
             self.logger.warning(f"Error getting replacement for placeholder '{placeholder}': {str(e)}")
+            # 確保即使在異常情況下也返回有意義的內容
             return placeholder.replace('_', ' ') if placeholder else "scene elements"
 
-    def _generate_simplified_objects_summary(self, detected_objects: List[Dict]) -> str:
-        """生成簡化的物件摘要，避免與詳細摘要重複"""
-        try:
-            if not detected_objects:
-                return "scene elements"
-            
-            # 只取最重要的前3個物件
-            object_counts = {}
-            for obj in detected_objects:
-                class_name = obj.get("class_name", "unknown")
-                confidence = obj.get("confidence", 0.5)
-                
-                if class_name not in object_counts:
-                    object_counts[class_name] = {"count": 0, "total_confidence": 0}
-                
-                object_counts[class_name]["count"] += 1
-                object_counts[class_name]["total_confidence"] += confidence
-            
-            # 排序並取前3個
-            sorted_objects = []
-            for class_name, stats in object_counts.items():
-                count = stats["count"]
-                avg_confidence = stats["total_confidence"] / count
-                importance = count * 0.6 + avg_confidence * 0.4
-                sorted_objects.append((class_name, count, importance))
-            
-            sorted_objects.sort(key=lambda x: x[2], reverse=True)
-            top_objects = sorted_objects[:3]
-            
-            if top_objects:
-                primary_object = top_objects[0]
-                clean_name = primary_object[0].replace('_', ' ')
-                count = primary_object[1]
-                
-                if count == 1:
-                    article = "an" if clean_name[0].lower() in 'aeiou' else "a"
-                    return f"{article} {clean_name}"
-                else:
-                    return f"{count} {clean_name}s"
-            
-            return "scene elements"
-        
-        except Exception as e:
-            self.logger.warning(f"Error generating simplified summary: {str(e)}")
-            return "scene elements"
-
-    def _generate_area_focused_summary(self, detected_objects: List[Dict]) -> str:
-        """生成區域導向的摘要"""
-        try:
-            # 根據檢測到的物件推斷主要功能區域
-            furniture_objects = [obj for obj in detected_objects if obj.get("class_name") in ["chair", "dining table", "sofa", "bed"]]
-            
-            if any(obj.get("class_name") == "dining table" for obj in furniture_objects):
-                return "dining area"
-            elif any(obj.get("class_name") == "sofa" for obj in furniture_objects):
-                return "seating area"
-            elif any(obj.get("class_name") == "bed" for obj in furniture_objects):
-                return "sleeping area"
-            elif furniture_objects:
-                return "furnished area"
-            else:
-                return "activity area"
-        
-        except Exception as e:
-            self.logger.warning(f"Error generating area-focused summary: {str(e)}")
-            return "functional area"
-
-    def _generate_zones_summary(self, detected_objects: List[Dict]) -> str:
-        """生成區域描述摘要"""
-        try:
-            return "organized areas of activity"
-        except Exception as e:
-            return "functional zones"
-
-    def _generate_elements_summary(self, detected_objects: List[Dict]) -> str:
-        """生成元素導向的摘要"""
-        try:
-            if len(detected_objects) > 5:
-                return "diverse elements"
-            elif len(detected_objects) > 2:
-                return "multiple elements"
-            else:
-                return "key elements"
-        except Exception as e:
-            return "scene elements"
-
     def get_scene_based_default(self, placeholder: str, scene_type: str) -> Optional[str]:
         """
         基於場景類型提供智能默認值

functional_zone_detector.py

@@ -230,14 +230,7 @@ class FunctionalZoneDetector:
             region = zone_data.get("region", "")
             description = zone_data.get("description", "")
 
-            # 確保只有在明確檢測到廚房設備時才產生 kitchen area
-            kitchen_objects = ["refrigerator", "microwave", "oven", "sink", "dishwasher", "stove"]
-            explicit_kitchen_detected = any(
-                any(kitchen_item in obj.lower() for kitchen_item in kitchen_objects)
-                for obj in objects
-            )
-
-            # 基於物件內容確定功能類型（保持原有順序，但加強廚房確認, 因為與dining room混淆）
+            # 基於物件內容確定功能類型
             if any("dining" in obj.lower() or "table" in obj.lower() for obj in objects):
                 base_name = "dining area"
             elif any("chair" in obj.lower() or "sofa" in obj.lower() for obj in objects):
@@ -248,52 +241,20 @@ class FunctionalZoneDetector:
                 base_name = "workspace area"
             elif any("plant" in obj.lower() or "vase" in obj.lower() for obj in objects):
                 base_name = "decorative area"
-            elif explicit_kitchen_detected:
-                # 只有在明確檢測到廚房設備時才使用 kitchen area
+            elif any("refrigerator" in obj.lower() or "microwave" in obj.lower() for obj in objects):
                 base_name = "kitchen area"
             else:
-                # 基於描述內容推斷，但避免不當的 kitchen area 判斷
-                if "dining" in description.lower() and any("table" in obj.lower() for obj in objects):
-                    # 只有當描述中提到 dining 且確實有桌子時才使用 dining area
+                # 基於描述內容推斷
+                if "dining" in description.lower():
                     base_name = "dining area"
                 elif "seating" in description.lower() or "relaxation" in description.lower():
                     base_name = "seating area"
-                elif "work" in description.lower() and any("laptop" in obj.lower() or "keyboard" in obj.lower() for obj in objects):
-                    # 只有當描述中提到 work 且確實有工作設備時才使用 workspace area
+                elif "work" in description.lower():
                     base_name = "workspace area"
                 elif "decorative" in description.lower():
                     base_name = "decorative area"
                 else:
-                    # 根據主要物件類型決定預設區域類型，避免使用 kitchen area
-                    if objects:
-                        # 根據最常見的物件類型決定區域名稱
-                        object_counts = {}
-                        for obj in objects:
-                            obj_lower = obj.lower()
-                            if "chair" in obj_lower:
-                                object_counts["seating"] = object_counts.get("seating", 0) + 1
-                            elif "table" in obj_lower:
-                                object_counts["dining"] = object_counts.get("dining", 0) + 1
-                            elif "person" in obj_lower:
-                                object_counts["activity"] = object_counts.get("activity", 0) + 1
-                            else:
-                                object_counts["general"] = object_counts.get("general", 0) + 1
-                        
-                        # 選擇最常見的類型
-                        if object_counts:
-                            most_common = max(object_counts, key=object_counts.get)
-                            if most_common == "seating":
-                                base_name = "seating area"
-                            elif most_common == "dining":
-                                base_name = "dining area"
-                            elif most_common == "activity":
-                                base_name = "activity area"
-                            else:
-                                base_name = "functional area"
-                        else:
-                            base_name = "functional area"
-                    else:
-                        base_name = "functional area"
+                    base_name = "functional area"
 
             # 為次要區域添加位置標識以區分
             if priority_level == "secondary" and region:

functional_zone_identifier.py

@@ -688,7 +688,7 @@ class FunctionalZoneIdentifier:
             if not high_conf_objects:
                 high_conf_objects = detected_objects  # 後備到所有物件
 
-            # 根據個別重要物件創建區域
+            # 基於個別重要物件創建區域
             processed_objects = set()  # 避免重複處理相同類型的物件
 
             for obj in high_conf_objects[:3]:  # 限制為前3個物件
@@ -788,6 +788,7 @@ class FunctionalZoneIdentifier:
             區域描述字串
         """
         try:
+            # 物件特定描述
             descriptions = {
                 "bed": "Sleeping and rest area",
                 "sofa": "Seating and relaxation area",
@@ -796,42 +797,10 @@ class FunctionalZoneIdentifier:
                 "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"
             }
-            
-            # 只有在明確的廚房場景中才使用廚房描述
-            kitchen_related_objects = ["refrigerator", "microwave", "oven", "sink", "dishwasher", "stove"]
-            
-            if class_name in kitchen_related_objects:
-                # 檢查場景類型是否真的是廚房相關
-                kitchen_scene_types = ["kitchen", "professional_kitchen", "cooking_area"]
-                
-                if scene_type in kitchen_scene_types:
-                    # 只有在明確的廚房場景中才使用廚房描述
-                    if class_name == "refrigerator":
-                        descriptions[class_name] = "Food storage and kitchen area"
-                    elif class_name == "microwave":
-                        descriptions[class_name] = "Food preparation area"
-                    elif class_name == "oven":
-                        descriptions[class_name] = "Cooking area"
-                    elif class_name == "sink":
-                        descriptions[class_name] = "Washing and preparation area"
-                    else:
-                        descriptions[class_name] = "Kitchen appliance area"
-                else:
-                    # === 修正：非廚房場景中的廚房物件使用中性描述 ===
-                    # 在餐廳、客廳等場景中，即使檢測到這些物件也不使用廚房描述
-                    if class_name == "refrigerator":
-                        descriptions[class_name] = "Storage area"
-                    elif class_name == "microwave":
-                        descriptions[class_name] = "Appliance area"
-                    elif class_name == "oven":
-                        descriptions[class_name] = "Equipment area"
-                    elif class_name == "sink":
-                        descriptions[class_name] = "Utility area"
-                    else:
-                        descriptions[class_name] = "Equipment area"
 
             return descriptions.get(class_name, f"Functional area with {class_name}")
 
@@ -930,36 +899,30 @@ class FunctionalZoneIdentifier:
             "surfboard":     "sports area",
             "tennis racket": "sports area",
 
-            # 餐具與用餐相關物品重新歸類為 dining area 
-            "bottle":        "dining area",
-            "wine glass":    "dining area", 
-            "cup":           "dining area",
-            "fork":          "dining area",
-            "knife":         "dining area",
-            "spoon":         "dining area",
-            "bowl":          "dining area",
-            "dining table":  "dining area",  # 確保 dining table 也歸類為 dining area
-            
-            # 食品使用中性的 food area 
-            "banana":        "food area",
-            "apple":         "food area",
-            "sandwich":      "food area",
-            "orange":        "food area",
-            "broccoli":      "food area",
-            "carrot":        "food area",
-            "hot dog":       "food area",
-            "pizza":         "food area",
-            "donut":         "food area",
-            "cake":          "food area",
-            
-            # 只有在有明確的廚房設備才使用 kitchen area 
-            "refrigerator":  "kitchen appliance area",
-            "oven":          "kitchen appliance area",
-            "microwave":     "kitchen appliance area",
-            "toaster":       "kitchen appliance area",
-            "sink":          "kitchen appliance 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",

scene_zone_identifier.py

@@ -47,10 +47,10 @@ class SceneZoneIdentifier:
         try:
             zones = {}
 
-            # 主要功能區域（根據物件關聯性而非場景類型）
+            # 主要功能區域（基於物件關聯性而非場景類型）
             primary_zone = self.functional_detector.identify_primary_functional_area(detected_objects)
             if primary_zone:
-                # 根據區域內容生成描述性鍵名
+                # 基於區域內容生成描述性鍵名
                 descriptive_key = self.functional_detector.generate_descriptive_zone_key_from_data(primary_zone, "primary")
                 zones[descriptive_key] = primary_zone
 
@@ -116,7 +116,7 @@ class SceneZoneIdentifier:
                                 "description": f"Pedestrian area with {len(objs)} {'people' if len(objs) > 1 else 'person'}"
                             }
 
-            # 辨識車輛區域，適用於街道和停車場
+            # 識別車輛區域，適用於街道和停車場
             vehicle_objs = [obj for obj in detected_objects if obj["class_id"] in [1, 2, 3, 5, 6, 7]]
             if vehicle_objs:
                 vehicle_regions = {}
@@ -250,6 +250,7 @@ class SceneZoneIdentifier:
             # 5. Step D: 分析車輛交通區域（Vehicle Zones）
             if vehicle_objs:
                 traffic_zones = self.pattern_analyzer.analyze_traffic_zones(vehicle_objs)
+                # analyze_traffic_zones 內部已用英文 debug，直接更新
                 for zone_key, zone_info in traffic_zones.items():
                     if zone_key in zones:
                         suffix = 1
@@ -354,7 +355,7 @@ class SceneZoneIdentifier:
         try:
             zones = {}
 
-            # 辨識店面區域
+            # 識別店面區域
             # 由於店面不能直接檢測，從情境推斷
             # 例如，尋找有標誌、行人和小物件的區域
             storefront_regions = {}
@@ -372,7 +373,7 @@ class SceneZoneIdentifier:
                                             reverse=True)[:2]  # 前2個區域
 
                 for idx, (region, objs) in enumerate(main_storefront_regions):
-                    # 根據基於位置的描述性key name
+                    # 生成基於位置的描述性鍵名
                     spatial_desc = self._get_directional_description(region)
                     if spatial_desc and spatial_desc != "central":
                         zone_key = f"{spatial_desc} commercial area"

template_processor.py

@@ -50,7 +50,6 @@ class TemplateProcessor:
             str: 修復後的模板字符串
         """
         try:
-            # 原有的語法修復邏輯
             # 修復 "In , " 模式
             filled_template = re.sub(r'\bIn\s*,\s*', 'In this scene, ', filled_template)
             filled_template = re.sub(r'\bAt\s*,\s*', 'At this location, ', filled_template)
@@ -61,63 +60,7 @@ class TemplateProcessor:
 
             # 修復開頭的逗號
             filled_template = re.sub(r'^[,\s]*', '', filled_template)
-          
-            # 1. 修復不完整的 "and." 結尾問題
-            # 處理 "物件列表, and." 的模式，將其修正為完整的句子
-            filled_template = re.sub(r',\s*and\s*\.\s*', '. ', filled_template)
-            filled_template = re.sub(r'\s+and\s*\.\s*', '. ', filled_template)
-            
-            # 2. 處理重複的物件列表模式
-            # 識別並移除重複的完整物件描述片段
-            # 針對 "數字 + 物件名稱" 的重複模式
-            object_pattern = r'(\b\d+\s+\w+(?:\s+\w+)*(?:,\s*\d+\s+\w+(?:\s+\w+)*)*(?:,\s*(?:a|an)\s+\w+(?:\s+\w+)*)*)'
-            
-            # 找到所有物件列表片段
-            object_matches = re.findall(object_pattern, filled_template)
-            if object_matches:
-                # 移除重複的物件列表
-                seen_objects = set()
-                for obj_desc in object_matches:
-                    # 標準化物件描述用於比較（移除多餘空格）
-                    normalized_desc = re.sub(r'\s+', ' ', obj_desc.strip().lower())
-                    if normalized_desc in seen_objects:
-
-                        # 找到重複的物件描述，移除後續出現的實例
-                        escaped_desc = re.escape(obj_desc)
-                        pattern = r'\.\s*' + escaped_desc + r'(?=\s*\.|\s*$)'
-                        filled_template = re.sub(pattern, '', filled_template, count=1)
-                    else:
-                        seen_objects.add(normalized_desc)
-            
-            # 3. 處理重複的句子片段
-            # 將文本分割為句子，檢查是否有完整句子的重複
-            sentences = re.split(r'(?<=[.!?])\s+', filled_template)
-            unique_sentences = []
-            seen_sentences = set()
-            
-            for sentence in sentences:
-                if sentence.strip():  # 忽略空句子
-                    # 標準化句子用於比較（移除標點符號和多餘空格）
-                    normalized_sentence = re.sub(r'[^\w\s]', '', sentence.lower().strip())
-                    normalized_sentence = re.sub(r'\s+', ' ', normalized_sentence)
-                    
-                    # 只有當句子足夠長且確實重複時才移除
-                    if len(normalized_sentence) > 10 and normalized_sentence not in seen_sentences:
-                        unique_sentences.append(sentence.strip())
-                        seen_sentences.add(normalized_sentence)
-                    elif len(normalized_sentence) <= 10:
-                        # 短句子直接保留，避免過度清理
-                        unique_sentences.append(sentence.strip())
-            
-            # 重新組合句子
-            if unique_sentences:
-                filled_template = ' '.join(unique_sentences)
-            
-            # 4. 清理可能產生的多餘空格和標點符號
-            filled_template = re.sub(r'\s+', ' ', filled_template)
-            filled_template = re.sub(r'\s*\.\s*\.\s*', '. ', filled_template)  # 移除連續句號
-            filled_template = re.sub(r'\s*,\s*\.\s*', '. ', filled_template)   # 修正 ", ." 
-                      
+
             # 確保首字母大寫
             if filled_template and not filled_template[0].isupper():
                 filled_template = filled_template[0].upper() + filled_template[1:]