---
pretty_name: Infinigen Trajectory Videos 2K
task_categories:
  - object-detection
  - depth-estimation
tags:
  - 3d-object-detection
  - oriented-bounding-box
  - video
  - synthetic
  - infinigen
  - camera-pose
size_categories:
  - 100K<n<1M
---

# Infinigen Trajectory Videos 2K

2,000 synthetic indoor videos rendered from [Infinigen](https://github.com/princeton-vl/infinigen) scenes, with per-frame
RGB, metric depth, camera intrinsics and poses, instance masks and per-frame 3D oriented boxes. Each video is a slow,
wall-avoiding camera path between two real camera poses of one scene. The data is in the native scene-JSON format of
SpatialEncoder v2 Small (`spatial_encoder_v2_small`), plus WebDataset shards that its HF/WDS training loader can stream.

| | train | val | total |
|---|---|---|---|
| Videos | 1,822 | 178 | 2,000 |
| Frames | 179,400 | 17,580 | 196,980 |
| Object tracks | | | 39,303 (73 categories) |
| WDS shards / samples | 74 / 3,609 | 8 / 353 | 81.5 GB |

- 1,003 layouts of about 1,000 Infinigen scenes, 1 or 2 videos per layout; the split follows the layout's split.
- 45–120 frames per video (multiples of 15, mean 98.5), 15 fps, 1024 × 1024.
- Camera: 0.3 m/s, 20°/s, path length 0.8–2 m, total turn ≤ 90°; about 2 cm and 0.5° of motion per frame,
  similar to ScanNet (0.9 cm / 0.7° median).
- Horizontal field of view fixed per video, 48–82° across videos (median 67°); pinhole, no distortion.

## Layout

```
README.md
manifest.json                         WDS shard manifest (schema spatialencoder-wds-native-v1, pinned URLs)
catalog.json                          training catalog with the "Infinigen" source ($INFINIGEN_ROOT paths)
dataset/Infinigen.json                index: [["train-json/<video>.json", num_frames, "train"|"val"], ...]
Infinigen/train-json/<video>.json     one scene JSON per video (all splits; the index gives the split)
videos/<video>.tar                    per-video package, extracts to <video>/...
  <video>/render/rgb_frames/NNNNNN.jpg   RGB
  <video>/render/rgb.mp4                 the same frames as a video
  <video>/depth/depth_mm_uint16/NNNNNN.png   depth, uint16 millimetres, 0 = invalid
  <video>/depth/depth_preview.mp4
  <video>/instance/instance_id_png/NNNNNN.png   instance ids
  <video>/annotations/                   renderer output: video_annotation.json, per_frame/*.json, categories, source
  <video>/trajectory.json                planned camera path
wds/Infinigen/infinigen-<split>-NNNNNN.tar   ~1 GB WebDataset shards (rgb + depth + metadata)
metadata/registry.jsonl               every scene, layout and Part 3 camera used (for de-duplicating later batches)
metadata/selections/                  layout selection lists
metadata/trajectory_plans.tar         per-layout trajectory plans
metadata/stats.json                   counts and the category histogram
metadata/videos_sha256.json           size and sha256 of every videos/*.tar
```

## Conventions

Scene JSON `frames[frame_id]`:

| Field | Meaning |
|---|---|
| `rgb_path`, `depth_path`, `instance_path` | relative to `videos/` (after extracting the tars) |
| `rgb_intrinsic`, `depth_intrinsic` | 3 × 3 K in pixels, pixel centres at integer coordinates (cx = cy = 511.5) |
| `camera_pose` | 4 × 4 camera-to-world, metres, OpenCV camera axes (+X right, +Y down, +Z forward), world +Z up |
| `original_width`, `original_height` | 1024, 1024 |
| `time_s` | frame time at 15 fps |

Scene JSON `objects[object_id][frame_id]` (only frames where the object is visible):

| Field | Meaning |
|---|---|
| `camera_center` | box centre in the camera frame, metres |
| `camera_scale` | full side lengths, metres, in the order of `camera_R`'s columns |
| `camera_R` | box-local → camera rotation; local Y is the box axis closest to world vertical, pointing down |
| `camera_box_2d_rend` | **2D prompt / 2D target used by the loader**: envelope of the projected cuboid, clipped to the image `[-0.5, W-0.5] × [-0.5, H-0.5]` (same convention as ScanNet val-json and ADT) |
| `camera_box_2d_visible` | box of the visible instance mask |
| `camera_box_2d_proj` | envelope of the projected cuboid, not clipped |
| `category_name`, `visible_pixels` | query text and visible pixel count |

Object-level fields: `3d_category` (query text, Part 3 shared vocabulary with `_` → space), `part3_category`,
`instance_id`, `is_added` (object added by Infinigen layout augmentation). Doors and windows are not exported as objects.

Depth is planar z in millimetres (`default_scale` 1000).

## Using it with spatial_encoder_v2_small

The training code builds an `ObjectDetectionDataset` only for names in `DATASET_IDS`
(`sam3/train/data/object_detection_dataset.py`), so register the source first, e.g.
`DATASET_IDS.setdefault("Infinigen", max(DATASET_IDS.values()) + 1)` in every training process.

**Native files.**

```bash
huggingface-cli download vveicao/infinigen-traj-2k --repo-type dataset --local-dir $INFINIGEN_ROOT \
  --include "videos/*" "Infinigen/*" "dataset/*" "catalog.json"
for f in $INFINIGEN_ROOT/videos/*.tar; do tar -xf "$f" -C $INFINIGEN_ROOT/videos && rm "$f"; done
export INFINIGEN_ROOT
# then train with ++trainer.data.train.dataset.catalog_path=$INFINIGEN_ROOT/catalog.json
```

**WebDataset streaming.** `manifest.json` follows the same schema as the `xxxspatialencoderwds*/data_*` releases, so
`training/prepare_hf_wds.py` can read this repository as one more manifest repo. One sample is a block of 64 clip
starts plus 14 look-ahead frames of one video (the native loader's 15-frame windows); shards mix videos. To add the
source to a lock, include `vveicao/infinigen-traj-2k` in the repos passed to `prepare_lock`, add `"Infinigen"` to
`EXPECTED_SOURCES` (`sam3/train/data/wds_manifest.py`) and to `wds.train_sources` / `wds.val_sources`, and set its
weight in `wds.train_weights`.

## How it was made

- Scenes: Infinigen indoor `.blend` files (Part 1), with camera poses, categories and splits from the matching Part 3
  release; every `.blend` was checked against the Part 3 sha256 (2,000 / 2,000).
- Paths: Dijkstra on a 0.1 m floor grid, at least 0.2 m from walls and objects, then straightened and smoothed;
  height, yaw and pitch interpolated linearly, roll 0; the first and last frames equal the Part 3 camera poses.
  Views keep median depth ≥ 0.8 m and at least 2 trainable objects in ≥ 90 % of frames.
- Rendering: Blender 5.0.1 Cycles, 64 samples + OIDN denoising for RGB; a separate geometry pass for depth and instance ids.
- Categories: the Part 3 name of the same scene object (73 categories here); objects Part 3 does not know (mostly
  architectural pillars) keep the renderer's name.

## Quality checks

- Depth reprojection between adjacent frames (K, poses, depth): ≥ 98.45 % of overlapping pixels agree within 1 %
  (median 99.9 %).
- The spatial_encoder_v2_small training loader reads boxes that match the JSON (< 1e-6 m, 0.02°) on sampled clips.
- WDS shards decode with the repository's own `TarCursor` and `SpatialWDSDecoder`; sample counts match the manifest.

## Differences from real indoor scans

Compared with ScanNet val88: objects are farther from the camera (median 2.68 m vs 2.12 m), cameras are slightly
higher (median 1.62 m vs 1.47 m above the floor), the field of view is wider (median 67° vs 58°), and the category mix
differs (chair 3 % of tracks vs 30 %). In a fine-tuning test, a model trained only on this data shifted its distance
prior and placed ScanNet objects 15–25 % farther; mixing it with real data is recommended.

## Checkpoints

`checkpoints/infinigen_10ep_lr1e-5/` holds SpatialEncoder v2 Small (Lite) fine-tuned on this dataset only (train split),
starting from the e100 checkpoint (`SpatialCoding/Data_verification`, `se_small_lite_wds518_e100/checkpoint.pt`; these
weights derive from it and follow its terms).

- 10 epochs × 1,600 clips per GPU on 8 GPUs (16,000 steps), batch 1 clip per GPU, 518 px, AdamW, learning rate
  1e-5 → 1e-7 cosine (spatial-encoder group 1e-7 → 1e-9), same losses and augmentation as e100.
- `checkpoint_epoch{2,5,10}.pt` are full trainer checkpoints (`model`, `optimizer`, `epoch`, ...), 2.4 GB each;
  `config.yaml` is the resolved training config; `val88_metrics.json` has the scores below.
- Trained on the first version of the scene JSONs, where `camera_box_2d_rend` was the visible-mask box (now
  `camera_box_2d_visible`).

ScanNet val88 (GT 2D-box prompts):

| Checkpoint | F1@0.25 | F1@0.5 | F1@0.1 | 3D IoU |
|---|---|---|---|---|
| e100 (start, not in this repo) | 51.80 | 8.82 | 78.10 | 0.258 |
| epoch 2 | 40.20 | 4.98 | 71.98 | 0.222 |
| epoch 5 | 42.24 | 6.13 | 71.41 | 0.225 |
| epoch 10 | 41.99 | 5.64 | 70.92 | 0.223 |

The drop comes mainly from the model's distance prior shifting toward this dataset's farther objects (see above); the
same checkpoints improve sharply on this dataset's val split (rotation error 32° → 14°, centre error 0.67 → 0.41 m).