feat: add cot trace generation code for task1

src/action_state/gen_task1.py

@@ -32,7 +32,10 @@ D. <image_start>[image_D]<image_end>
 import argparse
 import random
 import json
+import os
 from tqdm import tqdm
+import numpy as np # 确保导入 numpy
+
 # 导入公共工具库
 from utils import (
     CO3DDataLoader, 
@@ -41,15 +44,19 @@ from utils import (
     get_angle_diff,
     format_image_path,
     save_jsonl_splits,
-    get_sequence_geometry
+    get_sequence_geometry,
+    decompose_angle
 )
 
 class Task1Generator:
     def __init__(self, loader, image_prefix):
         self.loader = loader
         self.image_prefix = image_prefix
-        # 处理 category 名称，去掉下划线，使其在 Prompt 中更自然
         self.cat_name = self.loader.category.replace('_', ' ')
+        # 定义旋转步长配置，与 create_entry 保持一致
+        self.ROTATION_STEPS = [15, 10] 
+        # 定义允许的最大误差（度）：如果模拟角度和真实图片角度相差超过此值，则认为该样本无效
+        self.MAX_COT_ERROR = 10.0 
 
     def verify(self, start_R, start_T, target_R, target_T, distractor_infos, 
                min_angle, max_angle, min_interval, mean_center, basis):
@@ -57,22 +64,16 @@ class Task1Generator:
         Task 1 专用验证逻辑：
         确保 Start, Target, Distractors 任意两张图之间的角度差都大于 min_interval
         """
-        # 1. 计算 Target 角度并检查范围
-        # [修改] 使用 PCA 计算角度
         target_yaw = get_relative_yaw(start_R, start_T, target_R, target_T, mean_center, basis)
         
         if not (min_angle <= abs(target_yaw) <= max_angle):
             return False, None, []
 
-        # 2. 计算所有干扰项角度
         distractor_yaws = []
         for d_info in distractor_infos:
-            # [修改] 使用 PCA 计算角度
             d_yaw = get_relative_yaw(start_R, start_T, d_info['R'], d_info['T'], mean_center, basis)
             distractor_yaws.append(d_yaw)
 
-        # 3. 全局互斥检查 (Global Separation Check)
-        # 集合: [Start(0度), Target, D1, D2, D3]
         all_angles = [0.0, target_yaw] + distractor_yaws
         
         for i in range(len(all_angles)):
@@ -82,16 +83,63 @@ class Task1Generator:
                     
         return True, target_yaw, distractor_yaws
 
+    def _get_all_relative_angles(self, start_idx, all_frames, aligned_seq_data, mean_center, basis):
+        """
+        计算序列中所有帧相对于 start_idx 的角度。
+        """
+        start_info = aligned_seq_data[start_idx]
+        results = []
+        
+        for f_idx in all_frames:
+            if f_idx == start_idx:
+                results.append({'idx': f_idx, 'angle': 0.0})
+                continue
+                
+            f_info = aligned_seq_data[f_idx]
+            yaw = get_relative_yaw(
+                start_info['R'], start_info['T'], 
+                f_info['R'], f_info['T'], 
+                mean_center, basis
+            )
+            results.append({'idx': f_idx, 'angle': yaw})
+            
+        return results
+
+    def _check_cot_feasibility(self, target_yaw, all_rel_data):
+        """
+        [新增] 检查 CoT 路径的可行性。
+        如果中间某一步找不到足够接近的真实图片（误差 > MAX_COT_ERROR），则返回 False。
+        """
+        rotation_sign = 1 if target_yaw >= 0 else -1
+        total_delta = abs(target_yaw)
+        steps = decompose_angle(total_delta, self.ROTATION_STEPS)
+        
+        current_simulated_angle = 0.0
+        
+        for step in steps:
+            current_simulated_angle += (step * rotation_sign)
+            
+            # 寻找最近邻的角度差
+            min_diff = float('inf')
+            for item in all_rel_data:
+                diff = abs(item['angle'] - current_simulated_angle)
+                if diff < min_diff:
+                    min_diff = diff
+            
+            # 如果最近的一张图误差都很大，说明这里缺帧，不能生成高质量 CoT
+            if min_diff > self.MAX_COT_ERROR:
+                return False
+                
+        return True
+
     def generate_sample(self, seq_name, config):
         frames = self.loader.get_frames(seq_name)
-        if len(frames) < 5:
+        if len(frames) < 10: # 稍微提高一点门槛，太短的序列很难凑齐中间帧
             return None
 
-        # [新增] 获取该序列的 PCA 几何信息
         seq_data_dict = self.loader.seq_data[seq_name]
-        mean_center, basis, aligned_seq_data = get_sequence_geometry(seq_data_dict)
+        mean_center, basis, aligned_seq_data = get_sequence_geometry(seq_data_dict, align_to_standard=True)
 
-        # 尝试多次寻找合法组合
         max_attempts = 5000
         for _ in range(max_attempts):
             # A. 随机采样
@@ -99,6 +147,7 @@ class Task1Generator:
             start_info = aligned_seq_data[start_idx]
             
             possible_targets = [f for f in frames if f != start_idx]
+            if not possible_targets: continue
             target_idx = random.choice(possible_targets)
             target_info = aligned_seq_data[target_idx]
             
@@ -107,8 +156,7 @@ class Task1Generator:
             distractor_indices = random.sample(remaining, 3)
             distractor_infos = [aligned_seq_data[d] for d in distractor_indices]
 
-            # B. 验证几何约束
-            # [修改] 传入 T 和 PCA 参数
+            # B. 验证几何约束 (Start/Target/Distractors 之间的互斥性)
             is_valid, target_yaw, distractor_yaws = self.verify(
                 start_info['R'], start_info['T'],
                 target_info['R'], target_info['T'],
@@ -120,25 +168,34 @@ class Task1Generator:
             )
 
             if is_valid:
+                # === 关键修改：先获取所有帧角度，进行 CoT 可行性预检查 ===
+                all_rel_data = self._get_all_relative_angles(
+                    start_idx, frames, aligned_seq_data, mean_center, basis
+                )
+                
+                # 如果 CoT 路径中间缺图，直接跳过，重新采样
+                if not self._check_cot_feasibility(target_yaw, all_rel_data):
+                    continue
+                
                 return self.create_entry(
                     seq_name, start_idx, target_idx, distractor_indices,
-                    target_yaw, distractor_yaws, start_info, target_info, distractor_infos
+                    target_yaw, distractor_yaws, start_info, target_info, distractor_infos,
+                    all_rel_data 
                 )
         return None
 
     def create_entry(self, seq_name, start_idx, target_idx, distractor_indices, 
-                     target_yaw, distractor_yaws, start_info, target_info, distractor_infos):
+                     target_yaw, distractor_yaws, start_info, target_info, distractor_infos,
+                     all_rel_data):
         
         angle_deg, direction_str = format_angle_direction(target_yaw)
         
         # 1. 构建选项列表
-        # 正确选项
         options = [{
             "path": format_image_path(target_info['path'], self.loader.root_path, self.image_prefix),
             "angle": target_yaw,
             "is_correct": True
         }]
-        # 干扰选项
         for d_idx, d_yaw, d_info in zip(distractor_indices, distractor_yaws, distractor_infos):
             options.append({
                 "path": format_image_path(d_info['path'], self.loader.root_path, self.image_prefix),
@@ -162,7 +219,53 @@ class Task1Generator:
             if opt["is_correct"]:
                 correct_label = label
 
-        # 3. 生成 Prompt (使用 self.cat_name)
+        # ------------------------------------------------------------------
+        # 3. 生成 Think Process (CoT)
+        # ------------------------------------------------------------------
+        
+        rotation_sign = 1 if target_yaw >= 0 else -1
+        total_delta = abs(target_yaw)
+        # 使用类成员变量 ROTATION_STEPS
+        steps = decompose_angle(total_delta, self.ROTATION_STEPS)
+        
+        cot_lines = []
+        current_simulated_angle = 0.0
+        reasoning_img_counter = 0
+        
+        for step_idx, step in enumerate(steps):
+            reasoning_img_counter += 1
+            
+            current_simulated_angle += (step * rotation_sign)
+            
+            # 寻找最近邻帧 (这里肯定能找到误差在 MAX_COT_ERROR 内的，因为前面检查过了)
+            closest_frame_data = min(all_rel_data, key=lambda x: abs(x['angle'] - current_simulated_angle))
+            closest_frame_idx = closest_frame_data['idx']
+            
+            closest_frame_info = self.loader.get_frame_info(seq_name, closest_frame_idx)
+            reasoning_key = f"reasoning_image_{reasoning_img_counter}"
+            images_dict[reasoning_key] = format_image_path(
+                closest_frame_info['path'], self.loader.root_path, self.image_prefix
+            )
+            
+            is_last_step = (step_idx == len(steps) - 1)
+            
+            prefix = "After I rotate" if step_idx == 0 else "Continue rotating"
+            
+            step_text = f"{prefix} {step} degrees {direction_str}, I will see <image_start>[{reasoning_key}]<image_end>"
+            
+            if is_last_step:
+                step_text += f", which corresponds to the final view. Checking the answers, option {correct_label} matches this view best, so the final answer should be {correct_label}."
+            else:
+                step_text += ";"
+            
+            cot_lines.append(step_text)
+            
+        think_content = " ".join(cot_lines)
+        final_answer_field = f"<answer>{correct_label}</answer>"
+
+        # ------------------------------------------------------------------
+        # 4. 生成 Prompt
+        # ------------------------------------------------------------------
         template_id = random.choice([1, 2])
         if template_id == 1:
             question = f"""The {self.cat_name} in the image <image_start>[image_1]<image_end> remains **static**. Imagine a camera rotating around this {self.cat_name}. The direction of rotation is defined from a **top-down bird's-eye view**.
@@ -198,9 +301,10 @@ D. <image_start>[image_D]<image_end>"""
                 "angle_degrees": angle_deg,
                 "direction": direction_str,
                 "raw_yaw": target_yaw,
-                "option_angles": option_angles_meta
+                "option_angles": option_angles_meta,
+                "cot_trace": think_content
             },
-            "gt_answer": correct_label
+            "gt_answer": final_answer_field
         }
 
 def main():
@@ -210,8 +314,7 @@ def main():
     parser.add_argument("--root_path", type=str, required=True, help="CO3D dataset root")
     parser.add_argument("--output_dir", type=str, default="output_task1", help="Output directory")
     parser.add_argument("--image_prefix", type=str, default="data/", help="Prefix for image paths")
-    # [新增] 筛选名单路径
-    parser.add_argument("--filter_path", type=str, default=None, help="Root directory for filter logs (containing category/keep.json)")
+    parser.add_argument("--filter_path", type=str, default=None, help="Root directory for filter logs")
     
     # 采样配置
     parser.add_argument("--category", type=str, default=None, help="Specific category or None for all")
@@ -231,16 +334,12 @@ def main():
 
     args = parser.parse_args()
     
-    # 初始化
     random.seed(args.seed)
-    import numpy as np
     np.random.seed(args.seed)
     
-    # 确定类别列表
     if args.category:
         categories = [args.category]
     else:
-        import os
         data_dir = os.path.join(args.root_path, 'data', 'original')
         if os.path.exists(data_dir):
             categories = sorted([d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))])
@@ -255,9 +354,7 @@ def main():
         'min_interval': args.min_interval
     }
 
-    # 主循环
     for cat in categories:
-        # 1. 加载数据 (使用 Utils)
         loader = CO3DDataLoader(args.root_path, cat)
         if not loader.seq_data:
             continue
@@ -265,35 +362,30 @@ def main():
         generator = Task1Generator(loader, args.image_prefix)
         sequences = loader.get_sequences()
 
-        # [新增] 过滤逻辑
         if args.filter_path:
             keep_file = os.path.join(args.filter_path, cat, "keep.json")
             if os.path.exists(keep_file):
                 try:
                     with open(keep_file, 'r') as f:
-                        keep_list = set(json.load(f)) # 使用 set 加速查找
-                    
-                    original_count = len(sequences)
+                        keep_list = set(json.load(f))
                     sequences = [s for s in sequences if s in keep_list]
-                    print(f"[{cat}] Filter applied: {original_count} -> {len(sequences)} sequences retained.")
+                    print(f"[{cat}] Filter applied: {len(sequences)} sequences retained.")
                 except Exception as e:
-                    print(f"[{cat}] Error reading keep.json: {e}. Skipping category.")
+                    print(f"[{cat}] Error reading keep.json: {e}. Skipping.")
                     sequences = []
             else:
-                print(f"[{cat}] Warning: No keep.json found at {keep_file}. Skipping category.")
+                print(f"[{cat}] Warning: No keep.json found. Skipping.")
                 sequences = []
         
         if not sequences:
             continue
         
-        # 2. 生成样本
         for seq in tqdm(sequences, desc=f"Task1 - {cat}", leave=False):
             for _ in range(args.num_samples):
                 sample = generator.generate_sample(seq, config)
                 if sample:
                     all_results.append(sample)
 
-    # 3. 保存与切分 (使用 Utils)
     print(f"Total generated: {len(all_results)}")
     save_jsonl_splits(
         all_results,