| # 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_ab` map 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`) |
|
|
| ```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_cw` is **world -> camera** (extrinsics), 4x4 with last row `[0,0,0,1]`. |
| - `K` is 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.5` is the exact image center, and pixel `(u, v)` covers `[u-0.5, u+0.5]`. A point `x_c` projects to `u = 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: |
| ``` |
| CANONICAL_FROM_GLTF = [[1,0,0],[0,0,-1],[0,1,0]] # (x, y, z)_gltf -> (x, -z, y) |
| ``` |
| Blender's glTF importer applies this automatically; trimesh, Open3D and PyTorch3D do not. |
| - 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: |
|
|
| ```json |
| [{"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_wo` is always isotropic (all three entries equal) but stored as a 3-vector to match SAM 3D's `s in R^3`. |
| - `t_wo` is 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_cw` and the poses to sub-pixel accuracy. |
| - **Determinism**, on one clip regenerated from its seed: |
| - poses, masks and JSON are identical (except `meta.json` `timing` and `git_commit`); |
| - depth matches to 1e-5 relative; |
| - RGB matches up to renderer noise. |
|
|
| ## 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) |
|
|
| ```python |
| 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: |
|
|
| ```python |
| 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; `rgb` is 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.md` Section 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. |
|
|
