Multi-camera volumetric captures of people doing everyday tasks (ball handling, shirt folding). Four RGB-D cameras record each take. Each take has the reconstructed 3-D scene of every frame and the fitted body and hands. It also has calibration, camera poses, action labels over frame spans, reviewed language and rendered orbit videos. A USD skeleton and a URDF rig let a robotics consumer load the body.

Ball handling: the person drops the ball to bounce off the floor and catches it with alternating hands. (`dataset_balls_p1_2`)

Shirt folding: the person unfolds and smooths the shirt on the table, then folds it into a compact stack. (`dataset_shirt_p1_3`)

The action orbits with the fitted body and hands drawn on them. Each is a virtual camera rendered from the reconstruction, not a physical camera.

Quick start

Download the shared code and one take. Restore the depth images from their tar shards, then load the take with code/loader.py. It needs the Python packages numpy, zstandard and huggingface_hub, and ffmpeg for the RGB videos.

import pathlib, sys, tarfile
from huggingface_hub import snapshot_download

root = pathlib.Path(snapshot_download(
    "latticecx/Lattice_4D_Dataset", repo_type="dataset", local_dir="lattice4d",
    allow_patterns=["code/*", "takes/dataset_balls_p1_2/*"]))  # ignore_patterns=["*.ltrc"] skips the 3-D scene
take_dir = root / "takes/dataset_balls_p1_2"
for shard in sorted(take_dir.rglob("*.shard-*.tar")):  # depth images, packed for the Hub
    with tarfile.open(shard) as archive:
        archive.extractall(take_dir, filter="data")

sys.path.insert(0, str(root / "code"))
from loader import Take

take = Take(take_dir)
print(take.n_frames, take.n_cams, take.fps)
points = take.points(0)             # (P, 3) float32 world positions, metres
skeleton = take.skeleton(0)         # the fused bodies of frame 0, [] when none was tracked
rgb = take.rgb(cam=0, frame=0)      # (H, W, 3) uint8
depth = take.depth(cam=0, frame=0)  # (H, W) float32 metres, raw, 0 is invalid

code/example.ipynb is a longer walkthrough.

Folders

README.md          this card
LICENSE.md         the licence of every take (cc-by-4.0)
code/              loader.py, ltrc_decoder.py, example.ipynb: one copy for every take
index/             takes.jsonl and actions.jsonl (the viewer tables), takes.json
takes/<take>/
  README.md        what this take holds, its licence and consent, its provenance
  cameras/         calibration, camera poses, timestamps, RGB videos, depth images
  scene/           the 3-D reconstruction (<take>.ltrc and its index), room.json
  body/            2-D and 3-D keypoints, the fused skeleton, the body and hand fit
  models/          the USD skeleton animation, the URDF rig, its bone-length table
  labels/          actions.json, interaction.json, objects.json
  orbit/           the rendered orbit videos, their poses and depth
  meta/            provenance.json, quality/, redaction.json, checksums.sha256

Folders of many per-frame files (depth images) are uncompressed tar shards. Extract every *.shard-NNNNN.tar in takes/<take>/ to restore them. takes/<take>/meta/checksums.sha256 then verifies the take. Each <folder>.shards.json gives the sha256 and byte offset of every member, so one frame can be read with an HTTP range request.

Files in each take

index/takes.jsonl gives each take's repo path for every row here (its scene_ltrc, decoder, usd, urdf, skeleton and calibration columns).

path	what it is	how to load it
`takes/<take>/scene/<take>.ltrc`	the 3-D reconstruction, every frame, indexed by `scene/<take>.ltrc.idx`	`loader.Take('takes/<take>').points(frame)`, or `ltrc_decoder.open_ltrc(path).read_frame(frame)`
`code/ltrc_decoder.py`	the standalone `.ltrc` decoder (Apache-2.0), one copy for every take	`import ltrc_decoder` with `code/` on `sys.path` (`pip install numpy zstandard`)
`takes/<take>/models/<take>.usd`	UsdSkel skeleton and animation of the fitted body	`pxr.Usd.Stage.Open(path)` (`pip install usd-core`)
`takes/<take>/models/<take>.urdf`	the static rig: links, joints, the fitted body's bone lengths	`yourdfpy.URDF.load(path, load_meshes=False)` (`pip install yourdfpy`)
`takes/<take>/body/skeleton.jsonl`	the fused 3-D skeleton, one JSON line per frame	`loader.Take('takes/<take>').skeleton(frame)`
`takes/<take>/cameras/calibration.json`	per-camera intrinsics and row-major `cam_to_world` extrinsics (metres), world up	`json.load`

Decode one frame of the reconstruction without the loader:

import sys; sys.path.insert(0, "lattice4d/code")
import ltrc_decoder as ld
scene = ld.open_ltrc("lattice4d/takes/dataset_balls_p1_2/scene/dataset_balls_p1_2.ltrc")  # reads the .ltrc.idx beside it
arrays = scene.read_frame(scene.frames[0])            # dict of NumPy arrays, one row per point
xyz, rgb = arrays["positions"], arrays["rgb"]         # (N, 3) float32 metres, (N, 3) uint8

Load the skeleton animation and the rig (pip install usd-core yourdfpy):

from pxr import Usd; stage = Usd.Stage.Open("lattice4d/takes/dataset_balls_p1_2/models/dataset_balls_p1_2.usd")
import yourdfpy; rig = yourdfpy.URDF.load("lattice4d/takes/dataset_balls_p1_2/models/dataset_balls_p1_2.urdf", load_meshes=False)
print(stage.GetEndTimeCode(), len(rig.actuated_joint_names))

The 3-D reconstruction

takes/<take>/scene/<take>.ltrc holds every frame, indexed by <take>.ltrc.idx. code/ltrc_decoder.py is a standalone decoder. It needs NumPy and zstandard (pip install numpy zstandard). This command writes the arrays of one frame as .npy files: python code/ltrc_decoder.py <file>.ltrc --frame N --out DIR. The arrays are positions, normals, rgb, sigma, camera and contributor fields, uv, classes and flags. The decoder's docstring documents the byte format.

The .ltrc is the reconstruction as the pipeline stores it, not the internal float export. Positions are on a 0.5 mm grid. Normals are rounded to a 12-bit octahedral code. Sigma is rounded to 0.1 mm steps and saturates at 102.3 mm. There is no per-camera colour (rgb_per_cam), only the winning camera's rgb. Per-point pixels (uv) are the owner camera's only. The meta of each frame carries frame, timestamp, kind and point count only. The other fields are stored as integers with no rounding step: camera, contributor mask, colour, motion and source class, flags, confidence and footprint. Points are stored in spatial (Morton) order, so a row number means nothing across frames or files. The contributor mask and uv are rebuilt exactly.

Conventions: the frame index joins the depth images, the body files, the labels and the reconstruction. An RGB video holds more pictures than the take has frames. The picture of frame i in camera c is rgb_picture_index[i][c] in cameras/timestamps.json, and Take.rgb looks it up. An orbit's poses.json gives the source frame of each output frame. World coordinates are right-handed metres, with the up vector declared per take in cameras/calibration.json. Extrinsics are row-major cam_to_world. Depth is uint16 millimetres, 0 invalid. It is the cameras' raw depth: calibration.json says depth_is_corrected: false and gives the correction. Timestamps are int64 nanoseconds.

Licence

cc-by-4.0 (Creative Commons Attribution 4.0 International), stated in LICENSE.md. Each take's meta/provenance.json states the same terms as fields under delivery.use_restrictions. Do not attempt to identify the people recorded.

Consent and face redaction

The operator attests that every person recorded in these takes consented to their public release under this licence (2026-09-29). This includes commercial use, model training and biometric processing. All are adults. The record is the operator's attestation: no person signed a form. Each take's README.md states its consent record.

Faces in the camera pictures are painted out before publication. Every take carries its receipt at takes/<take>/meta/redaction.json. Its policy field records how the faces were painted. Per camera and per orbit video, it gives the frames with a measured head and the frames that got a box.

Redaction does NOT remove all head GEOMETRY. The 3-D reconstruction holds points on the head, and the depth images keep valid depth on parts of it.

Takes

take	frames	rate (Hz)	orbit videos	action labels	files	GB	content sha256	published (UTC)
`dataset_balls_p1_1`	453	60.002	2	27	47	23.26	`a9ce5db78c1a`	2026-10-03T05:25:53Z
`dataset_balls_p1_2`	415	60.002	2	22	47	21.46	`c0421f3c9e89`	2026-10-04T11:56:25Z
`dataset_balls_p1_3`	647	60.002	2	30	47	33.49	`a0d4df20de0f`	2026-10-02T07:14:54Z
`dataset_balls_p1_4`	679	59.999	2	41	47	35.14	`007d783b844b`	2026-10-03T08:20:42Z
`dataset_balls_p1_5`	746	60.002	2	41	47	38.40	`49bc0a425617`	2026-10-02T05:41:24Z
`dataset_balls_p2_1`	575	60.002	2	43	47	29.59	`16cd05c89876`	2026-10-03T05:59:20Z
`dataset_balls_p2_2`	626	59.999	2	15	47	32.28	`97ea30093e46`	2026-10-03T06:13:54Z
`dataset_balls_p2_3`	744	59.999	2	12	47	38.30	`6a80562358bb`	2026-10-03T06:30:28Z
`dataset_balls_p2_4`	987	60.002	2	53	47	51.19	`7e3ecadd3cc4`	2026-10-02T06:27:52Z
`dataset_balls_p3_1`	492	59.999	2	31	47	25.39	`f204dacc102f`	2026-10-03T04:15:57Z
`dataset_balls_p3_2`	831	60.002	2	45	47	43.19	`06107764ccf4`	2026-10-03T09:05:12Z
`dataset_balls_p3_3`	821	59.999	2	31	47	42.75	`bf3a923966c6`	2026-10-03T08:56:38Z
`dataset_balls_p3_4`	676	60.002	2	31	47	35.00	`3961325786cf`	2026-10-03T06:08:48Z
`dataset_balls_p4_1`	620	60.002	2	40	47	32.60	`6135f8fc8ddf`	2026-10-03T06:08:02Z
`dataset_balls_p4_2`	569	59.999	2	39	47	29.66	`e0a6f7716fdb`	2026-10-03T06:31:01Z
`dataset_balls_p4_3`	611	59.999	2	52	47	32.11	`c62273950911`	2026-10-03T02:27:03Z
`dataset_balls_p4_4`	558	59.999	2	54	47	29.11	`4e68a6ceb2bb`	2026-10-03T07:28:47Z
`dataset_balls_p4_5`	893	59.999	2	32	47	46.82	`6719519b4185`	2026-10-03T09:10:31Z
`dataset_shirt_p1_1`	1793	59.999	2	108	48	95.52	`f1cbd24428e2`	2026-10-04T09:21:02Z
`dataset_shirt_p1_2`	1236	59.999	2	28	47	66.20	`3bb058763a8d`	2026-10-03T08:10:59Z
`dataset_shirt_p1_3`	881	59.999	2	24	47	46.83	`5f88b46b995e`	2026-10-03T23:05:48Z
`dataset_shirt_p1_4`	1395	59.999	2	62	47	74.25	`73a7ca1444a5`	2026-10-03T08:48:06Z
`dataset_shirt_p1_5`	1274	59.999	2	32	47	67.51	`f82b0ece7224`	2026-10-03T14:36:22Z
`dataset_shirt_p3_1`	771	59.999	2	114	47	40.90	`b531c96721d1`	2026-10-03T12:47:33Z
`dataset_shirt_p3_2`	1070	59.999	2	138	47	57.12	`524a0a7f7f99`	2026-10-03T07:34:44Z
`dataset_shirt_p3_3`	1633	59.999	2	109	48	85.89	`a47f1c20f8df`	2026-10-02T10:10:12Z
`dataset_shirt_p3_4`	1278	59.999	2	85	47	67.16	`c9aee7ce5842`	2026-10-03T08:21:34Z
`dataset_shirt_p3_5`	1567	59.999	2	99	48	82.29	`a8caa8b0cace`	2026-10-03T11:29:56Z
`dataset_shirt_p4_1`	1037	59.999	2	27	47	54.92	`6331dceb71b9`	2026-10-03T07:47:54Z
`dataset_shirt_p4_2`	1400	59.999	2	33	47	74.06	`04dbd2c633a1`	2026-10-03T11:35:27Z
`dataset_shirt_p4_3`	855	59.999	2	39	47	45.70	`4d332056f62c`	2026-10-03T09:18:56Z
`dataset_shirt_p4_4`	1269	59.999	2	87	47	67.68	`58cfd08a5827`	2026-10-03T08:32:39Z
`dataset_shirt_p4_5`	1417	59.999	2	106	47	75.24	`6442ed53d6b5`	2026-10-03T09:26:17Z

Benchmarks

We re-checked the result below on 2026-10-08 against its saved measurement. The "Data" column says whether it was measured on this dataset's takes.

A take is one recording.

Cloth folding twin (on an earlier take, not in this dataset)

We build a simulated copy of the cloth (a twin) from one recording of a bag fold. The measured hands drive the twin, and physics decides the cloth. We compare the twin with the real cloth. The take, bag_fold_thirds_2_real, is from the same room and rig, but it is not in this dataset.

Divergence is the distance from the twin to the real cloth's visible surface, added up over time, in mm·s. Lower is better. D is the difference of the mean divergence of two twins, over 20 fresh replays each. A twin is lower in a window when D is below −2 standard errors (2 SE). We score the whole take and four windows: fold 0, fold 1, unfold 1 and unfold 0. Each test and its pass rule was registered before its replays ran.

Measurement	Result	n	Data	Caveat
Lattice hands vs an untouched twin (goal 1, registered)	Pass. The twin driven by the Lattice 4-camera hands is lower than an untouched twin in all five windows. D (2 SE), mm·s: whole take −90.34 (11.47), fold 0 −1.36 (0.14), fold 1 −38.13 (6.94), unfold 1 −12.07 (1.01), unfold 0 −6.98 (0.48).	1 take, 20 fresh replays per twin	Not in this dataset (`bag_fold_thirds_2_real`)	A second, independent set of 20 fresh replays passes again in all five windows: whole take −96.46 (2 SE 12.32). The simulation is not deterministic, so each twin is replayed 20 times.

Limitations

Body, hand and object labels are automatic estimates, not human-certified ground truth. body/skeleton.jsonl and body/mhr_pose.npz carry per-joint confidence or validity and observed/inferred masks. A human reviewed the language (labels/actions.json). The action labels carry no review record. Orbit videos are renders, not more physical cameras.

Affordances are NOT measured. No published file has an affordance field, and none is inferred from the contacts and supports.

Gravity is NOT measured in this corpus. In every take's labels/interaction.json, scene_state.gravity.measured_g_m_s2 is null and refused says why. The block's reference value was measured on seven takes this dataset does not publish, so this dataset cannot check it.

Downloads last month: 2,482

Total file size:

1.62 TB