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

# 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/*"

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 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

@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) license. Copyright Physics Sim Lab, Inc. and Byungwoo Jeon. Simulator assets shown in the renders remain under the terms of their owners.