Multi-View Kubric (MV-Kubric)

These are synthetic multi-view Kubric scenes with ground-truth 3D point tracks, per-camera visibility, and depth maps. They were used to train and evaluate Tracktail (multi-view 3D point tracking without depth input). The scenes were rendered with the multi-view Kubric worker from MVTracker (ethz-vlg/kubric, branch multiview-point-tracking). Each scene has falling and moving rigid objects and 10 static cameras.

split	scenes	cameras	frames / scene	resolution	tracked points / scene	images	depth maps
train	4,959	10	24	512x512	1,087–7,618	1,190,160	1,190,160
val	2	10	24	512x512	3,418–5,158	480	480
test	30	10	24	512x512	2,034–7,458 (all) / 512 (eval)	7,200	7,200

The tracks in pose3d.npz cover every moving surface point of the Kubric scene, i.e. every point whose 3D position changes during the clip. Visibility is Kubric's per-view occlusion flag (vis = ~occlusion). The order of the vis camera axis was checked against Kubric's per-view occlusion for every scene.

The test split contains the 30 MV-Kubric evaluation sequences of the MVTracker benchmark (Rajič et al., 2025). The paper evaluation uses cameras view_0–view_3 and the fixed MVTracker track set in pose3d_cached.npz.

Coordinates are in Kubric scene units and are not metric.

Download and extraction

The dataset is hosted at ai-hhmi/mv-kubric.

The data (705 GB) is stored as uncompressed tar shards of about 4 GB in data/. Each shard holds complete trials. index.csv lists the shard for every trial, and SHA256SUMS has a checksum for every shard.

split	shards
train	166
val	1
test	1

# everything
hf download ai-hhmi/mv-kubric --type dataset --local-dir mv-kubric
# or only the test split
hf download ai-hhmi/mv-kubric --type dataset --local-dir mv-kubric --include "data/test-*" --include "*.md" --include "*.csv" --include SHA256SUMS

cd mv-kubric
sha256sum -c SHA256SUMS --ignore-missing      # optional integrity check
for f in data/*.tar; do tar -xf "$f"; done    # creates train/, val/, test/ next to data/

Paths inside the shards are relative to the dataset root (for example train/31/trial/img/view_0/img000000.png), so extracting all shards gives the layout below.

Directory layout

mv-kubric/
  README.md
  LICENSE
  {train,val,test}/<scene>/trial/
      metadata.yaml               cameras (+ provenance)
      pose3d.npz                  ground-truth 3D tracks and per-camera visibility
      pose3d_cached.npz           (test only) 512 MVTracker evaluation tracks
      pose3d_cached_100.npz       (test only) 100-track subset of the above
      img/<cam>/imgNNNNNN.png     RGB frames
      depth/<cam>/depthNNNNNN.png  16-bit z-depth, same frame index as img/

Camera folders are view_0 … view_9. Frame i of a trial is the i-th file of sorted(os.listdir(img/<cam>)), and it matches index i on the time axis of pose3d.npz and the i-th file of depth/<cam>/. Image and depth files with the same number belong to the same frame. Images are RGBA PNGs with an opaque alpha channel; the Tracktail loader uses the RGB channels.

File formats

metadata.yaml

All matrices are keyed by camera name.

key	meaning
intrinsic_matrices	3x3 pinhole K in pixels
extrinsic_matrices	4x4 world→camera transform [R t; 0 1], so x_cam = R @ x_world + t (OpenCV convention: +z forward, +y down)
distortion_matrices	5 OpenCV distortion coefficients (all zero, since these are synthetic pinhole cameras)
camera_heights, camera_widths	image size in pixels
depth	depth encoding: scale, invalid_value, and decoding rule (see below)
n_frames, num_cameras	trial size (informational)

Project a world point with uv = K @ (R @ X + t), then uv = uv[:2] / uv[2].

pose3d.npz

key	shape / dtype	meaning
pose	(1, T, N, 3) float64	world-space 3D position of each of the N tracked surface points at each of the T frames (Kubric scene units)
vis	(1, T, N, C) bool	visibility of each point in each of the C cameras. The camera axis follows the sorted camera names (view_0, view_1, …, view_9)
keypoints	(N,) str	point identifiers

Test-only evaluation files (same pose / vis / keypoints layout, for a subset of tracks):

file	extra keys	meaning
pose3d_cached.npz	query_times (N,), cache_track_indices (N,)	the 512 evaluation tracks of the MVTracker benchmark. pose is NaN before each track's query frame. cache_track_indices index MVTracker's cached track file
pose3d_cached_100.npz	query_times, cache_track_indices, source_index (N,)	100-track subset used for qualitative and fast runs. source_index indexes the tracks of pose3d_cached.npz

In evaluation, each track is queried at the first frame where it is visible in at least one of the cameras used.

depth/<cam>/depthNNNNNN.png

These are single-channel uint16 PNGs at full image resolution. Each stores z-depth: the distance along the camera's optical axis, i.e. the z coordinate of the surface point in that camera's frame, in the same units as pose.

depth = png_value / 1000        # z-depth in Kubric units, 1/1000-unit resolution (max representable 65.534)
invalid where png_value == 0   # no valid depth (non-finite, or outside the representable range)

The same scale / invalid_value are stored in every trial's metadata.yaml under depth:.

The depth maps were converted from Kubric's depth_*.tiff, which stores distance along the camera ray, to z-depth: z = d / sqrt(1 + ((u+0.5-cx)/fx)^2 + ((v+0.5-cy)/fy)^2). Observed depths go up to about 55 units (the scene dome). Depth at the projected track positions agrees with the tracks' camera-space z to a median ratio of 0.9995.

Minimal loader

import os, numpy as np, yaml
from PIL import Image

trial = "mv-kubric/test/1/trial"
md = yaml.safe_load(open(f"{trial}/metadata.yaml"))
cams = sorted(md["intrinsic_matrices"])                 # also the order of the vis camera axis
gt = np.load(f"{trial}/pose3d.npz")
pose, vis = gt["pose"][0], gt["vis"][0]                 # (T, N, 3), (T, N, C)

cam = cams[0]
frames = sorted(os.listdir(f"{trial}/img/{cam}"))
depths = sorted(os.listdir(f"{trial}/depth/{cam}"))
rgb = np.array(Image.open(f"{trial}/img/{cam}/{frames[0]}"))
d = np.array(Image.open(f"{trial}/depth/{cam}/{depths[0]}")).astype(np.float32)
valid = d != md["depth"]["invalid_value"]
d = d / md["depth"]["scale"]                            # z-depth in scene units

K = np.array(md["intrinsic_matrices"][cam]); E = np.array(md["extrinsic_matrices"][cam])
Xc = pose[0] @ E[:3, :3].T + E[:3, 3]                   # world -> camera
uv = Xc @ K.T; uv = uv[:, :2] / uv[:, 2:]

Using with the Tracktail code

Point TRACKTAIL_DATA at a folder that holds the extracted datasets. The Tracktail evaluation script (scripts/eval_testset_metrics.py) picks thresholds by dataset folder name, and the paper configs use the original folder names. To reproduce the paper numbers exactly, link this dataset under its original name:

ln -s mv-kubric $TRACKTAIL_DATA/kubric-multiview

Source assets and attribution

• Kubric (Greff et al., CVPR 2022), Apache 2.0, with its standard assets: Google Scanned Objects (CC BY 4.0) and Poly Haven HDRIs (CC0)
• The multi-view scene setup and the test sequences / evaluation tracks come from MVTracker (Rajič et al., 2025)

Please also cite Kubric and MVTracker.

Citation

If you use this dataset, please cite the Tracktail paper (citation to be added on publication).