README.md

---
license: cc-by-nc-4.0
task_categories:
  - image-to-video
  - robotics
  - depth-estimation
language:
  - en
tags:
  - multi-view
  - 4d
  - world-model
  - video-generation
  - 3d-point-tracking
  - point-trajectories
  - camera-pose
  - depth
  - synthetic
  - simulation
  - humanoid
pretty_name: VPM-Data
viewer: false
size_categories:
  - 10K<n<100K
---

<p align="center">
  <img src="https://huggingface.co/datasets/rooty2020/VPM-Data/resolve/main/assets/vpm-icon.png" alt="VPM" width="120">
</p>

<p align="center">
  <a href="https://rootyjeon.github.io/video-point-model/"><img src="https://img.shields.io/badge/Project-Page-1f6feb.svg?logo=googlechrome&logoColor=white" alt="Project page"></a>
  <a href="https://arxiv.org/abs/2610.28594"><img src="https://img.shields.io/badge/arXiv-2610.28594-b31b1b.svg?logo=arxiv&logoColor=white" alt="arXiv"></a>
  <a href="https://github.com/rootyJeon/VPM"><img src="https://img.shields.io/badge/GitHub-Code-181717.svg?logo=github&logoColor=white" alt="GitHub"></a>
</p>

# VPM-Data

VPM-Data is the simulated multi-view training set of the **Video-Point Model (VPM)**. It pairs synchronized
multi-view videos with **persistent, metric 3D point trajectories** in two domains:

- 🦾 **Robot**: 8,112 tabletop clips in which a Fourier GR-1 T2 humanoid picks and places objects among clutter;
- 🚶 **General**: 2,000 urban clips of pedestrians and vehicles in a CARLA city, each filmed by four independently moving
  cameras.

Every clip comes with

- 🎥 **synchronized multi-view RGB videos** (1280×1280, H.264);
- 📷 **camera intrinsics and per-frame world-to-camera extrinsics** of every view;
- 📍 **persistent 3D surface points** on the robot, the manipulated objects, people and vehicles, with validity and
  per-view visibility (robot) or in-frame flags (general);
- 🌊 **rendered depth** for every view and frame;
- 📝 a one-sentence **English caption**;
- 🏷️ **metadata**: object and actor labels, target visibility states (visible / occluded / out of frame), camera motion
  types, scene randomization and quality-check records.

Images and annotations are exported from the same simulation timestep, so the annotations are exact and aligned across
views and time.

## Overview

| domain | folder | clips | views | fps | resolution | frames / clip | 3D points / clip | hard clips |
|:--|:--|--:|--:|--:|:--|:--|:--|--:|
| **Robot** (tabletop manipulation) | `robot-episodes/` | 8,112 | 3 | 20 | 1280×1280 | 81, 100, 121, 144 or 181 | 512 robot + 256 per object (768–2,048 in total) | 1,641 |
| **General** (urban dynamics) | `general-episodes/` | 2,000 | 4 | 15 | 1280×1280 | 81, 100, 121, 144 or 181 (400 clips each) | 256 on the target | 0 |

| | Robot | General |
|:--|:--|:--|
| motion | recorded GR-1 T2 pick-and-place episodes replayed in Unreal Engine 5 | live traffic and crowd simulation in CARLA (Unreal Engine) |
| scene | a city environment used as static scenery, randomized clutter and surfaces | the same city (CARLA Town10HD extended to six tiles); targets on all six tiles |
| content | one target, 0–3 receptacles, 0–2 contact distractors and typically 5–10 non-contact distractors, drawn from 306 props; one or both hands | one followed pedestrian (1,000 clips) or vehicle (1,000 clips), 200 per class and length; 38 pedestrian and 17 vehicle models |
| cameras | static, jittered around authored poses; planned paths in hard clips | horizontal FoV 25–90° drawn per camera; static, arc, translation, random polyline or pan–tilt paths |
| reference camera | `cam00` | `cam01` |

The paper (Table 1) lists the corpus as 8,000 robot and 2,000 general clips; this release contains 8,112 robot and
2,000 general clips.

**Hard clips** keep the target covered by the camera set while single cameras lose it.
- Robot: in at least two views (`hard.hard_k` in `meta.json`) the target is out of sight (visible point fraction ≤ 0.3)
  for ≥ 20 consecutive frames while it moves ≥ 5 cm. `difficulty` is the generation label; `hard.measured_difficulty`
  re-measures it from the rendered visibility, and the two disagree on 224 clips (`hard.hard_metrics` has the
  per-camera measurements).
- General: all clips are `normal`. Cameras may still leave the target and come back: in 1,100 clips of 100 frames or
  more, one to three cameras pan away from the target and re-acquire it (the out-of-view schedule in `cameras.json`,
  the segments in `visibility.json`).

## Dataset Structure

```
VPM-Data/
├── README.md
├── robot-episodes/                              # 8,112 tabletop clips
│   ├── index.jsonl                              # one record per clip
│   └── part_{00..08}/                           # 1,000 episodes per part (part_08: 112, episodes 8048–8159)
│       └── episode_XXXXXX/
│           ├── manifest.json                    # build record: robot base pose, per-frame robot link positions, camera rig
│           └── clip/
│               ├── videos/cam{00,01,02}.mp4     # H.264, 20 fps
│               ├── views/cam{00,01,02}/{first,mid,last}_NNNN.png   # lossless stills of the first / middle / last frame
│               ├── depth.zip                    # cam0X/frame_NNNN.png, 16-bit depth in cm
│               ├── cameras.json                 # intrinsics + per-frame w2c of every camera
│               ├── points_target.npz            # 3D points of the robot and the objects + visibility
│               ├── visibility.json              # per-object and robot visibility states per frame and camera
│               ├── meta.json                    # scene, objects, distractors, randomization, hard-clip measurements
│               └── caption.txt
└── general-episodes/                            # 2,000 urban clips
    ├── index.jsonl                              # one record per clip
    ├── final_manifest.json                      # per clip: path, length, class, target model, tile, caption, size + SHA-256 of every file
    └── worker-{local,workshop}/                 # one folder per capture machine, 1,000 clips each
        └── clips/clip_XXXXX/                    # worker-local: clip_00002–clip_01451, worker-workshop: clip_100005–clip_101431
            ├── videos/cam{01,02,03,04}.mp4      # H.264, 15 fps
            ├── depth.zip                        # cam0X/frame_NNNN.png, 16-bit depth in cm
            ├── cameras.json                     # intrinsics + per-frame w2c / c2w of every camera
            ├── points_target.npz                # 3D points on the target + per-view in-frustum flags
            ├── visibility.json                  # target state per frame and camera, out-of-view segments, target box
            ├── meta.json                        # capture settings, target, camera paths, gate measurements
            ├── caption.txt
            └── .capture_done                    # capture summary
```

`index.jsonl` has one JSON record per clip: `id`, `path` (the clip folder), `frames`, `fps`, `cameras`, `difficulty`
(`normal` / `hard`), `caption`, and per domain
- Robot: `measured_difficulty`, `targets`, `placers` (receptacles), `contact_distractors`, `n_distractors`, `hands`,
  `n_object_points`, `n_robot_points`;
- General: `target_class` (`pedestrian` / `vehicle`), `target_model`, `tile` (the map tile of the target, 0–5),
  `camera_motion` and `hfov_deg` per camera, `n_points`.

Use the folder name as the clip id; in general clips it matches `clip` in `meta.json`. Clip numbers are not contiguous
(captures that failed the checks were discarded). Paths in `final_manifest.json` are relative to `general-episodes/`.
A few free-text notes in the JSON files are in Korean.

| size | Robot | General | total |
|:--|--:|--:|--:|
| videos | 137 GB | 208 GB | 345 GB |
| depth | 471 GB | 427 GB | 898 GB |
| stills (`views/`) | 201 GB | – | 201 GB |
| annotations and metadata | 28 GB | 2 GB | 30 GB |
| **all files** | **837 GB** | **637 GB** | **1.47 TB** |

## File Formats

### Conventions

- **Points** are stored in the reference camera's frame at the same frame t (OpenCV axes: +x right, +y down, +z forward),
  in metres. To move them to another view, use the relative transform `w2c[k][t] @ inv(w2c[ref][t])`, which is a rigid
  transform in metres in both domains.
- **Cameras** are distortion-free pinholes with `fx = fy`. The principal point is given in the pixel-corner convention
  (`cx = cy = 640` for 1280 px; pixel `i` covers `[i, i+1)`): `u = fx·x/z + cx` indexes pixel `floor(u)`. Subtract 0.5 from
  `cx, cy` for the pixel-centre convention.
- **World frames.** Robot `w2c_frames` map Unreal world points in **centimetres** (left-handed, z up) to OpenCV camera
  coordinates in metres; the 1/100 factor and the handedness flip are folded into the rotation block, whose determinant
  is therefore −1. General `extrinsic_w2c` are rigid OpenCV world-to-camera matrices in **metres** in a right-handed,
  z-up world (Unreal world with y negated). Both store the raw Unreal poses as well.
- **Depth** is planar camera z, stored as 16-bit grayscale PNG in centimetres (divide by 100 for metres), pixel-aligned
  with the RGB frames. Sky and far background saturate at large values (up to 65535).

### Robot clip

`points_target.npz` (`T` frames, `N = 256 × objects`):

| key | shape | dtype | content |
|:--|:--|:--|:--|
| `xyz` | (T, N, 3) | float32 | object surface points in `cam00`, metres; objects = targets, receptacles and contact distractors |
| `valid` | (T, N) | bool | point defined at this frame |
| `vis_cam` | (T, 3, N) | bool | point visible in each camera (depth test against the rendered depth, 3 cm tolerance) |
| `xyz_robot` | (T, 512, 3) | float32 | robot surface points in `cam00`, metres: 256 per arm, 128 of them on the hand |
| `valid_robot`, `vis_cam_robot` | (T, 512), (T, 3, 512) | bool | as above, for the robot points |
| `w2c_cam00` | (T, 4, 4) | float32 | world-to-`cam00` matrix (same as `cameras.json`) |
| `frames` | (T,) | int32 | frame indices |
| `point_meta` | () | str (JSON) | reference camera, convention, and per object its id, role (`target` / `placer` / `contact_distractor`), point index range and mesh |
| `robot_meta` | () | str (JSON) | per robot link its side, hand flag, point index range and mesh |

Points are sampled once per mesh (area-weighted, at least four per robot link) and propagated with the per-frame link
and object transforms, so every point keeps its physical identity over the clip and across views.

- `cameras.json`: `cameras_data[cam]` with `intrinsics` (`fx, fy, cx, cy, width, height`), `w2c_frames` (T, 4, 4),
  `moving`, `hfov_deg`, and the Unreal poses `ue_location_cm_frames` / `ue_rotation_pyr_deg_frames`.
- `visibility.json`: per object and frame the state in each camera (`visible`, `occluded`, `out_of_frustum`,
  `not_spawned`), the visible point fraction, the robot arms' visible fraction, and object centres in the world and in
  `cam00`.
- `meta.json`: map, seed, fps and frame count, camera FoVs, `difficulty` (`normal` / `hard`) with the hard-clip
  measurements, camera jitter, table pose, the replayed objects (targets, receptacles, contact distractors and their
  motion), every distractor with its asset and placement, the robot point allocation, and per-camera depth statistics.
- `manifest.json`: robot base pose, the per-frame world positions of the 66 robot links, and the camera rig before and
  after jitter.

### General clip

`points_target.npz`:

| key | shape | dtype | content |
|:--|:--|:--|:--|
| `xyz` | (T, 256, 3) | float32 | target surface points in `cam01`, metres |
| `valid` | (T, 256) | bool | point defined at this frame |
| `in_frustum_cam` | (T, 4, 256) | bool | point inside each camera's image (not occlusion tested; test against `depth.zip` for per-point occlusion) |
| `w2c_cam01` | (T, 4, 4) | float64 | world-to-`cam01` matrix |
| `frames` | (T,) | int32 | frame indices |
| `point_meta` | () | bytes (JSON) | sampling, surface area, mesh components, and per point its component, mesh section and skinning flag |

Points are sampled once per target model, area-weighted on its surface. Points on skinned meshes (bodies and vehicle
chassis) are re-posed from the bone transforms at every frame, and points on rigid parts (doors, lights, glass) follow
their component transforms, so every point keeps its identity over the clip. Window glass has no surface in the depth
images: leave the points whose component (`point_meta.point_component`) is a glass mesh out of depth-based occlusion
tests.

- `cameras.json`: `cameras[k]` with `intrinsics` (`fx, fy, cx, cy, width, height, hfov_deg`), the path type
  `motion_kind` and the out-of-view schedule; `per_frame[t].cameras[k]` with `extrinsic_w2c`, `c2w` and the Unreal pose
  `ue_pose`.
- `visibility.json`: the target state per frame and camera (`visible`, `occluded`, `out_of_frustum`, `target_absent`)
  from the projected target box (`visibility`) and from the target's surface points (`visibility_strict`, which drives
  the departure / re-acquisition labels), out-of-view segments and cycles per camera, and the target centre and box in
  the world and in `cam01`. `visible` means that the target covers at least 300 pixels of the instance segmentation.
- `meta.json`: capture settings (seed, FoV per camera, frame bucket), the target (class, model, map tile), camera
  placement and path types, the out-of-view scheduler, smoothing limits, and the measured motion, visibility, depth and
  point-track summaries.

### Captions

A vision-language model wrote one English sentence per clip. Captions must agree with the recorded motion, avoid numbers
and camera descriptions, and pass format checks; failures were regenerated with the check feedback for up to two rounds,
and unresolved clips were dropped. General captions are written from six frames of the clip (first, middle and last
frame of `cam01`, middle frame of `cam02`–`cam04`).

## Quality checks

Every clip was checked for geometric alignment, annotation completeness, depth validity, camera motion, target
visibility and caption consistency; failed clips were replaced, and the corpus got a final human audit.

**Robot.** Distractors are simulated at 60 Hz and must settle before the replay (placements with falling props are
rejected); contact distractors lie in the robot's swept volume and must be touched during the replay (≥ 1 cm contact
depth for ≥ 2 frames) and move by ≥ 1 cm. Cameras stay ≥ 5 cm above the table and ≥ 3 cm clear of the robot, and the
whole rig must be clear of the city geometry. Hard labels are verified from the measured visibility, not taken from
the camera schedule.

**General.**

| check | threshold |
|:--|:--|
| target visibility | visible ratio ≥ 0.1 in every camera without an out-of-view schedule |
| survival and motion | target present throughout; travel ≥ 1.0 m per 81 frames (0.5 m floor) |
| motion persistence | target speed ≥ 40 cm/s in ≥ 40% of the frames |
| tracks | no track breaks, completeness ≥ 0.99 |
| depth | sky, near and constant-value pixel ratios each ≤ 0.25 |
| camera clearance | at most two cameras with blocked paths, view-block ratio ≤ 0.6 |
| out of view | every scheduled camera leaves the target (≥ 8 frames out of frame) and re-acquires it (≥ 8 frames visible) |
| camera smoothness | jolt ≤ 40 cm, step ≤ 160 cm, rotation ≤ 0.08 of the horizontal FoV per frame, vertical vibration ≤ 4 cm (1.3–3 Hz) |
| capture | full length, no early stop, no texture still loading during the capture |
| caption | present, ≥ 20 characters, format checks |

`final_manifest.json` lists the size and SHA-256 of every general file for checking a download.

Details are in Appendix C of the paper.

## Usage

```bash
# everything (~1.47 TB)
hf download rooty2020/VPM-Data --repo-type dataset --local-dir data/VPM-Data
# one domain
hf download rooty2020/VPM-Data --repo-type dataset --local-dir data/VPM-Data --include "general-episodes/*"
# without depth and stills (~375 GB)
hf download rooty2020/VPM-Data --repo-type dataset --local-dir data/VPM-Data --exclude "*/depth.zip" --exclude "*/views/*"
```

```python
import io, json, zipfile
import numpy as np
from PIL import Image

def load_robot(clip):    # data/VPM-Data/robot-episodes/part_00/episode_000000/clip
    cams = json.load(open(f"{clip}/cameras.json"))["cameras_data"]
    K = {c: cams[c]["intrinsics"] for c in cams}
    w2c = {c: np.asarray(cams[c]["w2c_frames"]) for c in cams}               # (T, 4, 4)
    pts = np.load(f"{clip}/points_target.npz")
    return "cam00", K, w2c, pts            # pts["xyz_robot"], pts["xyz"], pts["vis_cam_robot"], pts["vis_cam"]

def load_general(clip):  # data/VPM-Data/general-episodes/worker-local/clips/clip_00002
    cj = json.load(open(f"{clip}/cameras.json"))
    K = {c["name"]: c["intrinsics"] for c in cj["cameras"]}
    w2c = {c["name"]: np.asarray([f["cameras"][k]["extrinsic_w2c"] for f in cj["per_frame"]])
           for k, c in enumerate(cj["cameras"])}                              # (T, 4, 4)
    pts = np.load(f"{clip}/points_target.npz")
    return "cam01", K, w2c, pts            # pts["xyz"], pts["in_frustum_cam"]

def to_view(xyz, w2c, ref, cam):
    """(T, N, 3) points in the reference camera -> the same points in `cam`, metres."""
    rel = w2c[cam] @ np.linalg.inv(w2c[ref])
    return np.einsum("tij,tnj->tni", rel[:, :3, :3], xyz) + rel[:, None, :3, 3]

def project(X, K):
    """camera points -> pixel coordinates (pixel-corner convention)."""
    return np.stack([K["fx"] * X[..., 0] / X[..., 2] + K["cx"], K["fy"] * X[..., 1] / X[..., 2] + K["cy"]], -1)

def depth(clip, cam, t):
    with zipfile.ZipFile(f"{clip}/depth.zip") as z:
        return np.asarray(Image.open(io.BytesIO(z.read(f"{cam}/frame_{t:04d}.png"))), np.float32) / 100.0  # metres

ref, K, w2c, pts = load_robot("data/VPM-Data/robot-episodes/part_00/episode_000000/clip")
uv = project(to_view(pts["xyz_robot"], w2c, ref, "cam01"), K["cam01"])       # (T, 512, 2)
visible = pts["vis_cam_robot"][:, 1]                                          # (T, 512), cam01
```

## Relation to VP-WorldBench

[VP-WorldBench](https://huggingface.co/datasets/rooty2020/VP-WorldBench) is the evaluation benchmark of VPM. Its
simulated clips were produced in separate capture runs and do not overlap with VPM-Data. The tabletop benchmark uses
new episodes at other places of the robot city and in two unseen kitchens. The urban benchmark was filmed in the same
CARLA city and with the same pedestrian and vehicle models as VPM-Data's urban clips, but in a separate capture run with
its own seeds, so no clip is shared; it also contains hard clips, which VPM-Data's urban part does not.

## Citation

```bibtex
@article{jeon2026vpm,
  title={Learning the 4D World through Point Trajectory Forecasting},
  author={Jeon, Byungwoo and Hong, Sunghwan and Kim, Dohyeon and Lee, Jonghoon and Park, Jungwoo and Lee, Inhee and Baek, Doosan and Kim, Jinil and Lim, Taehyun and Joo, Hanbyul and Pollefeys, Marc and Xie, Saining and Shin, Jinwoo},
  journal={arXiv preprint arXiv:2610.28594},
  year={2026}
}
```

## License

VPM-Data is released under the
[Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)](https://creativecommons.org/licenses/by-nc/4.0/)
license. Copyright [Physics Sim Lab, Inc.](https://pslab.ai/en/) and [Byungwoo Jeon](https://rootyjeon.github.io/). Simulator assets shown in the renders remain under the terms of their owners.