---
license: cc-by-4.0
pretty_name: "Syn4D windows with ground-truth Track4D caches (Track4DGEN v3)"
viewer: false
tags:
- 4d
- video
- synthetic
- point-tracking
- depth
- 3d-bounding-boxes
size_categories:
- 1K<n<10K
---

# Syn4D windows with ground-truth Track4D caches (Track4DGEN v3)

5,817 windows cut from **[Syn4D](https://huggingface.co/datasets/Syn4D/Syn4D)** (V1, revision
[`bb08d13f`](https://huggingface.co/datasets/Syn4D/Syn4D/tree/bb08d13faabc0649a4a938030025e9e2b32a6189)), each with an
annotation cache in Track4D's cache format: instance masks, metric depth, cameras, point trajectories and 3D boxes
built from Syn4D's own ground truth, no learned model involved. They are the input of the GPU stage of Track4DGEN's
v3 pair preprocessing (memory / control condition export, target latents, caption embeddings) for SanaTrack training.

This is a derivative of Syn4D, not an official Syn4D release. Please cite Syn4D
([arXiv:2605.05207](https://arxiv.org/abs/2605.05207), [project page](https://jzr99.github.io/Syn4D/)) when you use it.

## Contents

| | |
|---|---|
| Scenes | 29 (Syn4D V1) |
| Windows | 5,817 — 129 / 97 / 65 frames: 2,292 / 2,022 / 1,503 — at 15 fps (every 2nd frame of the 30 fps renders) |
| Default pairs | 12,423 memory → target chunk pairs of 33 frames (gap 0 / 32 / 64 frames: 5,817 / 4,314 / 2,292) |
| Kept by the instance selection | 12,048 pairs (97.0 %), 35,779 of 41,594 instance-pairs (`dynamic_first_v3` with boxes standing on the ground-truth gravity) |
| Captions | every window: Syn4D's captions for 3 scenes, Qwen3-VL-8B-Instruct for the 26 scenes that ship none |
| Size | 108.5 GB (101 GiB) in 29 uncompressed tar shards, one per scene (1.0–7.0 GB) |

Left out: hallway's sequences without tracking records in the source (7 windows), sequences shorter than 65
frames at 15 fps, and the `syn4d_sim` subset.

## Layout

```text
README.md
index_b.jsonl                          one row per window (paths relative to the dataset root)
shards/syn4d_tracks-<scene>.tar        syn4d_tracks/<scene>/<window>/{clip.mp4, track/...}
SHA256SUMS                             every file of this repository
LICENSE  LICENSES/  THIRD_PARTY_NOTICES.md  sequence_to_asset_mapping.csv    Syn4D's, unchanged
```

Download and extract every shard into one folder; the index's paths are relative to it:

```bash
hf download HugMinjun/Syn4D-Track4D-v3 --repo-type dataset --local-dir Syn4D-Track4D-v3
cd Syn4D-Track4D-v3 && sha256sum -c SHA256SUMS && for t in shards/*.tar; do tar -xf "$t"; done
```

Track4DGEN's `tools/syn4d/hf_download.py` does the same scene by scene (checksums, extraction, deleting each tar).

### Index rows (`index_b.jsonl`)

```json
{"path": "syn4d_tracks/arena/seq_000000_0_w0_n129/clip.mp4", "id": "syn4d:arena:seq_000000_0:w0:n129",
 "source_id": "syn4d:arena:seq_000000_0:w0:n129", "caption": "Three individuals are on a wooden platform ...",
 "split": "train", "frames": 129, "tracking_frames": 129, "fps": 15.0,
 "tracks": "syn4d_tracks/arena/seq_000000_0_w0_n129/track", "metric_reference": {"scale": 1.0},
 "gravity_up_world": [0.002167, -0.680545, -0.732703]}
```

- `id`: `syn4d:<scene>:<sequence>:w<window>:n<frames>`; `<scene>` / `<sequence>` are Syn4D's names.
- `gravity_up_world`: the world's up (Unreal's +Z) in the window's coordinate frame, a unit vector, from Syn4D's camera
  CSVs.
- `metric_reference: {"scale": 1.0}`: the caches are already in metres.

### Window folder (`syn4d_tracks/<scene>/<window>/`)

- `clip.mp4`: the window's renders, H.264, 1280 × 720, 15 fps (training crops the centre 704 × 1280).
- `track/compact.npz` (T frames, N tracked instances, Q query points):

| Array | Shape, type | Meaning |
|---|---|---|
| `cam_R`, `cam_t` | (T, 3, 3), (T, 3) float32 | camera-to-world; world = the window's first camera, OpenCV axes, metres |
| `intrinsics` | (T, 3, 3) float32 | at the 308 × 560 tracker resolution (of the 704 × 1280 crop) |
| `depth16` | (T, 308, 560) float16 | z-depth in metres, NaN where invalid |
| `all_masks`, `query_masks` | (T, 704, 1280), (704, 1280) uint8 | 0 background, 1..N tracked moving instances, 200 moving pixels that are not tracked (objects appearing later, pixels that are neither environment nor an object) |
| `fg_prob` | (T, 308, 560) uint8 | foreground probability |
| `traj`, `conf`, `vis_logits` | (T, Q, 3), (T, Q), (T, Q) float32 | world trajectories of the query points, their confidence and visibility |
| `query_xyz`, `query_uv`, `query_instance` | (Q, 3), (Q, 2), (Q,) | the queries in the first frame and their instance |
| `pose`, `T_world_from_canon`, `corners`, `half`, `scale`, `pose_valid` | (N, T, ...) | per-frame 3D boxes of the tracked instances |
| `box0_center`, `box0_R`, `box0_half`, `instance_ids` | (N, ...) | first-frame boxes, instance ids |

- `track/box_refit.{npz,json}`: per-frame boxes re-fitted from the masks and the depth (median size); Track4DGEN's
  cache loader applies them over `compact.npz`'s boxes.
- `track/result.json`: per-instance metadata and the Syn4D source (`syn4d`: scene, sequence, frame range, groups);
  `track/observations.json`, `track/sampling.json`: Track4DGEN's observation and sampling metadata.

## How it was made

From Syn4D V1 (stride-1 bundle: frames, depth, masks, cameras and tracking records; stride-5 bundle: the window
index, captions and the camera CSVs for the gravity), on CPUs only (Track4DGEN `tools/syn4d`, branch `datasets/syn4d`):

1. Windows of 129 / 97 / 65 frames at 15 fps over each sequence.
2. Cameras: Syn4D's CSV rows (Unreal centimetres, left-handed) to OpenCV camera-to-world in metres, relative to the
   window's first camera. Depth: EXR depth ÷ 100.
3. Instances: one per Syn4D mesh group (a person's body and clothing are one instance). Since every Syn4D object is
   animated, an object counts as static only if the 90th percentile of its faces' displacement stays under 1 cm;
   moving objects visible in the first frame are tracked, the others get id 200.
4. Trajectories: each query's first-frame mesh face is found again in every frame through Syn4D's tracking records.
5. Boxes: Track4D's fitting code, then re-fitted per frame from masks and depth.
6. Captions: the sequence's Syn4D caption where the scene ships them, otherwise Qwen3-VL-8B-Instruct (`0c351dd`) over
   8 frames of the sequence.

The renders, depth, masks, cameras and tracking records are Syn4D's; this dataset changes their frame rate, crops,
units and coordinate frames, and adds the caches and the generated captions.

## License and third-party assets

Released under **CC BY 4.0**, like Syn4D. Syn4D's `LICENSE`, `LICENSES/`, `THIRD_PARTY_NOTICES.md` and
`sequence_to_asset_mapping.csv` are included unchanged and apply to this dataset as they do to Syn4D:

- **BEDLAM2**: every sequence of these 29 scenes depends on BEDLAM2 bodies (`asset_type` `bedlam2_body` in the mapping).
  As for Syn4D, no BEDLAM2 data is redistributed here, and you must obtain BEDLAM2 from its official source and agree
  to the BEDLAM2 license before using BEDLAM2-dependent sequences.
- Fab / Unreal scenes (Fab Standard License), Objaverse objects (ODC-By 1.0, each object under its own license),
  Google Scanned Objects (CC BY 4.0): see `THIRD_PARTY_NOTICES.md`. No rights to third-party assets are granted.