""" **任务名称：** 围绕静止物体的相机视角排序（Camera View Ordering around Static Objects） **任务设定：** 本任务模拟一个静止物体被移动相机拍摄的场景。相机围绕物体进行平滑的轨道旋转（Orbital Rotation）。 1. **数据来源：** 所有图像均从一段连续的视频中抽帧获得，因此具备内在的时空连贯性。 2. **运动约束：** 从给定的初始参考帧（Reference Frame）到序列的最后一帧，相机的总旋转角度严格限制在半个圆周（<180度）以内，保证视角的单向性和连续性。 **输入数据：** * 一张**初始参考图（Reference Image）**，作为序列的起点（t=0）。 * 四张**候选图片（Candidate Images）**，编号为 1、2、3、4。这四张图片是参考图之后的后续帧，但顺序已被打乱。 **任务目标：** 模型需要分析参考图与候选图片之间的几何关系，将四张候选图片按照真实的时间/空间顺序重新排列，使其构成一个连贯的相机运动轨迹。 **输出格式：** 提供 A、B、C、D 四个选项，每个选项代表一种排序组合（例如 B: 2-1-4-3）。模型需选择能够恢复正确时空顺序的选项。 """ import argparse import random import itertools import json import os from tqdm import tqdm import numpy as np # 导入公共工具库 from utils import ( CO3DDataLoader, get_relative_yaw, format_image_path, save_jsonl_splits, get_sequence_geometry_pca, decompose_angle, ) class Task3Generator: def __init__(self, loader, image_prefix): self.loader = loader self.image_prefix = image_prefix self.cat_name = self.loader.category.replace('_', ' ') def _get_all_relative_angles(self, start_idx, all_frames, seq_data_dict, mean_center, basis): """ 计算序列中所有帧相对于 start_idx 的角度。 Args: start_idx: 起始帧索引 all_frames: 所有帧索引列表 seq_data_dict: 对齐后的序列数据 {frame_idx: {'R': ..., 'T': ..., 'path': ...}} mean_center: 场景中心 basis: 基底矩阵 Returns: 列表: [{'idx': frame_idx, 'angle': relative_angle}, ...] """ start_info = seq_data_dict[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 = seq_data_dict[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 generate_sample(self, seq_name, config): # 获取该序列所有帧并排序 frames = sorted(self.loader.get_frames(seq_name)) if len(frames) < 10: # 稍微提高一点门槛，太短的序列很难凑齐5张符合间隔的图 return None # 获取几何信息（现在返回三个值） seq_data_dict = self.loader.seq_data[seq_name] mean_center, basis, _ = get_sequence_geometry_pca(seq_data_dict) min_int = config['min_interval'] max_int = config['max_interval'] max_span = config['max_angle'] max_attempts = 5000 # 尝试寻找起点的次数 for _ in range(max_attempts): # 1. 随机选择一个起点 (Reference Frame) # 留出后面至少4帧的空间，虽然不一定连续，但索引得靠前 start_idx = random.choice(frames[:-4]) # 2. 计算所有后续帧相对于起点的角度（使用对齐后的数据） rel_data = self._get_all_relative_angles( start_idx, frames, seq_data_dict, mean_center, basis ) # 过滤掉 start 之前的帧 future_candidates = [x for x in rel_data if x['idx'] > start_idx] # 3. 逐步构建链条 (Chain Building) # 我们需要找到 [Ref, C1, C2, C3, C4] # 使得 abs(Angle(Ci) - Angle(Ci-1)) 在 [min_int, max_int] 之间 chain = [{'idx': start_idx, 'angle': 0.0}] for step in range(4): # 需要找 4 个后续帧 last_item = chain[-1] last_angle = last_item['angle'] valid_next_frames = [] for cand in future_candidates: # 必须保持时间顺序 (index 递增) if cand['idx'] <= last_item['idx']: continue # 计算与上一帧的间隔 diff = abs(cand['angle'] - last_angle) # 核心约束检查： # 1. 间隔在 [min, max] 之间 # 2. 总跨度不超过 max_span (相对于 Ref 的 0 度) # 3. 单调性检查: 新的角度绝对值 必须 大于 旧的角度绝对值 (确保是越转越远，而不是转回来了) if (min_int <= diff <= max_int) and \ (abs(cand['angle']) <= max_span) and \ (abs(cand['angle']) > abs(last_angle)): valid_next_frames.append(cand) if not valid_next_frames: break # 链条断了，当前 start_idx 无法构成序列 # 随机选一个符合条件的下一帧 next_frame = random.choice(valid_next_frames) chain.append(next_frame) # 4. 检查是否成功找到了 5 帧 (Ref + 4 Candidates) if len(chain) == 5: # 提取索引和角度 indices = [x['idx'] for x in chain] angles = [x['angle'] for x in chain] return self.create_entry(seq_name, indices, angles, rel_data) return None def create_entry(self, seq_name, frame_indices, angles, all_rel_data): """ Args: frame_indices: [Ref, True_1, True_2, True_3, True_4] angles: [0, Ang1, Ang2, Ang3, Ang4] (相对于 Ref) all_rel_data: [{'idx':..., 'angle':...}, ...] 序列中所有帧的角度信息 """ # ================= 配置区域 ================= ROTATION_STEPS = [15, 10] # 优先使用 15度，补齐用 10度 # =========================================== ref_idx = frame_indices[0] true_candidates_indices = frame_indices[1:] ref_info = self.loader.get_frame_info(seq_name, ref_idx) candidates_infos = [self.loader.get_frame_info(seq_name, idx) for idx in true_candidates_indices] # 1. 准备候选图片数据 (用于最终选项) labeled_candidates = [] for i, info in enumerate(candidates_infos): labeled_candidates.append({ "true_order": i + 1, "path": format_image_path(info['path'], self.loader.root_path, self.image_prefix), "angle_rel_ref": angles[i+1] }) # 打乱顺序 shuffled_candidates = labeled_candidates.copy() random.shuffle(shuffled_candidates) # 初始化 images 字典 images_dict = { "image_ref": format_image_path(ref_info['path'], self.loader.root_path, self.image_prefix) } display_mapping = {} candidates_meta = {} for k, item in enumerate(shuffled_candidates): display_label = k + 1 images_dict[f"image_{display_label}"] = item['path'] display_mapping[display_label] = item['true_order'] # <--- [新增] 记录该 Display Image 的详细元数据 candidates_meta[str(display_label)] = { "angle_relative_to_ref": item['angle_rel_ref'], "true_rank": item['true_order'], "image_key": f"image_{display_label}" } # 2. 生成选项文本 (A/B/C/D) true_to_display = {v: k for k, v in display_mapping.items()} correct_sequence = [true_to_display[i] for i in range(1, 5)] correct_str = "-".join(map(str, correct_sequence)) all_permutations = list(itertools.permutations([1, 2, 3, 4])) distractor_pool = [ "-".join(map(str, p)) for p in all_permutations if list(p) != correct_sequence ] selected_distractors = random.sample(distractor_pool, 3) options_data = [{"seq": correct_str, "is_correct": True}] for d in selected_distractors: options_data.append({"seq": d, "is_correct": False}) random.shuffle(options_data) option_labels = ['A', 'B', 'C', 'D'] gt_option_label = "" sequence_options_text = {} for label, opt in zip(option_labels, options_data): sequence_options_text[f"sequence_{label}"] = opt["seq"] if opt["is_correct"]: gt_option_label = label # ------------------------------------------------------------------ # 3. 构建 Oracle Meta 和 Chain (替代原本的文本生成) # ------------------------------------------------------------------ is_clockwise = angles[-1] < 0 direction_str = "clockwise" if is_clockwise else "counter-clockwise" chain = [] images_dict_update = {} # 用于存储推理过程中的中间图 current_simulated_angle = 0.0 prev_target_angle = 0.0 reasoning_img_counter = 0 # 遍历 4 个目标阶段 (Ref -> C1, C1 -> C2, ...) # frame_indices[0] 是 Ref, frame_indices[1:] 是 C1, C2, C3, C4 for i in range(1, 5): target_angle = angles[i] true_delta = abs(target_angle - prev_target_angle) # 拆解步长为 [30, 15] steps = decompose_angle(true_delta, [30, 15]) matched_display_label = true_to_display[i] # 获取当前真实第i张图对应用户看到的 Label (1-4) for step_idx, step_deg in enumerate(steps): reasoning_img_counter += 1 # 1. 更新模拟角度 if is_clockwise: current_simulated_angle -= step_deg else: current_simulated_angle += step_deg # 2. 寻找最接近该角度的真实帧 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) # 3. 【关键修改】始终生成 reasoning_image # 不管是不是最后一步，都把当前视角的图存下来 result_key = f"reasoning_image_{reasoning_img_counter}" images_dict_update[result_key] = format_image_path( closest_frame_info['path'], self.loader.root_path, self.image_prefix ) # 4. 判断是否到达匹配点 is_last_step_of_phase = (step_idx == len(steps) - 1) # 4. 构建 Chain Item chain_item = { "step_index": len(chain) + 1, "action": { "type": "rotate", "degrees": step_deg, "direction": direction_str, "total_angle_so_far": current_simulated_angle }, "result_image_key": result_key, "is_key_frame": is_last_step_of_phase, "matched_display_label": matched_display_label if is_last_step_of_phase else None } chain.append(chain_item) prev_target_angle = target_angle # 合并图片字典 images_dict.update(images_dict_update) # ------------------------------------------------------------------ # 4. 生成 Question Prompt (保持不变) # ------------------------------------------------------------------ template_id = random.choice([1, 2]) obj_name = self.cat_name if template_id == 1: question = f"""The {obj_name} in the initial view [image_ref] remains **static**. Imagine a camera rotating around this {obj_name} 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. 1. [image_1] 2. [image_2] 3. [image_3] 4. [image_4] Please analyze the change in perspective and determine the correct chronological order of these four images following the initial view. Select the correct sequence. A. {sequence_options_text['sequence_A']} B. {sequence_options_text['sequence_B']} C. {sequence_options_text['sequence_C']} D. {sequence_options_text['sequence_D']}""" else: question = f"""Given the initial view of the **static** {obj_name}: [image_ref]. Imagine a camera rotating around this {obj_name} to capture a video sequence. The rotation covers an angle of less than 180 degrees. We have extracted four frames from the sequence, labeled 1 to 4, but their order is jumbled. 1. [image_1] 2. [image_2] 3. [image_3] 4. [image_4] Which of the following four options correctly sorts these images into a coherent spatio-temporal sequence starting after the initial view? A. {sequence_options_text['sequence_A']} B. {sequence_options_text['sequence_B']} C. {sequence_options_text['sequence_C']} D. {sequence_options_text['sequence_D']}""" return { "id": f"task3_{seq_name}_{ref_idx}", "task": "camera_view_ordering", "sequence": seq_name, "category": self.loader.category, "question": question, "images": images_dict, "oracle_meta": { "direction": direction_str, "correct_sequence_str": correct_str, # e.g. "2-1-4-3" "correct_label": gt_option_label, # e.g. "B" "chain": chain, "candidates_meta": candidates_meta }, "gt_answer": f"{gt_option_label}" # 占位，后面会被 Generator 覆盖 } def main(): parser = argparse.ArgumentParser(description="Generate Task 3: Camera View Ordering") # 路径配置 parser.add_argument("--root_path", type=str, required=True, help="CO3D dataset root") parser.add_argument("--output_dir", type=str, default="output_task3", 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("--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) # 几何约束配置 # min_interval: 相邻两帧之间至少间隔多少度 parser.add_argument("--min_interval", type=float, default=15.0) # max_interval: 相邻两帧之间最大间隔多少度 (防止跨度太大) parser.add_argument("--max_interval", type=float, default=45.0) # max_angle: 整个序列(Ref -> Last)的最大跨度，必须 < 180 parser.add_argument("--max_angle", type=float, default=175.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: 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_interval': args.min_interval, 'max_interval': args.max_interval, 'max_angle': args.max_angle } for cat in categories: loader = CO3DDataLoader(args.root_path, cat) if not loader.seq_data: continue generator = Task3Generator(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) sequences = [s for s in sequences if s in keep_list] print(f"[{cat}] Filter applied: {original_count} -> {len(sequences)} sequences retained.") except Exception as e: print(f"[{cat}] Error reading keep.json: {e}. Skipping category.") sequences = [] else: print(f"[{cat}] Warning: No keep.json found at {keep_file}. Skipping category.") sequences = [] if not sequences: continue for seq in tqdm(sequences, desc=f"Task3 - {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()