Upload 2 files

import_transphy3d.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+"""Extract TransPhy3D sequences and import them into FiftyOne.
+
+Pipeline
+--------
+1. Read WebDataset tar files from the TransPhy3D test split.
+2. Extract per-frame assets to ``data/processed/{sequence_id}/``.
+3. Assemble RGB frames into ``rgb.mp4`` with ffmpeg.
+4. Create FiftyOne video samples with frame-level annotations.
+
+Processed layout per sequence::
+
+    rgb.mp4
+    depth/{frame_id:08d}.png
+    normal/{frame_id:08d}.png
+    depth_json/{frame_id:08d}.json
+    metadata/{frame_id:08d}.json
+
+FiftyOne stores depth and normals as :class:`fiftyone.core.labels.Heatmap`
+fields that reference PNG files on disk via absolute ``map_path`` values.
+
+Typical usage::
+
+    conda activate fiftyone
+    python import_transphy3d.py --overwrite
+
+For grouped video + 3D reconstruction import, run :mod:`reconstruct_scenes`
+after this script has produced processed assets.
+
+Depth decoding (also used by reconstruction)::
+
+    depth_metric = png_uint16 / 65535 * max_depth
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess
+import tarfile
+from collections import defaultdict
+from pathlib import Path
+
+import fiftyone as fo
+from tqdm import tqdm
+
+MEMBER_RE = re.compile(
+    r"^(.+?)_(\d+)\.(depth\.json|depth\.png|image\.png|metadata\.json|normal\.png)$"
+)
+
+
+def parse_member(name: str) -> tuple[str, int, str] | None:
+    """Parse a tar member name into ``(sequence_id, frame_id, extension)``."""
+    match = MEMBER_RE.match(name)
+    if not match:
+        return None
+    prefix, frame_id, ext = match.groups()
+    return prefix, int(frame_id), ext
+
+
+def scene_type(sequence_id: str) -> str:
+    """Map a sequence id to a coarse scene category label."""
+    if "table_with_robot" in sequence_id:
+        return "table_with_robot"
+    return "materials"
+
+
+def sequence_id_from_tar(tar_path: Path) -> str:
+    """Infer the sequence id prefix from the first valid tar member name."""
+    with tarfile.open(tar_path) as tf:
+        for name in tf.getnames():
+            parsed = parse_member(name)
+            if parsed is not None:
+                return parsed[0]
+    raise ValueError(f"Could not determine sequence id for {tar_path}")
+
+
+def tar_sequence_map(tar_dir: Path) -> dict[str, Path]:
+    """Map sequence ids to their source tar paths."""
+    mapping: dict[str, Path] = {}
+    for tar_path in sorted(tar_dir.glob("*.tar")):
+        mapping[sequence_id_from_tar(tar_path)] = tar_path
+    return mapping
+
+
+def load_tar_frames(tar_path: Path) -> dict[int, dict[str, bytes]]:
+    """Load all frame payloads from one WebDataset tar file."""
+    frames: dict[int, dict[str, bytes]] = defaultdict(dict)
+    with tarfile.open(tar_path) as tf:
+        for member in tf.getmembers():
+            parsed = parse_member(member.name)
+            if parsed is None:
+                continue
+            _, frame_id, ext = parsed
+            frames[frame_id][ext] = tf.extractfile(member).read()
+    return dict(frames)
+
+
+def frame_asset_paths(seq_dir: Path, frame_id: int) -> dict[str, Path]:
+    """Return absolute paths for one frame's extracted on-disk assets."""
+    stem = f"{frame_id:08d}"
+    return {
+        "depth": (seq_dir / "depth" / f"{stem}.png").resolve(),
+        "normal": (seq_dir / "normal" / f"{stem}.png").resolve(),
+        "depth_json": (seq_dir / "depth_json" / f"{stem}.json").resolve(),
+        "metadata_json": (seq_dir / "metadata" / f"{stem}.json").resolve(),
+    }
+
+
+def load_frame_calibration(paths: dict[str, Path]) -> tuple[float, dict]:
+    """Load ``max_depth`` and parsed ``metadata.json`` for one frame."""
+    depth_info = json.loads(paths["depth_json"].read_text())
+    metadata = json.loads(paths["metadata_json"].read_text())
+    return depth_info["max_depth"], metadata
+
+
+def calibration_frame_fields(
+    frame_id: int,
+    sequence_id: str,
+    max_depth: float,
+    metadata: dict,
+) -> dict:
+    """Build parsed calibration fields for one video frame."""
+    cameras = metadata["camera_matrices"]
+    return {
+        "frame_id": metadata.get("frame_id", frame_id),
+        "sequence_id": metadata.get("sequence_id", sequence_id),
+        "max_depth": max_depth,
+        "camera_extrinsics": cameras["extrinsics"],
+        "camera_intrinsics": cameras["intrinsics"],
+    }
+
+
+def frame_field_update(
+    frame_id: int,
+    sequence_id: str,
+    paths: dict[str, Path],
+    max_depth: float,
+    metadata: dict,
+) -> dict:
+    """Build the full FiftyOne frame-field payload for one video frame."""
+    return {
+        **calibration_frame_fields(frame_id, sequence_id, max_depth, metadata),
+        "depth_map": fo.Heatmap(map_path=str(paths["depth"]), range=[0, 65535]),
+        "normal_map": fo.Heatmap(map_path=str(paths["normal"])),
+    }
+
+
+def sorted_frame_ids(seq_dir: Path) -> list[int]:
+    """Return sorted frame ids inferred from extracted depth PNG filenames."""
+    return sorted(int(path.stem) for path in (seq_dir / "depth").glob("*.png"))
+
+
+def write_rgb_video(frames: dict[int, dict[str, bytes]], output_path: Path, fps: int) -> None:
+    """Assemble extracted ``image.png`` frames into an H.264 ``rgb.mp4`` file."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    frame_ids = sorted(frames)
+    temp_dir = output_path.parent / "_rgb_frames_tmp"
+    if temp_dir.exists():
+        shutil.rmtree(temp_dir)
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        for idx, frame_id in enumerate(frame_ids):
+            (temp_dir / f"frame_{idx:06d}.png").write_bytes(frames[frame_id]["image.png"])
+
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-framerate",
+                str(fps),
+                "-i",
+                str(temp_dir / "frame_%06d.png"),
+                "-c:v",
+                "libx264",
+                "-pix_fmt",
+                "yuv420p",
+                str(output_path),
+            ],
+            check=True,
+        )
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def write_frame_assets(
+    frames: dict[int, dict[str, bytes]],
+    seq_dir: Path,
+    *,
+    write_png: bool = True,
+    write_json: bool = True,
+) -> None:
+    """Write selected per-frame assets for one sequence to disk."""
+    subdirs = []
+    if write_png:
+        subdirs.extend(("depth", "normal"))
+    if write_json:
+        subdirs.extend(("depth_json", "metadata"))
+    for name in subdirs:
+        (seq_dir / name).mkdir(parents=True, exist_ok=True)
+
+    for frame_id in sorted(frames):
+        frame = frames[frame_id]
+        paths = frame_asset_paths(seq_dir, frame_id)
+        if write_png:
+            paths["depth"].write_bytes(frame["depth.png"])
+            paths["normal"].write_bytes(frame["normal.png"])
+        if write_json:
+            paths["depth_json"].write_bytes(frame["depth.json"])
+            paths["metadata_json"].write_bytes(frame["metadata.json"])
+
+
+def build_video_sample_from_disk(
+    sequence_id: str,
+    processed_root: Path,
+    source_tar: str,
+) -> fo.Sample:
+    """Build a FiftyOne video sample from already extracted processed assets."""
+    seq_dir = processed_root / sequence_id
+    video_path = (seq_dir / "rgb.mp4").resolve()
+    if not video_path.exists():
+        raise FileNotFoundError(f"Missing RGB video for sequence {sequence_id}: {video_path}")
+
+    frame_ids = sorted_frame_ids(seq_dir)
+    if not frame_ids:
+        raise ValueError(f"No extracted depth frames found for sequence {sequence_id}")
+
+    sample = fo.Sample(filepath=str(video_path))
+    sample["sequence_id"] = sequence_id
+    sample["source_tar"] = source_tar
+    sample["frame_count"] = len(frame_ids)
+    sample["scene_type"] = scene_type(sequence_id)
+    sample["tags"] = ["test"]
+
+    for frame_idx, frame_id in enumerate(frame_ids, start=1):
+        paths = frame_asset_paths(seq_dir, frame_id)
+        max_depth, metadata = load_frame_calibration(paths)
+        sample.frames[frame_idx] = fo.Frame(
+            **frame_field_update(frame_id, sequence_id, paths, max_depth, metadata)
+        )
+
+    return sample
+
+
+def build_video_sample(
+    sequence_id: str,
+    tar_path: Path,
+    processed_root: Path,
+    fps: int,
+) -> fo.Sample:
+    """Extract one tar, write processed assets, and build a FiftyOne video sample."""
+    frames = load_tar_frames(tar_path)
+    if not frames:
+        raise ValueError(f"No frames found in {tar_path}")
+
+    seq_dir = processed_root / sequence_id
+    write_frame_assets(frames, seq_dir)
+    write_rgb_video(frames, seq_dir / "rgb.mp4", fps=fps)
+    return build_video_sample_from_disk(sequence_id, processed_root, tar_path.name)
+
+
+def backfill_json_files(tar_dir: Path, processed_root: Path) -> None:
+    """Write ``depth_json/`` and ``metadata/`` files for every tar in ``tar_dir``."""
+    for sequence_id, tar_path in tqdm(tar_sequence_map(tar_dir).items(), desc="Writing JSON files"):
+        write_frame_assets(
+            load_tar_frames(tar_path),
+            processed_root / sequence_id,
+            write_png=False,
+        )
+
+
+def refresh_calibration_fields(
+    tar_dir: Path,
+    processed_root: Path,
+    dataset_name: str,
+) -> fo.Dataset:
+    """Refresh on-disk JSON files and update parsed calibration frame fields."""
+    backfill_json_files(tar_dir, processed_root)
+
+    dataset = fo.load_dataset(dataset_name)
+    for sample in tqdm(dataset, desc="Updating calibration fields"):
+        seq_dir = processed_root / sample["sequence_id"]
+        frame_updates = {}
+        for frame_idx, frame_id in enumerate(sorted_frame_ids(seq_dir), start=1):
+            paths = frame_asset_paths(seq_dir, frame_id)
+            max_depth, metadata = load_frame_calibration(paths)
+            frame_updates[frame_idx] = calibration_frame_fields(
+                frame_id,
+                sample["sequence_id"],
+                max_depth,
+                metadata,
+            )
+
+        sample.frames.update(frame_updates)
+        sample.save()
+
+    return dataset
+
+
+def import_dataset(
+    tar_dir: Path,
+    processed_root: Path,
+    dataset_name: str,
+    fps: int,
+    overwrite: bool,
+) -> fo.Dataset:
+    """Extract all tars and create a persistent FiftyOne video dataset."""
+    tar_map = tar_sequence_map(tar_dir)
+    if not tar_map:
+        raise FileNotFoundError(f"No tar files found in {tar_dir}")
+
+    if dataset_name in fo.list_datasets():
+        if not overwrite:
+            raise ValueError(
+                f"Dataset '{dataset_name}' already exists. Pass --overwrite to replace it."
+            )
+        fo.delete_dataset(dataset_name)
+
+    dataset = fo.Dataset(dataset_name)
+    dataset.persistent = True
+
+    samples = [
+        build_video_sample(sequence_id, tar_path, processed_root, fps)
+        for sequence_id, tar_path in tqdm(tar_map.items(), desc="Processing sequences")
+    ]
+    dataset.add_samples(samples)
+    dataset.compute_metadata()
+    return dataset
+
+
+def print_dataset_summary(dataset: fo.Dataset) -> None:
+    """Print a short import summary for the created or updated dataset."""
+    frame_counts = dataset.values("frame_count")
+    preview = frame_counts[:3] if frame_counts else []
+    print(f"Dataset: {dataset.name}")
+    print(f"Samples: {len(dataset)}")
+    print(f"Media type: {dataset.media_type}")
+    print(f"Frames per sample (first 3): {preview}")
+    print(f"Total frame documents: {dataset.count('frames')}")
+    print(f"Sample fields: {list(dataset.get_field_schema().keys())}")
+    print(f"Frame fields: {list(dataset.get_frame_field_schema().keys())}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--tar-dir",
+        type=Path,
+        default=Path("data/tars/test"),
+        help="Directory containing downloaded WebDataset tar files",
+    )
+    parser.add_argument(
+        "--processed-root",
+        type=Path,
+        default=Path("data/processed"),
+        help="Directory where extracted PNG/JSON assets and rgb.mp4 files are written",
+    )
+    parser.add_argument(
+        "--dataset-name",
+        default="TransPhy3D",
+        help="Name of the FiftyOne dataset to create or update",
+    )
+    parser.add_argument(
+        "--fps",
+        type=int,
+        default=30,
+        help="FPS used when assembling rgb.mp4 from extracted PNG frames",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace an existing FiftyOne dataset with the same name",
+    )
+    parser.add_argument(
+        "--update-json-only",
+        action="store_true",
+        help="Refresh on-disk JSON files and update calibration frame fields",
+    )
+    parser.add_argument(
+        "--extract-json-only",
+        action="store_true",
+        help="Write depth_json/ and metadata/ files to disk only",
+    )
+    args = parser.parse_args()
+
+    if args.extract_json_only and args.update_json_only:
+        parser.error("Choose only one of --extract-json-only or --update-json-only")
+
+    if args.extract_json_only:
+        backfill_json_files(args.tar_dir, args.processed_root)
+        print(f"Wrote JSON files under {args.processed_root}")
+        return
+
+    if args.update_json_only:
+        dataset = refresh_calibration_fields(args.tar_dir, args.processed_root, args.dataset_name)
+    else:
+        dataset = import_dataset(
+            args.tar_dir,
+            args.processed_root,
+            args.dataset_name,
+            args.fps,
+            args.overwrite,
+        )
+
+    print_dataset_summary(dataset)
+
+
+if __name__ == "__main__":
+    main()

reconstruct_scenes.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""Build merged RGB point clouds and grouped FiftyOne scenes for TransPhy3D.
+
+Pipeline
+--------
+1. Read per-frame depth PNGs, ``depth.json``, and ``metadata.json`` from disk.
+2. Match each depth frame to the corresponding RGB frame in ``rgb.mp4``.
+3. Back-project depth pixels into a shared world coordinate system.
+4. Color each 3D point from the RGB image.
+5. Merge all frames into one point cloud per sequence.
+6. Export ``scene.pcd`` and a FiftyOne ``scene.fo3d`` scene file.
+
+Optionally builds a grouped FiftyOne dataset with two linked slices per
+sequence: ``video`` (RGB video + frame annotations) and ``reconstruction``
+(merged point cloud in ``scene.fo3d``).
+
+Run with the ``fiftyone`` conda environment::
+
+    conda activate fiftyone
+    python reconstruct_scenes.py --build-dataset --overwrite
+
+Math reference
+--------------
+Depth decoding::
+
+    Z = png_value / 65535 * max_depth
+
+Pinhole back-projection::
+
+    X = (u - cx) * Z / fx
+    Y = (v - cy) * Z / fy
+
+World coordinates::
+
+    [Xw, Yw, Zw, 1]^T = T @ [X, Y, Z, 1]^T
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import cv2
+import fiftyone as fo
+import numpy as np
+import open3d as o3d
+from PIL import Image
+from tqdm import tqdm
+
+from import_transphy3d import (
+    build_video_sample_from_disk,
+    scene_type,
+    sorted_frame_ids,
+    tar_sequence_map,
+)
+
+
+def pixel_intrinsics(k_norm: list[list[float]], width: int, height: int) -> np.ndarray:
+    """Convert normalized camera intrinsics to a pixel-space ``K`` matrix."""
+    k = np.eye(3, dtype=np.float64)
+    k[0, 0] = k_norm[0][0] * width
+    k[1, 1] = k_norm[1][1] * height
+    k[0, 2] = k_norm[0][2] * width
+    k[1, 2] = k_norm[1][2] * height
+    return k
+
+
+def decode_depth(depth_path: Path, max_depth: float) -> np.ndarray:
+    """Decode a 16-bit depth PNG into metric depth values."""
+    depth_u16 = np.array(Image.open(depth_path), dtype=np.uint16)
+    return depth_u16.astype(np.float64) / 65535.0 * max_depth
+
+
+def load_frame_calibration(seq_dir: Path, frame_id: int) -> tuple[float, np.ndarray, np.ndarray]:
+    """Load metric depth scale and camera matrices for one frame."""
+    stem = f"{frame_id:08d}"
+    max_depth = json.loads((seq_dir / "depth_json" / f"{stem}.json").read_text())["max_depth"]
+    cameras = json.loads((seq_dir / "metadata" / f"{stem}.json").read_text())["camera_matrices"]
+    extrinsics = np.array(cameras["extrinsics"], dtype=np.float64)
+    intrinsics = np.array(cameras["intrinsics"], dtype=np.float64)
+    return max_depth, extrinsics, intrinsics
+
+
+def subsample_valid_depth(
+    depth: np.ndarray,
+    stride: int,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return subsampled pixel coordinates and depth values with valid measurements."""
+    v_coords, u_coords = np.mgrid[0 : depth.shape[0] : stride, 0 : depth.shape[1] : stride]
+    depths = depth[v_coords, u_coords]
+    valid = np.isfinite(depths) & (depths > 0)
+    return u_coords, v_coords, depths, valid
+
+
+def camera_to_world(
+    u: np.ndarray,
+    v: np.ndarray,
+    depth: np.ndarray,
+    k: np.ndarray,
+    extrinsics: np.ndarray,
+    *,
+    z_sign: float,
+    use_inverse: bool,
+) -> np.ndarray:
+    """Back-project pixel coordinates into world-space 3D points."""
+    x = (u - k[0, 2]) * depth / k[0, 0]
+    y = (v - k[1, 2]) * depth / k[1, 1]
+    z = z_sign * depth
+    pts_cam = np.stack([x, y, z, np.ones_like(z)], axis=1)
+    transform = np.linalg.inv(extrinsics) if use_inverse else extrinsics
+    return (transform @ pts_cam.T).T[:, :3]
+
+
+def backproject_pixels(
+    depth: np.ndarray,
+    rgb: np.ndarray,
+    k: np.ndarray,
+    extrinsics: np.ndarray,
+    *,
+    stride: int,
+    z_sign: float,
+    use_inverse: bool,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Back-project a depth/RGB frame pair into colored world points."""
+    u_coords, v_coords, depths, valid = subsample_valid_depth(depth, stride)
+    if not np.any(valid):
+        return np.empty((0, 3)), np.empty((0, 3))
+
+    u = u_coords[valid].astype(np.float64)
+    v = v_coords[valid].astype(np.float64)
+    d = depths[valid]
+    points = camera_to_world(u, v, d, k, extrinsics, z_sign=z_sign, use_inverse=use_inverse)
+    colors = rgb[v_coords[valid], u_coords[valid]].astype(np.float64) / 255.0
+    return points, colors
+
+
+def reprojection_error(
+    points_world: np.ndarray,
+    u_orig: np.ndarray,
+    v_orig: np.ndarray,
+    k: np.ndarray,
+    extrinsics: np.ndarray,
+    *,
+    z_sign: float,
+    use_inverse: bool,
+) -> float:
+    """Mean pixel reprojection error for a candidate camera convention."""
+    transform = extrinsics if use_inverse else np.linalg.inv(extrinsics)
+    pts_cam = (transform @ np.hstack([points_world, np.ones((len(points_world), 1))]).T).T[:, :3]
+    valid = pts_cam[:, 2] > 1e-6
+    if not np.any(valid):
+        return np.inf
+
+    u_proj = k[0, 0] * pts_cam[valid, 0] / pts_cam[valid, 2] + k[0, 2]
+    v_proj = k[1, 1] * pts_cam[valid, 1] / pts_cam[valid, 2] + k[1, 2]
+    return float(np.hypot(u_proj - u_orig[valid], v_proj - v_orig[valid]).mean())
+
+
+def choose_backprojection_convention(
+    depth: np.ndarray,
+    k: np.ndarray,
+    extrinsics: np.ndarray,
+    *,
+    stride: int,
+) -> tuple[float, bool]:
+    """Pick the camera convention with the lowest reprojection error."""
+    u_coords, v_coords, depths, valid = subsample_valid_depth(depth, max(stride, 4))
+    u_sample = u_coords[valid][:5000].astype(np.float64)
+    v_sample = v_coords[valid][:5000].astype(np.float64)
+    d_sample = depths[valid][:5000]
+
+    best_error = np.inf
+    best_z_sign = 1.0
+    best_use_inverse = False
+
+    for z_sign in (1.0, -1.0):
+        for use_inverse in (False, True):
+            points = camera_to_world(
+                u_sample,
+                v_sample,
+                d_sample,
+                k,
+                extrinsics,
+                z_sign=z_sign,
+                use_inverse=use_inverse,
+            )
+            err = reprojection_error(
+                points,
+                u_sample,
+                v_sample,
+                k,
+                extrinsics,
+                z_sign=z_sign,
+                use_inverse=use_inverse,
+            )
+            if err < best_error:
+                best_error = err
+                best_z_sign = z_sign
+                best_use_inverse = use_inverse
+
+    return best_z_sign, best_use_inverse
+
+
+def reconstruct_sequence(
+    seq_dir: Path,
+    *,
+    stride: int,
+    voxel_size: float,
+    max_depth_ratio: float,
+) -> tuple[Path, Path, int]:
+    """Reconstruct one sequence into a merged RGB-colored point cloud."""
+    frame_ids = sorted_frame_ids(seq_dir)
+    if not frame_ids:
+        raise ValueError(f"No depth frames found in {seq_dir / 'depth'}")
+
+    video_path = seq_dir / "rgb.mp4"
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise RuntimeError(f"Could not open video: {video_path}")
+
+    all_points: list[np.ndarray] = []
+    all_colors: list[np.ndarray] = []
+    z_sign = 1.0
+    use_inverse = False
+    k: np.ndarray | None = None
+
+    try:
+        for frame_index, frame_id in enumerate(frame_ids):
+            ok, frame_bgr = cap.read()
+            if not ok:
+                raise RuntimeError(f"Could not read frame {frame_index} from {video_path}")
+
+            rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+            max_depth, extrinsics, intrinsics = load_frame_calibration(seq_dir, frame_id)
+            depth = decode_depth(seq_dir / "depth" / f"{frame_id:08d}.png", max_depth)
+            depth[depth > max_depth * max_depth_ratio] = 0
+
+            if k is None:
+                height, width = rgb.shape[:2]
+                k = pixel_intrinsics(intrinsics.tolist(), width, height)
+                z_sign, use_inverse = choose_backprojection_convention(
+                    depth,
+                    k,
+                    extrinsics,
+                    stride=stride,
+                )
+
+            points, colors = backproject_pixels(
+                depth,
+                rgb,
+                k,
+                extrinsics,
+                stride=stride,
+                z_sign=z_sign,
+                use_inverse=use_inverse,
+            )
+            if len(points):
+                all_points.append(points)
+                all_colors.append(colors)
+    finally:
+        cap.release()
+
+    if not all_points:
+        raise ValueError(f"No valid depth points reconstructed for {seq_dir.name}")
+
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(np.vstack(all_points))
+    pcd.colors = o3d.utility.Vector3dVector(np.vstack(all_colors))
+    if voxel_size > 0:
+        pcd = pcd.voxel_down_sample(voxel_size)
+
+    pcd_path = (seq_dir / "scene.pcd").resolve()
+    fo3d_path = (seq_dir / "scene.fo3d").resolve()
+    o3d.io.write_point_cloud(str(pcd_path), pcd)
+
+    scene = fo.Scene(camera=fo.PerspectiveCamera(up="Z"))
+    cloud = fo.PointCloud("reconstruction", str(pcd_path), flag_for_projection=True)
+    cloud.default_material.point_size = 2
+    scene.add(cloud)
+    scene.write(str(fo3d_path))
+
+    return pcd_path, fo3d_path, len(pcd.points)
+
+
+def build_grouped_dataset(
+    processed_root: Path,
+    tar_dir: Path,
+    target_dataset_name: str,
+    overwrite: bool,
+) -> fo.Dataset:
+    """Create a grouped FiftyOne dataset with video and reconstruction slices."""
+    if target_dataset_name in fo.list_datasets():
+        if not overwrite:
+            raise ValueError(
+                f"Dataset '{target_dataset_name}' already exists. "
+                "Pass --overwrite to replace it."
+            )
+        fo.delete_dataset(target_dataset_name)
+
+    target = fo.Dataset(target_dataset_name)
+    target.persistent = True
+    target.add_group_field("group", default="video")
+
+    samples = []
+    for sequence_id, tar_path in tqdm(tar_sequence_map(tar_dir).items(), desc="Building grouped dataset"):
+        seq_dir = processed_root / sequence_id
+        fo3d_path = (seq_dir / "scene.fo3d").resolve()
+        if not fo3d_path.exists():
+            raise FileNotFoundError(f"Missing reconstruction for {sequence_id}")
+
+        group = fo.Group()
+        video = build_video_sample_from_disk(sequence_id, processed_root, tar_path.name)
+        video["group"] = group.element("video")
+
+        reconstruction = fo.Sample(
+            filepath=str(fo3d_path),
+            group=group.element("reconstruction"),
+        )
+        reconstruction["sequence_id"] = sequence_id
+        reconstruction["scene_type"] = scene_type(sequence_id)
+        reconstruction["point_cloud_path"] = str((seq_dir / "scene.pcd").resolve())
+        reconstruction["tags"] = ["test", "reconstruction"]
+        samples.extend([video, reconstruction])
+
+    target.add_samples(samples)
+    target.compute_metadata()
+    return target
+
+
+def list_sequence_dirs(processed_root: Path, sequence: str | None) -> list[Path]:
+    """Return sequence directories to reconstruct."""
+    if sequence:
+        seq_dir = processed_root / sequence
+        if not seq_dir.is_dir():
+            raise FileNotFoundError(f"Sequence directory not found: {seq_dir}")
+        return [seq_dir]
+    return sorted(path for path in processed_root.iterdir() if path.is_dir())
+
+
+def print_grouped_summary(dataset: fo.Dataset) -> None:
+    """Print a short summary after building the grouped dataset."""
+    print(f"Grouped dataset: {dataset.name}")
+    print(f"Groups: {len(dataset)}")
+    print(f"Slices: {dataset.group_slices}")
+    print(f"Media types: {dataset.group_media_types}")
+    print(f"Total frame documents: {dataset.count('frames')}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--processed-root",
+        type=Path,
+        default=Path("data/processed"),
+        help="Root directory containing per-sequence processed assets",
+    )
+    parser.add_argument(
+        "--tar-dir",
+        type=Path,
+        default=Path("data/tars/test"),
+        help="Directory of source WebDataset tar files",
+    )
+    parser.add_argument(
+        "--sequence",
+        default=None,
+        help="Reconstruct a single sequence id instead of all sequences",
+    )
+    parser.add_argument(
+        "--stride",
+        type=int,
+        default=4,
+        help="Pixel subsampling stride during back-projection",
+    )
+    parser.add_argument(
+        "--voxel-size",
+        type=float,
+        default=0.01,
+        help="Open3D voxel size for downsampling; 0 disables downsampling",
+    )
+    parser.add_argument(
+        "--max-depth-ratio",
+        type=float,
+        default=0.999,
+        help="Zero depths above max_depth * ratio to remove far-plane saturation",
+    )
+    parser.add_argument(
+        "--build-dataset",
+        action="store_true",
+        help="After reconstruction, build the grouped FiftyOne dataset",
+    )
+    parser.add_argument(
+        "--build-dataset-only",
+        action="store_true",
+        help="Skip reconstruction and only build the grouped FiftyOne dataset",
+    )
+    parser.add_argument(
+        "--target-dataset",
+        default="TransPhy3D",
+        help="Name of the grouped FiftyOne dataset to create",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace an existing FiftyOne dataset with the same name",
+    )
+    args = parser.parse_args()
+
+    if args.build_dataset and args.build_dataset_only:
+        parser.error("Choose only one of --build-dataset or --build-dataset-only")
+
+    if not args.build_dataset_only:
+        for seq_dir in tqdm(
+            list_sequence_dirs(args.processed_root, args.sequence),
+            desc="Reconstructing sequences",
+        ):
+            _, fo3d_path, n_points = reconstruct_sequence(
+                seq_dir,
+                stride=args.stride,
+                voxel_size=args.voxel_size,
+                max_depth_ratio=args.max_depth_ratio,
+            )
+            print(f"{seq_dir.name}: {n_points:,} points -> {fo3d_path.name}")
+
+    if args.build_dataset or args.build_dataset_only:
+        dataset = build_grouped_dataset(
+            args.processed_root,
+            args.tar_dir,
+            args.target_dataset,
+            args.overwrite,
+        )
+        print_grouped_summary(dataset)
+
+
+if __name__ == "__main__":
+    main()