Synthetic video dataset: data format (v0.1)
This describes the data we generate for extending SAM 3D (image -> 3D objects) to short videos. It is meant to be everything a consumer needs. If anything is unclear, ask Julian.
1. What a sample is
One sample is a clip: 32 RGB frames at 512x512 of a static scene with N in {1,2,3,4} rigid objects floating in space (no ground, random orientations), seen by a camera that orbits the scene. The rendered objects are alpha-composited onto a real photo (SA-1B). Every clip comes with exact ground truth:
- per object: its shape (a 64^3 voxel grid and a textured mesh, in a canonical object frame) and its pose in the world;
- per frame: camera pose and intrinsics, visible instance masks, amodal masks, depth.
The scene never changes during a clip; only the camera moves. So each object's pose in camera coordinates changes from frame to frame, and that per-frame camera-frame pose (rotation, translation, scale) is the layout target SAM 3D predicts.
| Split | Objects | Backgrounds | Clips | Where generated |
|---|---|---|---|---|
eval |
Google Scanned Objects (GSO) | SA-1B eval pool | 500 | locally, shipped as a tarball |
train |
Objaverse-XL (TRELLIS-500K subset, filtered) | SA-1B train pool | 10,000 | on a cluster, later |
Both splits use the identical format. Objects and backgrounds never cross splits: object sets come from different sources, and SA-1B images are assigned to a pool by a fixed hash of their image ID.
2. Directory layout
dataset/
manifest.jsonl one line per clip: {clip_id, split, N, arc_span_deg, seed, path}
config.yaml generator config used
assets/{train|eval}/{asset_id}/
mesh.glb normalized textured mesh (see 3.3)
voxels.npy bool (64,64,64) surface occupancy (see 3.3)
meta.json source, source_name (original GSO/Objaverse name), license,
normalization (scale, offset, raw bbox), num_voxels, filter_scores
clips/{split}/{clip_id}/
rgb/000.png ... 031.png uint8 RGB, composited final frames <- model input
rgba_fg/000.png ... uint8 RGBA, objects only, straight (non-premultiplied) alpha
mask_visible/000.png ... uint8 instance map: 0 = background, k = object 1..N
mask_amodal/obj{k}/000.png uint8 {0,255}: full silhouette of object k
depth/000.npz ... key "depth": float32 (512,512) z-depth, NaN = background
cameras.json
objects.json
meta.json
All paths stored inside JSON files are relative to dataset/. Clips reference shared assets and don't copy them.
3. Conventions (read this carefully)
3.1 Frames and naming
R_ab,t_ab,T_abmap coordinates from frame b into frame a:x_a = R_ab x_b + t_ab.w= world,c= camera,o= object.- World: right-handed, Z up. Units are arbitrary "scene units" (no metric scale; see 3.4).
- Camera: OpenCV (x right, y down, z forward, looking along +z).
3.2 Camera (cameras.json)
{"convention": "opencv", "width": 512, "height": 512,
"K": [[548.993, 0, 255.5], [0, 548.993, 255.5], [0, 0, 1]],
"frames": [{"t": 0, "T_cw": [[4x4]]}, ..., {"t": 31, "T_cw": [[4x4]]}]}
T_cwis world -> camera (extrinsics), 4x4 with last row[0,0,0,1].Kis identical for all frames and clips: horizontal FOV 50 degrees,f = 256 / tan(25 deg), square pixels, no distortion.- Pixel centers are at integer coordinates (OpenCV convention). The principal point
255.5is the exact image center, and pixel(u, v)covers[u-0.5, u+0.5]. A pointx_cprojects tou = fx * x/z + cx,v = fy * y/z + cy.
3.3 Objects: canonical frame, shape, pose
Canonical object frame. Each asset is normalized exactly as TRELLIS does it:
- Z up, as Blender sees the asset after import.
- The longest bounding-box side is scaled to 1 and the box is centered.
- Vertices therefore lie in
[-0.5, 0.5]^3. For GSO they touch both faces along the longest axis. For Objaverse assets made of several rotated parts, TRELLIS's box can be slightly larger than the true vertex extent.
voxels.npy
bool[64,64,64]holding surface occupancy (TRELLIS-style, not solid), in the canonical frame.- Index
[i,j,k]is along(x,y,z); the voxel center is(index + 0.5) / 64 - 0.5.
mesh.glb
- A standard glTF file, which is Y-up by glTF convention. To get canonical coordinates outside Blender, multiply the vertices:
Blender's glTF importer applies this automatically; trimesh, Open3D and PyTorch3D do not.CANONICAL_FROM_GLTF = [[1,0,0],[0,0,-1],[0,1,0]] # (x, y, z)_gltf -> (x, -z, y) - One mesh object with an identity transform, already triangulated. Materials and textures are kept as in the source (GSO: one texture).
Pose in the world (objects.json), one entry per object, k = 1..N, matching the mask ids:
[{"k": 1, "asset_id": "...", "source": "gso|objaverse",
"mesh": "assets/eval/<id>/mesh.glb", "voxels": "assets/eval/<id>/voxels.npy",
"R_wo": [[3x3]], "t_wo": [x, y, z], "s_wo": [s, s, s]}]
x_w = R_wo (s_wo * x_o) + t_wo, with*elementwise.s_wois always isotropic (all three entries equal) but stored as a 3-vector to match SAM 3D'ss in R^3.t_wois where the canonical origin (the bbox center) ends up, not the center of mass.- All rotations are stored as 3x3 matrices.
Per-frame camera-frame target (what to train on):
R_co = R_cw @ R_wo
t_co = R_cw @ t_wo + t_cw
s_co = s_wo
x_c = R_co @ (s_co * x_o) + t_co
This is our convention, not SAM 3D's. SAM 3D's layout uses PyTorch3D camera axes (x left, y up), row vectors and a wxyz quaternion: x_cam = (s * x_o) @ R(q) + t. Its canonical frame and scale are the same as ours. Convert with sam3dvid.sam3d.ours_to_sam3d(R_co, t_co, s_co) -> (q, t, s) and sam3d_to_ours, which were verified against SAM 3D's own outputs in test T6 (DATASET.md Section 7).
3.4 Scale
There is no metric scale. The canonical object fits a unit cube, s ~ U(0.4, 1.0), and the camera distance is chosen relative to the scene size. t_co and s_co are in this generator's scene units, not meters.
4. Per-frame images and masks
| File | Content | Notes |
|---|---|---|
rgb/t.png |
final frame, sRGB uint8 | lit by the scene light, Blender "Standard" view transform |
rgba_fg/t.png |
objects only | anti-aliased alpha; rgb = fg*a + bg*(1-a) |
mask_visible/t.png |
which object owns each pixel | not anti-aliased; values 0..N |
mask_amodal/obj{k}/t.png |
object k's silhouette as if no other object existed | clipped to the image; visible pixels of k are always a subset |
depth/t.npz |
z-depth along the optical axis (the OpenCV z of the surface point), not distance along the ray |
finite exactly where mask_visible > 0, NaN elsewhere; the background has no depth |
Because the alpha in rgba_fg is anti-aliased, it can extend about 1 px beyond mask_visible. Those edge pixels have no depth (NaN).
5. meta.json (per clip)
| Key | Meaning |
|---|---|
clip_id, split, seed, attempt |
identity; the clip is fully reproducible from seed |
num_objects |
N |
arc_span_deg, arc_direction |
total orbit angle (10-70 deg) and its sign |
start_azimuth_deg, start_elevation_deg, elevation_drift_deg |
trajectory parameters |
orbit_radius, scene_center |
camera distance to and look-at point (world) |
hfov_deg |
50 |
light |
sun_direction (unit vector towards the sun, world frame), sun_strength, ambient_strength |
background |
image_id (SA-1B), width, height, virtual_hfov_deg (130), K_bg. Frame t's background is the photo warped by the homography K @ R_cw(t) @ R_cw,ref^T @ inv(K_bg) |
reference_T_cw |
virtual camera at the arc midpoint that the background is aligned to |
visibility |
visible_px, amodal_px, visible_frac, each a [32][N] array |
render, timing, git_commit, generator_version, arc_retries, rejections |
provenance; ignore for training |
6. Guarantees
Enforced by the generator (failing clips are resampled) and re-checked by the test suite on every released eval clip:
- Visibility: every object in every frame has at least 524 visible pixels (0.2% of the image) and at least 10% of its amodal area visible. Objects can be partly occluded but never vanish.
- Background: it covers every pixel of every frame.
Enforced by construction:
- No interpenetration: objects' bounding spheres (radius
s * sqrt(3) / 2) are disjoint.
Checked by the test suite:
- Geometry, on every eval clip, object and frame: the GT-posed mesh is ray-cast independently of Blender (one ray per pixel center).
- The amodal mask matches the ray-cast silhouette to at most 0.05 mismatched pixels per boundary pixel (typically ≤ 0.007).
- Rendered depth matches the ray-cast depth to a median error of at most 5e-4 · s (typically 1e-5 · s).
- A half-pixel principal-point offset, a 5 degree rotation or a 0.1 · s shift all fail this check, so masks and depth agree with
K,T_cwand the poses to sub-pixel accuracy.
- Determinism, on one clip regenerated from its seed:
- poses, masks and JSON are identical (except
meta.jsontimingandgit_commit); - depth matches to 1e-5 relative;
- RGB matches up to renderer noise.
- poses, masks and JSON are identical (except
7. How the data is distributed
| Quantity | Distribution |
|---|---|
| N | 1, 2, 3, 4 with p = 0.30, 0.30, 0.25, 0.15 |
object rotation R_wo |
uniform on SO(3) |
scale s |
U(0.4, 1.0) |
| object positions | uniform in a ball of radius N^(1/3), resampled until no overlap |
| camera | looks at the centroid of the object centers, Z up, no roll; distance r / tan(25 deg) * U(1.0, 1.4), where r is the radius of the objects' actual geometry around that centroid |
| object size in image | median 2.5% of the frame (N=1 larger, N=4 smaller); about 3% of objects are slightly cut off by the frame edge in some frames |
| start azimuth / elevation | U(0, 360) / U(10, 45) deg (with drift, camera elevation spans 0-55 deg) |
| arc span / elevation drift | U(10, 70) deg with random sign / U(-10, 10) deg |
| camera timing | eased: u(t) = (1 - cos(pi t / 31)) / 2, so motion is slow at both ends |
| light | one sun (uniform on the upper hemisphere) plus low ambient, fixed in world for the clip |
| background | an SA-1B photo treated as a plane at infinity, i.e. warped by the camera's rotation only (no parallax) |
These are the distributions before rejection. N, the assets, the background and the light are drawn once per seed and never resampled, so their distributions are exact. Rotations, scales, positions and the camera are redrawn when a clip fails the visibility or background checks, so released clips lean slightly towards less-occluded configurations and arcs that keep the background covered.
The model side is expected to subsample 16 of the 32 frames.
8. Minimal loader (numpy only)
import json, numpy as np
from PIL import Image
root, clip = "dataset", "dataset/clips/eval/00000000"
cams = json.load(open(f"{clip}/cameras.json"))
objs = json.load(open(f"{clip}/objects.json"))
K = np.array(cams["K"])
t, k = 0, 1
T_cw = np.array(cams["frames"][t]["T_cw"])
o = objs[k - 1]
R_wo, t_wo, s_wo = np.array(o["R_wo"]), np.array(o["t_wo"]), np.array(o["s_wo"])
R_co = T_cw[:3, :3] @ R_wo
t_co = T_cw[:3, :3] @ t_wo + T_cw[:3, 3]
rgb = np.asarray(Image.open(f"{clip}/rgb/{t:03d}.png"))
visible_k = np.asarray(Image.open(f"{clip}/mask_visible/{t:03d}.png")) == k
amodal_k = np.asarray(Image.open(f"{clip}/mask_amodal/obj{k}/{t:03d}.png")) > 0
depth = np.load(f"{clip}/depth/{t:03d}.npz")["depth"]
# Sanity check: project the voxel centers; typically >90% land on the amodal mask (voxel
# centers sit up to half a voxel off the surface, which matters for small objects).
vox = np.load(f"{root}/{o['voxels']}")
x_o = (np.argwhere(vox) + 0.5) / 64 - 0.5
x_c = (x_o * s_wo) @ R_co.T + t_co
uv = np.round(x_c[:, :2] / x_c[:, 2:] @ K[:2, :2].T + K[:2, 2]).astype(int)
inside = (uv >= 0).all(1) & (uv < 512).all(1)
print("voxel centers on amodal mask:", amodal_k[uv[inside, 1], uv[inside, 0]].mean())
9. Training export
The model team does not train on the full format. A packed export holds RGB, visible masks, per-frame object poses and voxels only (no depth, amodal masks or rgba_fg). It is built from the clip folders with:
uv run python -m sam3dvid.export --dataset dataset --split train --out <dir> --clips-per-shard 100 [--workers N]
Export is deterministic (same input, byte-identical shards) and resumable: a shard that already exists is skipped, and files are written to a temp name and renamed. One --out directory holds one split.
<out>/
train-000000.tar ... WebDataset shards, --clips-per-shard clips each, sorted by clip id
voxels_train.npz asset_id -> packed voxels, only the assets the split uses
index.json shards with clip ids and byte sizes, format version, conventions
9.1 Shards
One sample per clip, keyed by clip id. A sample is 65 tar members:
| Member | Content |
|---|---|
<clip_id>.rgb.000.jpg ... 031.jpg |
RGB frame, JPEG quality 95, 4:4:4 chroma (PSNR above 40 dB against the PNG) |
<clip_id>.visible.000.png ... 031.png |
uint8 instance map, lossless, identical to mask_visible: 0 = background, k = object k |
<clip_id>.json |
everything below |
9.2 Sample JSON
| Key | Meaning |
|---|---|
clip_id, split, seed, num_objects, generator_version, git_commit |
from meta.json; blender_version only when the clip's meta has it |
K |
3x3 intrinsics, same as cameras.json |
T_cw |
[32][4][4] world -> camera, same as cameras.json |
objects |
one entry per object, index k - 1, matching the mask ids (below) |
visibility |
visible_px, amodal_px, visible_frac, each [32][N], from meta.json |
Each entry of objects:
| Key | Shape | Meaning |
|---|---|---|
k, asset_id |
mask id (1-based) and the key into the voxels file | |
R_wo, t_wo, s_wo |
3x3, 3, 3 | world pose, as in objects.json |
R_co, t_co, s_co |
[32][3][3], [32][3], [32][3] |
per-frame camera-frame pose, computed with pose_in_camera (section 3.3) |
Poses are in our convention, as everywhere in this document; the SAM 3D converter is applied at load time, not at export.
9.3 Voxels
voxels_<split>.npz maps asset_id to np.packbits of the flattened (C order) bool (64,64,64) grid, i.e. a uint8[32768]. Voxels belong to assets, not clips, so they are stored once.
9.4 Reading
src/sam3dvid/export_reader.py needs only numpy and PIL:
from sam3dvid.export_reader import iter_samples, load_voxels
for clip_id, rgb, visible, info in iter_samples("export/train/train-000000.tar"):
# rgb (32,512,512,3) uint8, visible (32,512,512) uint8, info = the JSON above
obj = info["objects"][0]
R_co, t_co, s_co = np.array(obj["R_co"]), np.array(obj["t_co"]), np.array(obj["s_co"])
voxels = load_voxels("export/train/voxels_train.npz", obj["asset_id"]) # bool (64,64,64)
Shards are plain tars, so webdataset reads them too (keys are the clip ids).
10. Known limitations and things that may change
- Version 0.1. The file format is stable; the sampling distributions in section 7 are final for M1 unless the test runs reveal a problem.
- No de-lit texture target. Texture ground truth is out of scope;
rgbis lit. - No metric scale. Scene units are arbitrary, whereas SAM 3D's MoGe pointmaps are metric (one of our units comes out at about 0.29 in MoGe's reconstruction, median over T6, varying per scene). Without a pointmap input, use scale-invariant translation and scale targets.
- Train split not generated yet (M2). Its format will be identical; the assets are filtered Objaverse objects (
DATASET.mdSection 1).
CC0 background update (2026-10-28)
New M2 runs use data/bg_pools_polyhaven via configs/m2.yaml. Prepare it on a CPU
node with uv run python scripts/prepare_polyhaven.py --limit 200 --views 4.
Powered by Poly Haven (https://polyhaven.com); assets: CC0 (https://polyhaven.com/license).
The script converts tone-mapped equirectangular panoramas into 2048x1024 perspective
JPEGs at 130 degree HFOV, keeping the existing compositor and lighting unchanged.
It freezes the source selection/settings, verifies downloads, records source URLs and
checksums, and splits by panorama before creating views. Do not rebuild these pools
with the legacy image-ID-based build_bg_pools.py. Freeze pools before rendering.
Background provenance is included in new clip metadata and exported sample JSON.
Earlier SA-1B descriptions and M1/T6 results are historical. Preserve those clips, but
exclude them from the HF release. Regenerate eval into a fresh dataset root using
configs/m1_polyhaven.yaml, link its assets, and rerun coverage/visual validation.
The source swap does not clear Objaverse/GSO license obligations; audit them before
upload, including private HF hosting. Background preparation does not upload anything.