Lattice_4D_Dataset

Multi-camera volumetric captures of people performing everyday tasks (ball handling, shirt folding): four synchronised RGB-D cameras, the reconstructed 3-D scene per frame, rendered novel views with the fitted skeleton drawn on, the fitted body and hands, calibration and poses, per-frame action labels and reviewed language, and a URDF/USD rig a robotics consumer can load.

Licence

cc-by-4.0 (Creative Commons Attribution 4.0 International). Each take's provenance.json states the same terms as fields under 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, including commercial use, model training and biometric processing, and that all are adults (2026-09-29). Each take's LICENSE.md carries its consent record's statement.

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

What redaction does NOT remove: depth maps and the 3-D reconstruction carry head GEOMETRY (the colours there 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.

Layout

Each take lives under takes/<take>/; takes/<take>/TAKE.md lists what it carries and its provenance. Directories of many per-frame files (depth PNGs, orbit depth) are published as uncompressed tar shards: extract every *.shard-NNNNN.tar at takes/<take>/, and concatenate any <file>.part-NNNNN pieces (a .ltrc over 100 GiB) in order, to restore the bundle layout exactly, then check it against takes/<take>/checksums.sha256. Each <dir>.shards.json gives every member's sha256 and byte offset, so a single frame can be fetched with an HTTP range request. index/takes.json is the machine-readable list below.

Files in each take

Paths are relative to takes/<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
scene/<take>.ltrc	the 3-D reconstruction, every frame, indexed by scene/<take>.ltrc.idx	ltrc_decoder.open_ltrc(path).read_frame(frame), or loader.Take('.').points(frame)
ltrc_decoder.py	the standalone .ltrc decoder (Apache-2.0)	import ltrc_decoder (pip install numpy zstandard)
usd/<take>.usd	UsdSkel skeleton and animation of the fitted body	pxr.Usd.Stage.Open(path) (pip install usd-core)
rig/<take>.urdf	the static rig: links, joints, measured bone lengths	yourdfpy.URDF.load(path, load_meshes=False) (pip install yourdfpy)
body/skeleton.jsonl	the fused 3-D skeleton, one JSON line per frame	loader.Take('.').skeleton(frame)
calibration.json	per-camera intrinsics and row-major cam_to_world extrinsics (metres), world up	json.load

Decode one frame of the reconstruction, inside a downloaded take's directory (pip install numpy zstandard):

import ltrc_decoder as ld
take = ld.open_ltrc("scene/dataset_balls_p1_2.ltrc")    # reads the .ltrc.idx beside it
arrays = take.read_frame(take.frames[0])              # dict of NumPy arrays, one row per point
xyz, rgb = arrays["positions"], arrays["rgb"]         # (N, 3) float32 metres, (N, 3) uint8
print(len(take.frames), xyz.shape, rgb.dtype)

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

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

The 3-D reconstruction

Every frame of every take is in takes/<take>/scene/<take>.ltrc, indexed by <take>.ltrc.idx. takes/<take>/ltrc_decoder.py is a standalone decoder (pip install numpy zstandard): Take('.').points(frame) in loader.py, or python ltrc_decoder.py scene/<take>.ltrc --frame N --out DIR for that frame's arrays (positions, normals, rgb, sigma, camera and contributor fields, uv, classes and flags) as .npy; its docstring documents the byte format completely. The decoder's own code licence is stated in its header.

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 and sigma to 0.1 mm steps (saturating at 102.3 mm), there is no per-camera colour (rgb_per_cam; only the winning camera's rgb), per- point pixels are the owner camera's only (uv), and the per-frame meta carries frame, timestamp, kind and point count only. Every other stored field (camera, contributor mask, colour, motion/source class, flags, confidence, footprint) is exact. 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: frame index joins every stream; world coordinates are right-handed metres with the up vector declared per take in calibration.json; extrinsics are row-major cam_to_world; depth is uint16 millimetres, 0 invalid; timestamps are int64 nanoseconds.

Takes

take	frames	rate (Hz)	orbits	action labels	files	GB	content sha256	published (UTC)
dataset_balls_p1_1	453	60.002	2	27	57	23.84	45c80894fd8f	2026-10-03T05:25:53Z
dataset_balls_p1_2	415	60.002	2	22	57	22.01	3b051f5b985f	2026-10-02T02:56:37Z
dataset_balls_p1_3	647	60.002	2	30	57	34.31	efeb13b5f512	2026-10-02T07:14:54Z
dataset_balls_p1_5	746	60.002	2	41	57	39.41	be3c0df89a11	2026-10-02T05:41:24Z
dataset_balls_p2_1	575	60.002	2	43	57	30.34	b262d7d947bd	2026-10-03T05:59:20Z
dataset_balls_p2_2	626	59.999	2	15	57	33.10	6908cf075840	2026-10-03T06:13:54Z
dataset_balls_p2_3	744	59.999	2	12	57	39.26	72fff085315a	2026-10-03T06:30:28Z
dataset_balls_p2_4	987	60.002	2	53	57	52.52	65f9e34e346d	2026-10-02T06:27:52Z
dataset_balls_p3_1	492	59.999	2	31	57	26.05	a5ef5be181f8	2026-10-03T04:15:57Z
dataset_balls_p3_4	676	60.002	2	31	57	35.93	38a301a9763c	2026-10-03T06:08:48Z
dataset_balls_p4_1	620	60.002	2	40	57	33.45	09778bb98682	2026-10-03T06:08:02Z
dataset_balls_p4_2	569	59.999	2	39	57	30.42	72037b2b6b8c	2026-10-03T06:31:01Z
dataset_balls_p4_3	611	59.999	2	52	57	32.92	90fcc453e239	2026-10-03T02:27:03Z
dataset_shirt_p3_3	1633	59.999	2	109	59	88.16	d5dfa216d557	2026-10-02T10:10:12Z

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. An affordance guessed from a grasp would be a claim no control arm here can refuse.

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, and it travels with a refusal_arm: the same estimator refuses on a dribbled ball, where a descent's apex 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.

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. The language was reviewed by a human; the action labels were not. Novel views are renders, not additional physical cameras.