VPM-Data is the simulated multi-view training set of the Video-Point Model (VPM) (paper · project page · code). 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,169 urban clips of pedestrians and vehicles, 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,169	4	15	1280×1280	81, 100, 121, 144 or 181	256 on the target	312

	Robot	General
motion	recorded GR-1 T2 pick-and-place episodes replayed in Unreal Engine 5	live traffic and crowd simulation in Unreal Engine
scene	a city environment used as static scenery, randomized clutter and surfaces	13 surveyed locations in a second city
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,460 clips) or vehicle (709 clips); 6 body meshes with procedural clothing, 12 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 and 2,169.

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 four cameras leave the target and re-acquire it in two phases; hard clips are 181 frames long.

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,169 urban clips
    ├── index.jsonl                              # one record per clip
    └── worker-{cloud,home,linux,local}/         # one folder per capture machine (clip ids 1xxxxx / 3xxxxx / 4xxxxx / 2xxxxx)
        └── clips/clip_XXXXXX/
            ├── 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
            └── .caption_done                    # caption record

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), camera_motion and hfov_deg per camera, n_points.

Use the folder name as the clip id: in general clips, the clip field of meta.json holds the first clip of its capture session (bench.clip_id and the other files carry the right id). A few free-text notes in the JSON files are in Korean.

size	Robot	General	total
videos	137 GB	245 GB	382 GB
depth	471 GB	386 GB	857 GB
stills (`views/`)	201 GB	–	201 GB
annotations and metadata	28 GB	3 GB	31 GB
all files	837 GB	634 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 seed, surface area, mesh components

Points are sampled area-weighted on the target's surface at acquisition. On skinned meshes, triangle identities and barycentric coordinates recover the same surface points from the deformed vertices at every frame.

cameras.json: cameras[k] with intrinsics (fx, fy, cx, cy, width, height, hfov_deg) 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 box rays (visibility) and from up to 32 traced 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.
meta.json: capture settings (FoV per camera, frame bucket), the target (class, model), camera path types, the out-of-view scheduler, smoothing limits, and the measured motion, visibility 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.

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 over all cameras
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, ≥ 99% of the points reproject within one pixel
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
camera smoothness	jolt ≤ 40 cm, step ≤ 160 cm, rotation ≤ 0.08 of the horizontal FoV per frame, vertical vibration ≤ 4 cm
caption	present, ≥ 20 characters, format checks

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 (~413 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-home/clips/clip_300001
    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 with separate capture pipelines 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, and the urban benchmark films moving agents in the robot city, whose traffic and crowd dynamics never appear in training (VPM-Data's urban clips come from a different city).

Citation

@article{vpm2026,
  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.06940},
  year    = {2026}
}

License

VPM-Data is released under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) license. Copyright Byungwoo Jeon. Simulator assets shown in the renders remain under the terms of their owners.

Downloads last month: 145

Total file size:

1.47 TB

Paper for rooty2020/VPM-Data

Stabilizing language models under continual learning via condition-anchored distillation

Paper • 2610.06940 • Published 16 days ago