| """Build twelve NeoVerse-style camera controls for every DynPose scene. |
| |
| Each source keeps its original variable frame count. The relative trajectory |
| is sampled over that count and composed frame-wise with the observed ViPE |
| OpenCV c2w trajectory: |
| |
| target_c2w[t] = source_c2w[t] @ relative_c2w[t] |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from copy import deepcopy |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| from scipy.spatial.transform import Rotation, Slerp |
|
|
|
|
| ROOT = Path(__file__).resolve().parent |
| CONTROL_SPECS: dict[str, dict[str, float]] = { |
| "pan_left": {"angle": 15.0}, |
| "pan_right": {"angle": 15.0}, |
| "tilt_up": {"angle": 15.0}, |
| "tilt_down": {"angle": 15.0}, |
| "move_left": {"distance": 0.1}, |
| "move_right": {"distance": 0.1}, |
| "push_in": {"distance": 0.1}, |
| "pull_out": {"distance": 0.1}, |
| "boom_up": {"distance": 0.1}, |
| "boom_down": {"distance": 0.1}, |
| "orbit_left": {"angle": 15.0, "orbit_radius": 1.0}, |
| "orbit_right": {"angle": 15.0, "orbit_radius": 1.0}, |
| } |
| COMPOSITION = "target_c2w[t] = source_c2w[t] @ relative_c2w[t]" |
| PROVENANCE = ( |
| "NeoVerse CameraTrajectory.from_predefined defaults and dynamic-scene " |
| "relative composition" |
| ) |
|
|
|
|
| def relative_endpoint(name: str, params: dict[str, float]) -> np.ndarray: |
| """Match NeoVerse CameraTrajectory._get_camera_matrix exactly.""" |
| angle = np.deg2rad(params.get("angle", 30.0)) |
| radius = params.get("orbit_radius", 0.5) |
| pose = np.eye(4, dtype=np.float64) |
| if name == "move_left": |
| pose[0, 3] = -params["distance"] |
| elif name == "move_right": |
| pose[0, 3] = params["distance"] |
| elif name == "push_in": |
| pose[2, 3] = params["distance"] |
| elif name == "pull_out": |
| pose[2, 3] = -params["distance"] |
| elif name == "boom_up": |
| pose[1, 3] = -params["distance"] |
| elif name == "boom_down": |
| pose[1, 3] = params["distance"] |
| elif name in {"orbit_left", "orbit_right"}: |
| theta = -angle if name == "orbit_left" else angle |
| cosine, sine = np.cos(theta), np.sin(theta) |
| pose[0, 3] = radius * sine |
| pose[2, 3] = radius * (1.0 - cosine) |
| pose[0, 0] = cosine |
| pose[0, 2] = -sine |
| pose[2, 0] = sine |
| pose[2, 2] = cosine |
| elif name in {"pan_left", "pan_right"}: |
| theta = -angle if name == "pan_left" else angle |
| cosine, sine = np.cos(theta), np.sin(theta) |
| pose[0, 0] = cosine |
| pose[0, 2] = sine |
| pose[2, 0] = -sine |
| pose[2, 2] = cosine |
| elif name in {"tilt_up", "tilt_down"}: |
| theta = angle if name == "tilt_up" else -angle |
| cosine, sine = np.cos(theta), np.sin(theta) |
| pose[1, 1] = cosine |
| pose[1, 2] = -sine |
| pose[2, 1] = sine |
| pose[2, 2] = cosine |
| else: |
| raise ValueError(f"unsupported control: {name}") |
| return pose |
|
|
|
|
| def relative_trajectory(name: str, params: dict[str, float], num_frames: int) -> np.ndarray: |
| endpoint = relative_endpoint(name, params) |
| frame_times = np.linspace(0.0, 1.0, num_frames) |
| rotations = Slerp( |
| [0.0, 1.0], |
| Rotation.from_matrix(np.stack([np.eye(3), endpoint[:3, :3]])), |
| )(frame_times).as_matrix() |
| positions = frame_times[:, None] * endpoint[:3, 3][None] |
| output = np.repeat(np.eye(4, dtype=np.float64)[None], num_frames, axis=0) |
| output[:, :3, :3] = rotations |
| output[:, :3, 3] = positions |
| return output |
|
|
|
|
| def trajectory_template(name: str, params: dict[str, float]) -> dict[str, Any]: |
| json_params = { |
| key: int(value) if float(value).is_integer() else value |
| for key, value in params.items() |
| } |
| return { |
| "name": name, |
| "description": f"NeoVerse predefined {name} control for variable-length DynPose clips", |
| "mode": "relative", |
| "num_frames_rule": "match_source_num_frames", |
| "zoom_ratio": 1.0, |
| "use_first_frame": True, |
| "composition": COMPOSITION, |
| "interpolation": {"rotation": "Slerp", "translation": "linear"}, |
| "normalized_keyframes": [ |
| {"time": 0.0, "operations": [{"static": {}}]}, |
| {"time": 1.0, "operations": [{name: json_params}]}, |
| ], |
| } |
|
|
|
|
| def source_records(manifest: dict[str, Any]) -> list[dict[str, Any]]: |
| records: dict[str, dict[str, Any]] = {} |
| for case in manifest["cases"]: |
| scene = case["scene"] |
| if scene in records: |
| continue |
| base = deepcopy(case) |
| base["case_id"] = scene |
| base["traj"] = None |
| base["target_path"] = None |
| base["camera_control"] = None |
| base["pair_id"] = None |
| metadata = deepcopy(base.get("metadata", {})) |
| metadata.pop("camera_control_provenance", None) |
| base["metadata"] = metadata |
| records[scene] = base |
| return [records[key] for key in sorted(records)] |
|
|
|
|
| def control_document(source: dict[str, Any], relative: np.ndarray) -> dict[str, Any]: |
| frames = source["frames"] |
| num_frames = len(frames) |
| if len(relative) != num_frames: |
| raise ValueError("source and relative trajectory lengths differ") |
| source_c2w = np.asarray([frame["c2w"] for frame in frames], dtype=np.float64) |
| target_c2w = source_c2w @ relative |
| return { |
| "format_version": source["format_version"], |
| "camera_model": source["camera_model"], |
| "pose_type": source["pose_type"], |
| "coordinate_system": source["coordinate_system"], |
| "image_hw": source["image_hw"], |
| "num_frames": num_frames, |
| "frames": [ |
| { |
| "frame_index": index, |
| "c2w": target_c2w[index].tolist(), |
| "intrinsics": deepcopy(frames[index]["intrinsics"]), |
| } |
| for index in range(num_frames) |
| ], |
| } |
|
|
|
|
| def controlled_case(base: dict[str, Any], name: str, params: dict[str, float]) -> dict[str, Any]: |
| scene = base["scene"] |
| case = deepcopy(base) |
| case["case_id"] = f"{scene}__{name}" |
| case["traj"] = name |
| case["target_path"] = None |
| case["camera_control"] = { |
| "path": f"camera_controls/{scene}/{name}/transforms.json", |
| "variant": "default", |
| } |
| case["pair_id"] = None |
| case["metadata"]["camera_control_provenance"] = { |
| "source": PROVENANCE, |
| "spec_path": f"trajectory_specs/{name}.json", |
| "mode": "relative", |
| "composition": COMPOSITION, |
| "num_frames": base["num_frames"], |
| "angle_degrees": params.get("angle"), |
| "distance": params.get("distance"), |
| "distance_unit": "source_reconstruction_unit" if "distance" in params else None, |
| "orbit_radius": params.get("orbit_radius"), |
| "orbit_radius_unit": "source_reconstruction_unit" if "orbit_radius" in params else None, |
| } |
| return case |
|
|
|
|
| def update_manifest(manifest: dict[str, Any], bases: list[dict[str, Any]]) -> dict[str, Any]: |
| output = deepcopy(manifest) |
| cases = [ |
| controlled_case(base, name, params) |
| for base in bases |
| for name, params in CONTROL_SPECS.items() |
| ] |
| total_source_frames = sum(base["num_frames"] for base in bases) |
| output["protocol"]["control"] = "camera" |
| output["camera"].update({ |
| "default_control_variant": "default", |
| "synthetic_control_mode": "relative", |
| "synthetic_control_composition": COMPOSITION, |
| }) |
| output["extensions"]["camera_trajectory_specs"] = { |
| "path": "trajectory_specs/<trajectory_id>.json", |
| "meaning": "NeoVerse predefined relative endpoint template sampled to each source length", |
| "source": PROVENANCE, |
| } |
| output["statistics"] = { |
| "num_scenes": len(bases), |
| "num_cases": len(cases), |
| "num_source_frames": total_source_frames, |
| "num_camera_control_cases": len(cases), |
| "num_camera_control_frames": total_source_frames * len(CONTROL_SPECS), |
| "camera_control_trajectory_distribution": { |
| name: len(bases) for name in CONTROL_SPECS |
| }, |
| "num_pairs": 0, |
| "num_unpaired_cases": len(cases), |
| } |
| output["pairing"].update({ |
| "scene_identity": "Each DynPose source scene is paired only with synthetic camera controls, not target RGB.", |
| "temporal_alignment": "control frame index matches the observed source frame index", |
| "pairs": [], |
| "unpaired_sources": [ |
| { |
| "case_id": case["case_id"], |
| "source_scene_id": case["scene"], |
| "source_path": case["source_path"], |
| "num_frames": case["num_frames"], |
| "reason": "synthetic_camera_control_only_no_target_rgb", |
| } |
| for case in cases |
| ], |
| }) |
| output["cases"] = cases |
| return output |
|
|
|
|
| def validate(root: Path) -> dict[str, Any]: |
| manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8")) |
| errors: list[str] = [] |
| max_first_error = 0.0 |
| max_composition_error = 0.0 |
| max_orthonormal_error = 0.0 |
| max_determinant_error = 0.0 |
| relative_cache: dict[tuple[str, int], np.ndarray] = {} |
| case_ids = [case["case_id"] for case in manifest["cases"]] |
| control_paths = [case["camera_control"]["path"] for case in manifest["cases"]] |
| if len(case_ids) != len(set(case_ids)): |
| errors.append("duplicate case_id") |
| if len(control_paths) != len(set(control_paths)): |
| errors.append("duplicate camera control path") |
| for case in manifest["cases"]: |
| control_path = root / case["camera_control"]["path"] |
| source_path = root / case["source_path"] / "transforms.json" |
| if not control_path.is_file(): |
| errors.append(f"missing {control_path.relative_to(root)}") |
| continue |
| control = json.loads(control_path.read_text(encoding="utf-8")) |
| source = json.loads(source_path.read_text(encoding="utf-8")) |
| num_frames = case["num_frames"] |
| if len(control["frames"]) != num_frames or len(source["frames"]) != num_frames: |
| errors.append(f"{case['case_id']}: wrong frame count") |
| continue |
| key = (case["traj"], num_frames) |
| if key not in relative_cache: |
| relative_cache[key] = relative_trajectory( |
| case["traj"], CONTROL_SPECS[case["traj"]], num_frames |
| ) |
| relative = relative_cache[key] |
| control_c2w = np.asarray([frame["c2w"] for frame in control["frames"]]) |
| source_c2w = np.asarray([frame["c2w"] for frame in source["frames"]]) |
| max_first_error = max(max_first_error, float(np.max(np.abs(control_c2w[0] - source_c2w[0])))) |
| expected_c2w = source_c2w @ relative |
| max_composition_error = max( |
| max_composition_error, float(np.max(np.abs(control_c2w - expected_c2w))) |
| ) |
| rotations = control_c2w[:, :3, :3] |
| max_orthonormal_error = max( |
| max_orthonormal_error, |
| float(np.max(np.abs(rotations @ np.swapaxes(rotations, 1, 2) - np.eye(3)[None]))), |
| ) |
| max_determinant_error = max( |
| max_determinant_error, |
| float(np.max(np.abs(np.linalg.det(rotations) - 1.0))), |
| ) |
| if not np.isfinite(control_c2w).all(): |
| errors.append(f"{case['case_id']}: non-finite pose") |
| if [frame["frame_index"] for frame in control["frames"]] != list(range(num_frames)): |
| errors.append(f"{case['case_id']}: invalid frame indexes") |
| if [frame["intrinsics"] for frame in control["frames"]] != [ |
| frame["intrinsics"] for frame in source["frames"] |
| ]: |
| errors.append(f"{case['case_id']}: intrinsics differ from source") |
| statistics = manifest.get("statistics", {}) |
| if len(manifest["cases"]) != len(CONTROL_SPECS) * statistics.get("num_scenes", 0): |
| errors.append("manifest case count does not match scene × trajectory count") |
| if max_first_error > 1e-9: |
| errors.append(f"first-frame mismatch: {max_first_error}") |
| if max_composition_error > 1e-9: |
| errors.append(f"composition mismatch: {max_composition_error}") |
| if max_orthonormal_error > 1e-6: |
| errors.append(f"rotation orthonormal error: {max_orthonormal_error}") |
| if max_determinant_error > 1e-6: |
| errors.append(f"rotation determinant error: {max_determinant_error}") |
| if errors: |
| raise RuntimeError("\n".join(errors[:20])) |
| return { |
| "scenes": statistics["num_scenes"], |
| "cases": len(manifest["cases"]), |
| "trajectories": list(CONTROL_SPECS), |
| "camera_control_frames": statistics["num_camera_control_frames"], |
| "min_frames": min(case["num_frames"] for case in manifest["cases"]), |
| "max_frames": max(case["num_frames"] for case in manifest["cases"]), |
| "max_first_frame_pose_error": max_first_error, |
| "max_composition_error": max_composition_error, |
| "max_rotation_orthonormal_error": max_orthonormal_error, |
| "max_rotation_determinant_error": max_determinant_error, |
| } |
|
|
|
|
| def build(root: Path) -> dict[str, Any]: |
| manifest_path = root / "manifest.json" |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
| bases = source_records(manifest) |
| if len(bases) != 377: |
| raise ValueError(f"expected 377 DynPose scenes, found {len(bases)}") |
| spec_root = root / "trajectory_specs" |
| spec_root.mkdir(parents=True, exist_ok=True) |
| for name, params in CONTROL_SPECS.items(): |
| (spec_root / f"{name}.json").write_text( |
| json.dumps(trajectory_template(name, params), indent=2) + "\n", |
| encoding="utf-8", |
| ) |
| relative_cache: dict[tuple[str, int], np.ndarray] = {} |
| for base in bases: |
| scene = base["scene"] |
| source_path = root / base["source_path"] / "transforms.json" |
| source = json.loads(source_path.read_text(encoding="utf-8")) |
| num_frames = len(source["frames"]) |
| if num_frames != base["num_frames"]: |
| raise ValueError(f"{scene}: manifest/source frame count mismatch") |
| for name, params in CONTROL_SPECS.items(): |
| key = (name, num_frames) |
| if key not in relative_cache: |
| relative_cache[key] = relative_trajectory(name, params, num_frames) |
| relative = relative_cache[key] |
| output_path = root / "camera_controls" / scene / name / "transforms.json" |
| output_path.parent.mkdir(parents=True, exist_ok=True) |
| output_path.write_text( |
| json.dumps(control_document(source, relative), indent=2) + "\n", |
| encoding="utf-8", |
| ) |
| manifest_temp = manifest_path.with_suffix(".json.tmp") |
| manifest_temp.write_text( |
| json.dumps(update_manifest(manifest, bases), indent=2, ensure_ascii=False) + "\n", |
| encoding="utf-8", |
| ) |
| manifest_temp.replace(manifest_path) |
| return validate(root) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--root", type=Path, default=ROOT) |
| parser.add_argument("--check", action="store_true") |
| args = parser.parse_args() |
| result = validate(args.root) if args.check else build(args.root) |
| print(json.dumps(result, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
