feat: add gen_task2 v1

src/action_state/gen_task2.py

@@ -29,4 +29,295 @@ B. <image_start>[image_B]<image_end>
 C. <image_start>[image_C]<image_end>
 D. <image_start>[image_D]<image_end>
 
-"""
+"""
+
+import argparse
+import random
+from tqdm import tqdm
+import numpy as np
+
+# 导入公共工具库 (假设 utils.py 在同一目录下)
+from utils import (
+    CO3DDataLoader, 
+    get_relative_yaw, 
+    format_angle_direction, 
+    get_angle_diff, 
+    format_image_path, 
+    save_jsonl_splits
+)
+
+class Task2Generator:
+    def __init__(self, loader, image_prefix):
+        self.loader = loader
+        self.image_prefix = image_prefix
+        # 处理 category 名称，去掉下划线
+        self.cat_name = self.loader.category.replace('_', ' ')
+
+    def verify(self, start_R, target_R, distractor_Rs, min_angle, max_angle, min_interval):
+        """
+        验证逻辑与 Task 1 相同：
+        确保 Start, Target, Distractors 视觉上是可区分的。
+        虽然 Task 2 是多步移动，但最终我们需要区分的是"最终位置"的视图。
+        """
+        # 1. 计算 Target 角度并检查范围
+        target_yaw = get_relative_yaw(start_R, target_R)
+        if not (min_angle <= abs(target_yaw) <= max_angle):
+            return False, None, []
+
+        # 2. 计算所有干扰项角度
+        distractor_yaws = [get_relative_yaw(start_R, dR) for dR in distractor_Rs]
+
+        # 3. 全局互斥检查
+        all_angles = [0.0, target_yaw] + distractor_yaws
+        
+        for i in range(len(all_angles)):
+            for j in range(i + 1, len(all_angles)):
+                if get_angle_diff(all_angles[i], all_angles[j]) < min_interval:
+                    return False, None, []
+                    
+        return True, target_yaw, distractor_yaws
+
+    def _generate_instruction_sequence(self, total_yaw):
+        """
+        将总角度 total_yaw 拆解为 2 到 3 步的旋转指令序列。
+        例如：Total 40 -> Step1: 90, Step2: -50
+        """
+        target_deg = int(round(total_yaw))
+        num_steps = random.choices([3, 4], weights=[0.5, 0.5])[0]
+        
+        max_attempts = 100
+        for _ in range(max_attempts):
+            steps = []
+            current_sum = 0
+            
+            # 生成前 n-1 步
+            for _ in range(num_steps - 1):
+                # 随机生成一个较大的角度步骤，范围 [-120, 120]，避开过小的角度
+                step = 0
+                while abs(step) < 20: 
+                    step = random.randint(-90, 90)
+                steps.append(step)
+                current_sum += step
+            
+            # 计算最后一步
+            final_step = target_deg - current_sum
+            
+            # 验证最后一步是否合理 (不能太小，也不能太大)
+            if 20 <= abs(final_step) <= 90:
+                steps.append(final_step)
+                
+                # 生成文本描述
+                instruction_parts = []
+                for i, step in enumerate(steps):
+                    val, direction = format_angle_direction(step)
+                    action = f"rotate {val} degrees {direction}"
+                    if i == 0:
+                        instruction_parts.append(action)
+                    else:
+                        instruction_parts.append(f"then {action}")
+                
+                instruction_str = ", ".join(instruction_parts)
+                return instruction_str, steps
+        
+        # 如果尝试多次失败，回退到直接一步 (虽然不太可能发生)
+        val, direction = format_angle_direction(target_deg)
+        return f"rotate {val} degrees {direction}", [target_deg]
+
+    def generate_sample(self, seq_name, config):
+        frames = self.loader.get_frames(seq_name)
+        if len(frames) < 5:
+            return None
+
+        max_attempts = 5000
+        for _ in range(max_attempts):
+            # A. 随机采样 Start, Target, Distractors
+            start_idx = random.choice(frames)
+            start_info = self.loader.get_frame_info(seq_name, start_idx)
+            
+            possible_targets = [f for f in frames if f != start_idx]
+            target_idx = random.choice(possible_targets)
+            target_info = self.loader.get_frame_info(seq_name, target_idx)
+            
+            remaining = [f for f in frames if f != start_idx and f != target_idx]
+            if len(remaining) < 3: continue
+            distractor_indices = random.sample(remaining, 3)
+            distractor_infos = [self.loader.get_frame_info(seq_name, d) for d in distractor_indices]
+
+            # B. 验证几何约束
+            is_valid, target_yaw, distractor_yaws = self.verify(
+                start_info['R'], 
+                target_info['R'], 
+                [d['R'] for d in distractor_infos],
+                config['min_angle'], 
+                config['max_angle'], 
+                config['min_interval']
+            )
+
+            if is_valid:
+                # C. 生成指令序列
+                instruction_seq, steps_breakdown = self._generate_instruction_sequence(target_yaw)
+                
+                return self.create_entry(
+                    seq_name, start_idx, target_idx, distractor_indices,
+                    target_yaw, distractor_yaws, 
+                    start_info, target_info, distractor_infos,
+                    instruction_seq, steps_breakdown
+                )
+        return None
+
+    def create_entry(self, seq_name, start_idx, target_idx, distractor_indices, 
+                     target_yaw, distractor_yaws, start_info, target_info, distractor_infos,
+                     instruction_seq, steps_breakdown):
+        
+        # 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),
+                "angle": d_yaw,
+                "is_correct": False
+            })
+        
+        random.shuffle(options)
+        
+        # 2. 映射到 A, B, C, D
+        images_dict = {
+            "image_1": format_image_path(start_info['path'], self.loader.root_path, self.image_prefix)
+        }
+        option_labels = ['A', 'B', 'C', 'D']
+        option_angles_meta = {}
+        correct_label = ""
+        
+        for label, opt in zip(option_labels, options):
+            images_dict[f"image_{label}"] = opt["path"]
+            option_angles_meta[label] = opt["angle"]
+            if opt["is_correct"]:
+                correct_label = label
+
+        # 3. 生成 Prompt (Task 2 模板)
+        template_id = random.choice([1, 2])
+        
+        if template_id == 1:
+            question = f"""The object in the image <image_start>[image_1]<image_end> remains **static**.
+
+Imagine a camera rotating around this object. The direction of rotation is defined from a **top-down bird's-eye view**.
+
+Please identify the view of the object after the camera follows this sequence of rotations: {instruction_seq}. Based on this top-down perspective, select the correct answer.
+
+A. <image_start>[image_A]<image_end>
+B. <image_start>[image_B]<image_end>
+C. <image_start>[image_C]<image_end>
+D. <image_start>[image_D]<image_end>"""
+
+        else:
+            question = f"""Given the initial view of a static object: <image_start>[image_1]<image_end>.
+
+Imagine looking at the setup from a bird's-eye view (from directly above) to determine the direction. Now, move the camera according to the following instructions: {instruction_seq}.
+
+Which of the following images shows what the object looks like from this new position?
+
+A. <image_start>[image_A]<image_end>
+B. <image_start>[image_B]<image_end>
+C. <image_start>[image_C]<image_end>
+D. <image_start>[image_D]<image_end>"""
+
+        return {
+            "id": f"task2_{seq_name}_{start_idx}_{target_idx}",
+            "task": "camera_view_sequence_prediction", # 区分于 Task 1
+            "sequence": seq_name,
+            "category": self.loader.category,
+            "question": question,
+            "images": images_dict,
+            "metadata": {
+                "start_frame": start_idx,
+                "target_frame": target_idx,
+                "total_yaw": target_yaw,
+                "instruction_sequence": instruction_seq,
+                "steps_degrees": steps_breakdown,
+                "option_angles": option_angles_meta
+            },
+            "gt_answer": correct_label
+        }
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate Task 2: Sequence Camera View Prediction")
+    
+    # 路径配置
+    parser.add_argument("--root_path", type=str, required=True, help="CO3D dataset root")
+    parser.add_argument("--output_dir", type=str, default="output_task2", help="Output directory")
+    parser.add_argument("--image_prefix", type=str, default="data/", help="Prefix for image paths")
+    
+    # 采样配置
+    parser.add_argument("--category", type=str, default=None, help="Specific category or None for all")
+    parser.add_argument("--num_samples", type=int, default=1, help="Samples per sequence")
+    parser.add_argument("--seed", type=int, default=42)
+    
+    # 几何约束配置 (与 Task 1 保持一致，用于筛选 Start/Target)
+    parser.add_argument("--min_angle", type=float, default=40.0)
+    parser.add_argument("--max_angle", type=float, default=140.0)
+    parser.add_argument("--min_interval", type=float, default=25.0)
+    
+    # 切分配置
+    parser.add_argument("--train_ratio", type=float, default=0.8)
+    parser.add_argument("--val_ratio", type=float, default=0.1)
+    parser.add_argument("--test_ratio", type=float, default=0.1)
+    parser.add_argument("--max_items", type=int, default=10000)
+
+    args = parser.parse_args()
+    
+    # 初始化
+    random.seed(args.seed)
+    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))])
+        else:
+            print(f"Error: {data_dir} not found.")
+            return
+
+    all_results = []
+    config = {
+        'min_angle': args.min_angle,
+        'max_angle': args.max_angle,
+        'min_interval': args.min_interval
+    }
+
+    # 主循环
+    for cat in categories:
+        loader = CO3DDataLoader(args.root_path, cat)
+        if not loader.seq_data:
+            continue
+            
+        generator = Task2Generator(loader, args.image_prefix)
+        sequences = loader.get_sequences()
+        
+        for seq in tqdm(sequences, desc=f"Task2 - {cat}", leave=False):
+            for _ in range(args.num_samples):
+                sample = generator.generate_sample(seq, config)
+                if sample:
+                    all_results.append(sample)
+
+    # 保存与切分
+    print(f"Total generated: {len(all_results)}")
+    save_jsonl_splits(
+        all_results, 
+        args.output_dir, 
+        ratios=(args.train_ratio, args.val_ratio, args.test_ratio),
+        max_items=args.max_items,
+        seed=args.seed
+    )
+    print(f"Done. Output saved to {args.output_dir}")
+
+if __name__ == "__main__":
+    main()