Upload 4 files

fixed placeholder, region issues

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,21 +277,40 @@ class ContentGenerator:
                 else:
                     descriptions.append(f"{count} {clean_name}s")
 
-            # 組合描述
-            if len(descriptions) == 1:
-                return descriptions[0]
-            elif len(descriptions) == 2:
-                return f"{descriptions[0]} and {descriptions[1]}"
+            # === 修正組合描述邏輯，增加驗證機制 ===
+            # 過濾掉空的或無效的描述
+            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]}"
             else:
-                return ", ".join(descriptions[:-1]) + f", and {descriptions[-1]}"
+                # 對於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"
 
         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:
         """
         獲取特定佔位符的替換內容，確保永遠不返回空值
 
@@ -305,18 +324,36 @@ class ContentGenerator:
         Returns:
             str: 替換內容
         """
-        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()
-
+        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)
+          
             # 檢查預定義替換內容
             if placeholder in all_replacements:
                 replacement = all_replacements[placeholder]
@@ -346,7 +383,7 @@ class ContentGenerator:
             if scene_specific_replacement and scene_specific_replacement.strip():
                 return scene_specific_replacement.strip()
 
-            # 通用備用字典 
+            # 通用備用字典
             fallback_replacements = {
                 # 交通和城市相關
                 "crossing_pattern": "pedestrian crosswalks",
@@ -405,7 +442,7 @@ class ContentGenerator:
             # 最終備用：將下劃線轉換為有意義的短語
             cleaned_placeholder = placeholder.replace('_', ' ')
 
-            # 對常見模式提供更好的默認值
+            # 對常見模式提供更全面的defualt value
             if placeholder.endswith('_pattern'):
                 return f"{cleaned_placeholder.replace(' pattern', '')} arrangement"
             elif placeholder.endswith('_behavior'):
@@ -421,9 +458,94 @@ 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,7 +230,14 @@ 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):
@@ -241,20 +248,52 @@ 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 any("refrigerator" in obj.lower() or "microwave" in obj.lower() for obj in objects):
+            elif explicit_kitchen_detected:
+                # 只有在明確檢測到廚房設備時才使用 kitchen area
                 base_name = "kitchen area"
             else:
-                # 基於描述內容推斷
-                if "dining" in description.lower():
+                # 基於描述內容推斷，但避免不當的 kitchen area 判斷
+                if "dining" in description.lower() and any("table" in obj.lower() for obj in objects):
+                    # 只有當描述中提到 dining 且確實有桌子時才使用 dining area
                     base_name = "dining area"
                 elif "seating" in description.lower() or "relaxation" in description.lower():
                     base_name = "seating area"
-                elif "work" in description.lower():
+                elif "work" in description.lower() and any("laptop" in obj.lower() or "keyboard" in obj.lower() for obj in objects):
+                    # 只有當描述中提到 work 且確實有工作設備時才使用 workspace area
                     base_name = "workspace area"
                 elif "decorative" in description.lower():
                     base_name = "decorative area"
                 else:
-                    base_name = "functional area"
+                    # 根據主要物件類型決定預設區域類型，避免使用 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"
 
             # 為次要區域添加位置標識以區分
             if priority_level == "secondary" and region:

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,7 +250,6 @@ 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
@@ -355,7 +354,7 @@ class SceneZoneIdentifier:
         try:
             zones = {}
 
-            # 識別店面區域
+            # 辨識店面區域
             # 由於店面不能直接檢測，從情境推斷
             # 例如，尋找有標誌、行人和小物件的區域
             storefront_regions = {}
@@ -373,7 +372,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,6 +50,7 @@ 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)
@@ -60,7 +61,63 @@ 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:]