feat: add gen code

src/action_state/gen_task3.py

@@ -19,7 +19,7 @@
 
 
 1.
-The object in the initial view <image_start>[image_ref]<image_end> remains **static**. Imagine a camera rotating around this object along a continuous path. The total rotation from the start to the end is less than 180 degrees.
+The {object} in the initial view <image_start>[image_ref]<image_end> remains **static**. Imagine a camera rotating around this {object} along a continuous path. The direction of rotation is defined from a **top-down bird's-eye view**. The total rotation from the start to the end is less than 180 degrees.
 
 Below are four images captured during this rotation, labeled 1, 2, 3 and 4. They're currently shuffled.
 
@@ -37,7 +37,67 @@ D. [sequence_D]
 
 
 2.
-Given the initial view of the static object: <image_start>[image_ref]<image_end>.
+Given the initial view of the **static** {object}: <image_start>[image_ref]<image_end>.
+
+Imagine a camera rotating around this {object} to capture a video sequence. The rotation covers an anlge of less than 180 degrees. We have extracted four frames from the sequence, labeled 1 to 4, but their order is jumbled.
+
+1. <image_start>[image_1]<image_end>
+2. <image_start>[image_2]<image_end>
+3. <image_start>[image_3]<image_end>
+4. <image_start>[image_4]<image_end>
+
+Which of the following four options correctly sorts these images into a coherent spatio-temporal starting after the initial view?
+
+A. [sequence_A]
+B. [sequence_B]
+C. [sequence_C]
+D. [sequence_D]
+
+
+"""
+
+import os
+import random
+import itertools
+import numpy as np
+from copy import deepcopy
+
+# 引入提供的 utils
+from utils import (
+    CO3DDataLoader, 
+    get_relative_yaw, 
+    format_image_path, 
+    save_jsonl_splits
+)
+
+# --- 配置参数 ---
+ROOT_PATH = "/run/determined/NAS1/public/lixinyuan/interleaved-co3d"  # 请修改为实际 CO3D 数据集根目录
+OUTPUT_DIR = "/run/determined/NAS1/public/lixinyuan/interleaved-umm/data/questions/task3"
+CATEGORIES = ['tv'] # 示例类别，可根据需要添加更多
+SAMPLES_PER_SEQ = 3  # 每个视频序列生成的样本数量
+IMAGE_PREFIX = "data/raw_images" # 图片路径前缀
+MIN_YAW_INTERVAL = 20.0  # [修改] 最小 Yaw 角度间隔 (度)
+
+# --- 提示词模板 ---
+# 注意：这里保留了 [image_ref] 和 [image_1] 等占位符，不直接替换为路径
+TEMPLATES = [
+    """The object in the initial view <image_start>[image_ref]<image_end> remains **static**. Imagine a camera rotating around this object along a continuous path. The total rotation from the start to the end is less than 180 degrees.
+
+Below are four images captured during this rotation, labeled 1, 2, 3 and 4. They're currently shuffled.
+
+1. <image_start>[image_1]<image_end>
+2. <image_start>[image_2]<image_end>
+3. <image_start>[image_3]<image_end>
+4. <image_start>[image_4]<image_end>
+
+Please analyze the change in perspective and determine the correct chronological order of these four images following the initial view. Select the corret sequence.
+
+A. [sequence_A]
+B. [sequence_B]
+C. [sequence_C]
+D. [sequence_D]
+""",
+    """Given the initial view of the static object: <image_start>[image_ref]<image_end>.
 
 Imagine a camera rotating around this object to capture a video sequence. The rotation covers an anlge of less than 180 degrees. We have extracted four frames from the sequence, labeled 1 to 4, but their order is jumbled.
 
@@ -52,6 +112,252 @@ A. [sequence_A]
 B. [sequence_B]
 C. [sequence_C]
 D. [sequence_D]
+"""
+]
+
+def generate_options(correct_indices_permutation):
+    """
+    生成 A, B, C, D 选项。
+    :param correct_indices_permutation: 正确的顺序列表，例如 [2, 1, 4, 3]
+    :return: (options_dict, correct_choice_char)
+    """
+    all_perms = list(itertools.permutations([1, 2, 3, 4]))
+    correct_list = list(correct_indices_permutation)
+    
+    distractors = [list(p) for p in all_perms if list(p) != correct_list]
+    selected_distractors = random.sample(distractors, 3)
+    
+    choices_content = [correct_list] + selected_distractors
+    random.shuffle(choices_content) 
+    
+    options = {}
+    correct_char = None
+    chars = ['A', 'B', 'C', 'D']
+    
+    for char, content in zip(chars, choices_content):
+        seq_str = "-".join(map(str, content))
+        options[f"sequence_{char}"] = seq_str
+        
+        if content == correct_list:
+            correct_char = char
+            
+    return options, correct_char
+
+def sample_frames_by_yaw(loader, seq_name, frame_ids, min_yaw_interval):
+    """
+    [核心修正] 强制单调性采样。
+    确保采样的帧在角度上是严格单调递增或递减的。
+    """
+    n = len(frame_ids)
+    if n < 5: return None, None
+    max_attempts = 20
+    for _ in range(max_attempts):
+        # 随机选起点
+        start_idx = random.randint(0, n - 5)
+        ref_fid = frame_ids[start_idx]
+        
+        selected_fids = [ref_fid]
+        selected_yaws = [0.0] 
+        
+        ref_info = loader.get_frame_info(seq_name, ref_fid)
+        R_ref = ref_info['R']
+        T_ref = ref_info['T']
+        
+        current_idx = start_idx
+        success = True
+        
+        # 记录旋转方向: 1 (正向), -1 (负向), 0 (未定)
+        rotation_direction = 0 
+        
+        # 寻找后续 4 帧
+        for step in range(4):
+            found_next = False
+            
+            for next_idx in range(current_idx + 1, n):
+                next_fid = frame_ids[next_idx]
+                next_info = loader.get_frame_info(seq_name, next_fid)
+                
+                R_next = next_info['R']
+                T_next = next_info['T']
+                
+                rel_yaw = get_relative_yaw(R_ref, R_next)
+                
+                # 约束 1: 总跨度 < 180
+                if abs(rel_yaw) >= 180:
+                    # 超过 180 度，停止搜索当前路径
+                    found_next = False
+                    break 
+                
+                prev_yaw = selected_yaws[-1]
+                
+                # [核心逻辑修改] 强制单调性
+                
+                # 情况 A: 寻找第一个候选帧 (确定方向)
+                if step == 0:
+                    if abs(rel_yaw) >= min_yaw_interval:
+                        # 确定方向
+                        rotation_direction = 1 if rel_yaw > 0 else -1
+                        
+                        selected_fids.append(next_fid)
+                        selected_yaws.append(rel_yaw)
+                        current_idx = next_idx
+                        found_next = True
+                        break
+                
+                # 情况 B: 寻找后续帧 (必须遵循方向)
+                else:
+                    # 计算增量
+                    diff = rel_yaw - prev_yaw
+                    
+                    # 如果方向是正，增量必须是正且足够大
+                    if rotation_direction == 1:
+                        if diff >= min_yaw_interval:
+                            selected_fids.append(next_fid)
+                            selected_yaws.append(rel_yaw)
+                            current_idx = next_idx
+                            found_next = True
+                            break
+                    
+                    # 如果方向是负，增量必须是负且足够小 (绝对值足够大)
+                    elif rotation_direction == -1:
+                        if diff <= -min_yaw_interval:
+                            selected_fids.append(next_fid)
+                            selected_yaws.append(rel_yaw)
+                            current_idx = next_idx
+                            found_next = True
+                            break
+            
+            if not found_next:
+                success = False
+                break
+        
+        if success and len(selected_fids) == 5:
+            return selected_fids, selected_yaws
+    return None, None
+
+def process_category(category, all_data_list):
+    print(f"Processing category: {category}...")
+    loader = CO3DDataLoader(ROOT_PATH, category)
+    sequences = loader.get_sequences()
+    
+    for seq_name in sequences:
+        frame_ids = sorted(loader.get_frames(seq_name))
+        
+        attempts = 0
+        generated_count = 0
+        
+        while generated_count < SAMPLES_PER_SEQ and attempts < SAMPLES_PER_SEQ * 5:
+            attempts += 1
+            
+            # 1. 基于 Yaw 采样
+            selected_fids, selected_yaws = sample_frames_by_yaw(loader, seq_name, frame_ids, MIN_YAW_INTERVAL)
+            
+            if selected_fids is None:
+                # 如果这个序列很难找到满足条件的帧，就跳过，避免死循环
+                break
+            
+            ref_fid = selected_fids[0]
+            cand_fids = selected_fids[1:] # 4个候选帧 ID
+            
+            # selected_yaws[0] 是 0 (Ref), selected_yaws[1:] 是 candidates 相对 Ref 的 Yaw
+            cand_yaws = selected_yaws[1:]
+            
+            # --- 数据构建 ---
+            
+            # 准备图片路径
+            ref_info = loader.get_frame_info(seq_name, ref_fid)
+            cand_infos = [loader.get_frame_info(seq_name, fid) for fid in cand_fids]
+            
+            ref_path = format_image_path(ref_info['path'], ROOT_PATH, IMAGE_PREFIX)
+            cand_paths_sorted = [format_image_path(info['path'], ROOT_PATH, IMAGE_PREFIX) for info in cand_infos]
+            
+            # 2. 打乱候选图片顺序
+            # 创建 (Path, Rank, Yaw) 的列表
+            # Rank 1~4 代表真实时间顺序
+            cands_data = []
+            for rank, (path, yaw) in enumerate(zip(cand_paths_sorted, cand_yaws), 1):
+                cands_data.append({
+                    'path': path, 
+                    'rank': rank,
+                    'yaw': yaw
+                })
+            
+            random.shuffle(cands_data)
+            
+            # 计算正确答案序列
+            # cands_data 现在的索引 0,1,2,3 对应题目中的 Label 1,2,3,4
+            correct_sequence = []
+            for r in range(1, 5):
+                for label_idx, item in enumerate(cands_data):
+                    if item['rank'] == r:
+                        correct_sequence.append(label_idx + 1) 
+                        break
+            
+            # 3. 生成选项
+            options_map, correct_choice = generate_options(correct_sequence)
+            
+            # 4. 填充模板
+            template = random.choice(TEMPLATES)
+            
+            # 仅替换选项占位符，图片占位符保持原样 [image_ref], [image_1]...
+            text = template
+            for key, val in options_map.items():
+                text = text.replace(f"[{key}]", val)
+            
+            # 5. 构建 images 字典
+            images_dict = {
+                "ref": ref_path,
+                "candidate_1": cands_data[0]['path'],
+                "candidate_2": cands_data[1]['path'],
+                "candidate_3": cands_data[2]['path'],
+                "candidate_4": cands_data[3]['path']
+            }
+
+            # 6. 构建最终数据项
+            data_item = {
+                "id": f"task3_{seq_name}_{ref_fid}_ordering",
+                "task": "camera_view_ordering",
+                "sequence": seq_name,
+                "category": category,
+                "question": text,
+                "images": images_dict,
+                "metadata": {
+                    "ref_frame": ref_fid,
+                    "candidate_frames_sorted": cand_fids,
+                    "shuffled_indices": [item['rank'] for item in cands_data], # 1,2,3,4 的排列
+                    "yaws_relative_to_ref": {
+                        "ref": 0.0,
+                        # 记录排序后的真实 Yaw，方便分析
+                        "sorted_candidates": cand_yaws,
+                        # 记录打乱后对应 Label 1-4 的 Yaw
+                        "shuffled_candidates": [item['yaw'] for item in cands_data]
+                    },
+                    "min_yaw_interval": MIN_YAW_INTERVAL,
+                    "correct_sequence_str": options_map[f"sequence_{correct_choice}"]
+                },
+                "gt_answer": correct_choice
+            }
+            
+            all_data_list.append(data_item)
+            generated_count += 1
+
+def main():
+    all_data = []
+    
+    if not os.path.exists(ROOT_PATH):
+        print(f"Error: ROOT_PATH {ROOT_PATH} does not exist.")
+        return
 
+    for cat in CATEGORIES:
+        process_category(cat, all_data)
+        
+    print(f"Total samples generated: {len(all_data)}")
+    
+    if len(all_data) > 0:
+        save_jsonl_splits(all_data, OUTPUT_DIR)
+        print(f"Data saved to {OUTPUT_DIR}")
+    else:
+        print("No data generated. Check paths and categories.")
 
-"""
+if __name__ == "__main__":
+    main()

src/action_state/gen_task4.py

@@ -13,9 +13,9 @@
 
 
 1.
-The object in the initial view <image_start>[image_1]<image_end> remains **static**, with a specific point marked as **A**.
+The {object} in the initial view <image_start>[image_1]<image_end> remains **static**, with a specific point marked as **A**.
 
-Imagine a camera rotating around this object to a new position. The final view captured from this new angle is shown below, with four candidate points marked as **1, 2, 3 and 4**.
+Imagine a camera rotating around this {object} to a new position. The final view captured from this new angle is shown below, with four candidate points marked as **1, 2, 3 and 4**.
 
 Based on the visual features and geometry, which of the numbered points in the final view corresponds to the **same physical location** as point **A** in the inital view?
 

src/action_state/utils.py

@@ -2,21 +2,79 @@ import json
 import os
 import math
 import numpy as np
-from scipy.spatial.transform import Rotation as SciRotation
-
 # --- 1. 几何计算工具 ---
-
-def get_relative_yaw(R1, R2):
+def get_camera_center(R, T):
+    """计算相机中心: C = -R^T * T"""
+    return -R.T @ T
+def get_view_direction(R):
     """
-    计算 R2 相对于 R1 的水平旋转角 (Yaw, Degree)。
-    正值通常代表顺时针（取决于坐标系定义，需保持一致）。
+    获取相机光轴方向。
+    PyTorch3D 约定: x_cam = x_world @ R + T
+    这意味着 R 的第 3 行 (index 2) 是相机 Z 轴在世界系下的方向。
     """
-    # R_rel = R2 @ R1.T
-    R_rel = R2 @ R1.T
-    r = SciRotation.from_matrix(R_rel)
-    # 提取 Euler 角，顺序 xyz，取 y 分量
-    euler_angles = r.as_euler('xyz', degrees=True) 
-    return euler_angles[1]
+    return R[2, :]
+def get_relative_yaw(R_ref, R_curr):
+    """
+    计算相对 Yaw 角度。
+    
+    【重大修正 - 基于 Issue #64】
+    CO3D 的世界坐标系 Up 向量并不是 (0, 1, 0)，而是倾向于 (-0.04, -0.83, -0.55)。
+    直接投影到 XZ 平面会导致巨大的误差。
+    
+    本函数执行以下步骤：
+    1. 提取两帧的光轴向量。
+    2. 定义 CO3D 的平均 Up 向量。
+    3. 将光轴向量投影到垂直于 Up 向量的平面上（即真实的水平面）。
+    4. 计算投影向量之间的夹角。
+    """
+    
+    # 1. 获取光轴
+    v_ref = get_view_direction(R_ref)
+    v_curr = get_view_direction(R_curr)
+    
+    # 2. 定义 Up 向量 (来自 CO3D Issue #64 官方提供的经验值)
+    # 这是一个在 CO3D v2 中普遍适用的“地面法向量”
+    # 注意：官方代码里是 from_vec=(-0.0396, -0.8306, -0.5554)
+    # 我们将其归一化作为 Up 轴
+    up_vec = np.array([-0.0396, -0.8306, -0.5554])
+    up_vec = up_vec / np.linalg.norm(up_vec)
+    
+    # 3. 投影到水平面 (Gram-Schmidt 正交化)
+    # v_flat = v - (v . up) * up
+    # 去除光轴中垂直于地面的分量
+    v_ref_flat = v_ref - np.dot(v_ref, up_vec) * up_vec
+    v_curr_flat = v_curr - np.dot(v_curr, up_vec) * up_vec
+    
+    # 4. 归一化投影向量
+    norm_ref = np.linalg.norm(v_ref_flat)
+    norm_curr = np.linalg.norm(v_curr_flat)
+    
+    if norm_ref < 1e-4 or norm_curr < 1e-4:
+        return 0.0
+        
+    v_ref_flat = v_ref_flat / norm_ref
+    v_curr_flat = v_curr_flat / norm_curr
+    
+    # 5. 计算夹角
+    # 使用点积计算角度大小: cos(theta) = a . b
+    dot_val = np.dot(v_ref_flat, v_curr_flat)
+    # 限制范围防止数值误差
+    dot_val = np.clip(dot_val, -1.0, 1.0)
+    angle_deg = np.degrees(np.arccos(dot_val))
+    
+    # 6. 确定符号 (方向)
+    # 我们需要定义旋转轴 = v_ref_flat x v_curr_flat
+    # 如果旋转轴的方向与 Up 向量同向，则为正；反之为负。
+    cross_prod = np.cross(v_ref_flat, v_curr_flat)
+    direction = np.dot(cross_prod, up_vec)
+    
+    if direction < 0:
+        angle_deg = -angle_deg
+        
+    return angle_deg
+
+
+
 
 def format_angle_direction(angle):
     """将角度数值转换为 (绝对值, 方向字符串)"""
@@ -74,27 +132,48 @@ class CO3DDataLoader:
     def __init__(self, root_path, category):
         self.root_path = root_path
         self.category = category
-        self.seq_data = {} # {sequence_name: {frame_idx: {'R': ..., 'path': ...}}}
+        self.seq_data = {} # {sequence_name: {frame_idx: {'R': ..., 'T': ..., 'path': ...}}}
         
         self._load_data()
 
     def _load_data(self):
-        json_path = os.path.join(self.root_path, 'data', 'original', self.category, 'frame_annotations.json')
+        # 1. 确定该类别的基础路径
+        cat_dir = os.path.join(self.root_path, 'data', 'original', self.category)
+        json_path = os.path.join(cat_dir, 'frame_annotations.json')
+        
         if not os.path.exists(json_path):
-            print(f"Warning: {json_path} not found.")
+            print(f"Warning: Annotation file {json_path} not found.")
             return
-
+        
+        # 2. 获取磁盘上实际存在的序列列表
+        if not os.path.exists(cat_dir):
+            print(f"Warning: Category directory {cat_dir} not found.")
+            return
+            
+        valid_sequences = set()
+        for d in os.listdir(cat_dir):
+            d_path = os.path.join(cat_dir, d)
+            if os.path.isdir(d_path): 
+                valid_sequences.add(d)
+                
+        # 3. 加载 JSON 并过滤
         with open(json_path, 'r') as f:
             annotations = json.load(f)
 
         for item in annotations:
             seq = item['sequence_name']
+            
+            if seq not in valid_sequences:
+                continue
+            
             fid = item['frame_number']
             if seq not in self.seq_data:
                 self.seq_data[seq] = {}
             
+            # [修改] 同时加载 R 和 T
             self.seq_data[seq][fid] = {
                 'R': np.array(item['viewpoint']['R']),
+                'T': np.array(item['viewpoint']['T']), 
                 'path': item['image']['path']
             }
 
@@ -111,7 +190,7 @@ class CO3DDataLoader:
         return list(self.seq_data[sequence_name].keys())
 
     def get_frame_info(self, sequence_name, frame_idx):
-        """获取特定帧的 R 和 Path"""
+        """获取特定帧的 R, T 和 Path"""
         return self.seq_data[sequence_name].get(frame_idx)
 
 # --- 4. 结果保存工具 ---