Lattice_4D_Dataset

Multi-camera volumetric captures of people doing everyday tasks (ball handling, shirt folding). Four synchronised 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, per-frame action labels, reviewed language and rendered orbit videos. A USD skeleton and a URDF rig let a robotics consumer load the body.

The action orbit of dataset_balls_p1_2 with the fitted body and hands drawn on it. It 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 skeleton of frame 0
rgb = take.rgb(cam=0, frame=0)      # (H, W, 3) uint8
depth = take.depth(cam=0, frame=0)  # (H, W) float32 metres, 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 measurements
  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. A .ltrc over 100 GiB is published as <file>.part-NNNNN pieces: concatenate them in order. 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, measured 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 completely.

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. Every other stored field is exact: 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 every stream. 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. 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. Each take's README.md states its consent record.

Faces are removed at the source, before any published picture is written. The head-ellipse writer paints the projected ellipsoid of each tracked head, refined by face detections, into every camera picture. Each rendered orbit drops the face points in 3-D before the render exists. Every take carries its receipt at takes/<take>/meta/redaction.json. Per camera and per orbit, it gives the frames with a measured head and the frames that got a box. So the claim can be checked, not trusted. We measured every 5th frame of every camera of all 33 takes against an independent face detector. 99.56% of detector-confirmed face pixels are covered. 8 of 2,109 sampled confirmed faces are less than half covered: partly turned faces at the edge of the painted head.

Redaction does NOT remove head GEOMETRY from the depth maps and the 3-D reconstruction (their colours come from the painted pictures). An orbit's face removal is a zero-margin ball, so hairline, ear and jaw points just outside it still render.

Takes

take	frames	rate (Hz)	orbits	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 measured depth, view coverage, timing, hand tracking, and the value of the data for training and simulation. All recordings come from one room and one rig of four calibrated RGB-D (colour and depth) cameras.

A take is one recording. A held-out camera is a camera whose data no method receives. We use it only to score the result.

On this dataset's takes

Measurement	Result	n	Caveat
View coverage	One camera sees 31.7% of the surface that a held-out fourth camera sees. Three cameras see 59.9%. Higher is better.	1 take (dataset_balls_p1_2), 8 frames	A point counts as seen if the two depths agree within 50 mm. This rule makes the gap smaller, not larger.
Single-image depth model	Depth Anything 3 differs from the rig's depth by 95.9 mm (median), after one free scale correction. Lower means closer agreement.	1 take, 4 frames × 4 cameras	The rig's depth is a sensor measurement, not ground truth. This number is disagreement, not error.
Frame timing	The median frame rate is 59.999 to 60.000 frames per second (fps). A median 87% of frame intervals are within 0.05 ms of 1/60 s (85% to 95% per take).	4 ball takes (p1_1, p1_2, p3_2, p4_5)	Some frames are missing. The longest gap is 133 ms. We did not measure the shirt takes.

Known limits

Measurement	Result	n	Caveat
Fingertip noise	Near grasp and release, fingertip position noise is about 9 to 10 mm per axis (median over takes, 4.8 to 11.4 mm per take). Lower is better.	17 ball takes, 123 grasp and release events	This is a lower bound on hand error. The method cannot detect slow or shared errors.
Hand bone lengths	The exported hand skeleton does not keep its bone lengths constant. One fingertip bone has a median length of 21 mm but goes from 1.7 to 292 mm.	32 takes, 59,100 hand frames	This is a self-consistency check. No ground truth for hand shape exists. Do not treat fingertip bones as rigid. dataset_shirt_p4_4 has no usable hand frames.

On earlier takes from the same rig (not in this dataset)

These results come from earlier recordings in the same room with the same rig. Those recordings are not in this dataset. Most are cloth-folding takes of a bag or a T-shirt.

Depth and coverage

Measurement	Result	n	Caveat
Depth of a held-out camera	Three fused cameras predict a fourth camera's depth with a relative error (AbsRel) of 6.13 × 10⁻³. The best other method, MapAnything with true camera intrinsics, scores 18.03 × 10⁻³. Lower is better.	5 takes, 160 scored views per method	AbsRel is the mean absolute depth error divided by the true depth. The ground truth is the held-out camera's own depth.
Coverage of a held-out camera	Three fused cameras cover 61.4% of the held-out view. One camera covers 29.3%. Multi-view models cover 8.7% to 15.3%. Higher is better.	5 takes, 160 scored views per method	UniDepthV2 and MoGe-2 cover about 65%, but their error is about 10 times higher. One camera alone has almost the same error (6.56 × 10⁻³). The gain is coverage.
Plain fusion vs this dataset's reconstruction	The two rows above use plain fusion of raw camera depth. This dataset's reconstruction scored the same, by factors from 0.988 to 1.011.	5 takes, 340 scored views	This is a null result, not proof that the two are equal.
Metric scale against a tape measure	Ball radius error is −0.77% (−0.8 mm). Bag area error is +1.0%. Values nearer zero are better.	1 ball, 1 bag	Single-image models MoGe-2 and UniDepthV2 read the same bag area as +32.2% and +42.3%. One multi-view model, MapAnything, also gets metric scale from images alone.
Scale of single-image metric models	Off-the-shelf single-image metric models have a scale error of 4% (median) and 11% (worst). At 3 m, this is 120 to 330 mm.	5 takes × 4 cameras	Their shape is close to correct. Scale is the main gap.
Hand position vs camera count	Hand error at grasps, scored in a held-out camera: 27.5 mm with 1 camera, 22.0 mm with 2, 14.9 mm with 3. Lower is better.	5 bag takes, 24 grasps, 1 operator	The error includes the held-out camera's own detection error. We cannot score four cameras this way.
Body and hand joints	One camera has 1.72 times the joint error of three cameras (median, range 1.06 to 2.28). Lower is better.	13 captures, one camera worse in 13 of 13	The baseline is our own single-camera mode, not a standard single-camera pipeline.

Training ablations

An ablation trains the same model more than once and changes only one input.

Measurement	Result	n	Caveat
Metric depth model on an unseen camera	Fine-tuning on three cameras instead of one lowers the error by 20% to 34%. Lower error is better.	5 takes, 3 seeds, 2 model architectures, equal training budget	Most of the gain comes from seeing more camera units. One architecture failed one of its own checks, so its result is weaker.
Same model, coverage only	With the same input images, labels from more cameras lower the error by 12.7% (11.67 mm) on surface that one camera never saw.	5 takes, better in 3 of 3 seeds	This is a separate measurement. Do not add it to the row above.
Per-scene 3-D shape model	A model trained on four cameras has 22% lower error (11.70 mm) on unseen surface than one trained on one camera.	120 cells (5 takes × 4 frames × 2 regions × 3 seeds)	This applies to a model fitted to one scene only.
Depth precision (null)	Better depth precision gave no measurable gain (+0.18 mm, and the sign was not stable). We tested this six ways.	6 tests	We tested only near 6 mm of noise. Larger errors, such as single-image depth, are a different case.
Label fusion (null)	Fusing depth labels across cameras gave no gain (+0.41%).	1 test, 3 cameras	Each camera already returns valid depth on 98.47% of its own pixels.

Cloth folding (real-to-sim)

Real-to-sim means that we build a simulated copy of the cloth (a twin) from the recording. We replay the demonstrated motion and compare the twin with the real cloth.

Measurement	Result	n	Caveat
Cloth surface from measurement vs by hand	A cloth surface built from the recording matches a held-out camera to 0.80 to 0.88 mm. A hand-built surface scores 1.29 to 2.07 mm. Lower is better.	5 takes, 2 objects (bag, T-shirt), better in 5 of 5	This scores the simulated surface, not the fold motion. We made the hand-built baseline as strong as possible.
Three cameras vs best single camera (null)	Twins from three cameras and from the best single camera drift equally from the real cloth. The difference, +5.5 mm for three cameras, is inside the 7.7 mm noise band.	1 bag take, 6 repeats per condition	Earlier twin versions gave −6.4 to +8.0 mm, so we report no difference. Only one single-camera twin could be built.
Twin vs untouched cloth (null)	No replay of the human motion beats a twin that does not move. Untouched: 663 mm·s. Best replay: 713 mm·s. Lower is better.	1 bag take, 6 replays	mm·s is the distance to the real cloth, added up over time. The real cloth ends near its start shape, so the untouched twin is a strong control.
Effect of the reconstruction on the simulation	When only the reconstruction changes, the twin's motion changes 3.4 times more than its start shape. The pass bar, set before the test, was 2.0 times.	1 take, 5 repeats of the reference	This compares simulation with simulation. It shows that the reconstruction matters, not which one is correct. Only the first 15.2 s is above run-to-run noise.

Robot policy (simulated, not from recorded takes)

This test ran in a simulated world. It does not use any recorded take.

Measurement	Result	n	Caveat
Persistent 3-D map vs current view only	A model of a Dexmate Vega humanoid robot unplugs and plugs an RJ45 cable. With a map that keeps all past views, 24 of 60 runs complete. With only the current view, 0 of 60 complete.	60 random table setups, 1 seed	There was no physics engine and no real robot. Each completion needed a person to hand over the cable. Without handovers, both get 0 of 60. Neither arm made an unsafe move. A control gave the same outcome but not the same motion.

Limitations

Body, hand and object labels are automatic estimates, not human-certified ground truth. Each file carries its own confidence, validity and observed/inferred masks. A human reviewed the language. Nobody reviewed the action labels. Orbit videos are renders, not more physical cameras.

Affordances are NOT measured. Nothing in this pipeline measures what an object affords, and no affordance column is emitted or inferred from the contacts and supports.

Gravity is NOT this corpus's own measurement. Every interaction layer carries a scene_state.gravity block whose measured_g_m_s2 is null and whose refused says why. The block's reference (9.8658 m/s^2, CI95 [9.716, 10.271], 35 descents) was measured on seven takes this dataset does not publish. It travels with a refusal_arm: the same estimator refuses on a dribbled ball, where the apex of a descent falls before the last hand contact. This corpus's ball take is the worked example. It IS published here: 22 action labels, and its gravity block is refused all the same.