Get the Lattice 4D Dataset

Free under CC-BY-4.0. Five quick questions, and access is instant. We use the answers only to understand who uses the dataset.

By getting access you agree not to attempt to identify the people recorded in this dataset.

Log in or Sign Up to review the conditions and access this dataset content.

Lattice_4D_Dataset

Multi-camera volumetric captures of people doing everyday tasks with their hands (ball handling, shirt folding): 33 takes, four RGB-D cameras, the 3-D reconstruction of every frame, the fitted body and hands, reviewed language, and a persistent 3-D world state.

Quickstart

from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata  # pip install lerobot
repo = "latticecx/Lattice_4D_Dataset"
episodes = list(range(LeRobotDatasetMetadata(repo).total_episodes))  # downloads meta/ only
ds = LeRobotDataset(repo, episodes=episodes)  # 33 takes, 35 episodes, 30,763 frames
item = ds[0]  # 4 camera images, human body and hands, the step's text, a unitree_g1 example action

The LeRobot dataset is at the root of this repo (meta/, data/, videos/, 0.90 GB), beside the take folders (takes/). With episodes named, LeRobotDataset downloads only those three folders. If you leave episodes out, it downloads the whole repo (1.66 TB with every take folder). The take folders hold each take's full files: depth, the 3-D reconstruction, the world state, the USD room and the body fit. The repo is gated: accept the terms on this page and log in with hf auth login. One take loads with LeRobotDataset(repo, episode_filter=lambda e: e["take"] == "dataset_balls_p1_2"), which downloads only the files that hold that take's episodes.

Each take also has SMPL-X body and MANO hand parameters, for retargeting to any robot (the model files are not included; use your own copy):

import numpy as np
from huggingface_hub import hf_hub_download
smplx = np.load(hf_hub_download("latticecx/Lattice_4D_Dataset", "takes/dataset_balls_p1_2/body/smplx.npz", repo_type="dataset"))
mano = np.load(hf_hub_download("latticecx/Lattice_4D_Dataset", "takes/dataset_balls_p1_2/body/mano.npz", repo_type="dataset"))

What is in it

Every file of a take folder of this repo. T is the take's frame count. World coordinates are right-handed metres, with the up vector declared per take (cameras/calibration.json world_up_vector).

path shape units frame what
takes/<take>/cameras/rgb/cam_N.mp4 1200 x 1920 x 3 per picture 8-bit RGB camera N the face-redacted video (HEVC); frame i is picture timestamps.json rgb_picture_index[i][N]
takes/<take>/cameras/depth/cam_N/frame_NNNNNN.png 1200 x 1920 uint16 mm, 0 invalid camera N raw depth, packed in *.shard-NNNNN.tar; the correction is in calibration.json
takes/<take>/cameras/calibration.json per camera: fx, fy, cx, cy; 4 x 4 cam_to_world pixels; metres world intrinsics, row-major extrinsics, world_up_vector
takes/<take>/cameras/timestamps.json (T,) ns - the capture clock of each frame and the picture index of each camera
takes/<take>/scene/<take>.ltrc per frame: positions (P, 3), rgb (P, 3), normals, sigma metres; uint8 world the 3-D reconstruction of every frame
takes/<take>/body/mhr_pose.npz pos38 (T, 38, 3), hand_pos21 (T, 2, 21, 3), masks; pose136 (T, 136), scale68 (68,), identity45 (45,); floor_plane (4,) metres; MHR parameters world the fitted body (38 joints) and hands (21 joints each), NaN or valid False where nothing was measured; the MHR body-model parameters of the fit (the NVIDIA V2D body layout); the floor ax + by + cz + d = 0
takes/<take>/body/smplx.npz global_orient (T, 3), body_pose (T, 63), left_hand_pose / right_hand_pose (T, 45), transl (T, 3), betas (10,), valid (T,) axis-angle rad; metres world SMPL-X body parameters (neutral, 10 betas); the model file is not included
takes/<take>/body/mano.npz per hand: <side>_global_orient (T, 3), <side>_hand_pose (T, 45), <side>_transl (T, 3), <side>_betas (10,), <side>_valid (T,) axis-angle rad; metres world MANO hand parameters; NaN where the hand was not measured; the model files are not included
takes/<take>/body/skeleton.jsonl one line per frame metres world the fused 3-D skeleton with per-joint confidence
takes/<take>/models/<take>.usd room mesh, floor, cameras, UsdSkel animation metres USD stage, Z up the take as one USD stage
takes/<take>/models/<take>.room.obj, .room.xml vertices with colour, triangles metres world (.room.xml: Z up) the room mesh, and a MuJoCo model of it
takes/<take>/models/<take>.urdf links and joints metres - the static rig with the fitted body's bone lengths
takes/<take>/labels/actions.json spans of frames with text frames - the reviewed language
takes/<take>/labels/interaction.json action labels over frame spans, contacts frames - the interaction layer
takes/<take>/world/occupancy.npz, esdf.npz voxel grid per sample metres; cells world free, occupied and unknown space; the distance to the nearest occupied cell
takes/<take>/world/entities.jsonl, relations.jsonl one line per thing per sample metres, m/s, rad/s world the things in the room and their relations (held by, supported by, contact)
takes/<take>/orbit/*_captioned.mp4, ego/*_captioned.mp4, */poses.json W x H x 3 per frame; 4 x 4 per frame 8-bit RGB; metres world rendered views of the reconstruction with captions, and their camera paths (source_frame per output frame)

The LeRobot dataset, one row per frame (meta/lattice.json gives each episode's take and each take's measured frame rate):

key shape units frame what
observation.images.cam_00 .. cam_03 (3, 1200, 1920) float in [0, 1] camera N the four camera videos, one picture per frame
human.body, human.body_valid (114,) = 38 x xyz; (38,) metres world the fitted body; NaN where the mask is False
human.hands, human.hands_valid (126,) = 2 x 21 x xyz; (42,) metres world the fitted hands, left then right
human.joints, human.action, *_valid (195,) rad the take's URDF joint angles of models/<take>.urdf at t and at t + 1
human.root_pos (3,) metres world the root of the take's URDF
observation.object.pose, observation.object.visible (7,); (1,) metres; wxyz world the handled object's world_T_object [x, y, z, qw, qx, qy, qz] (the NVIDIA V2D layout), zeros where no object is visible; only the ball takes have one
observation.state.unitree_g1 (7 + J,) metres; xyzw; rad robot frame the robot's root and joints at t (an example retargeting)
action.unitree_g1 (J,) rad - the robot's joint positions at t + 1
finger_held.unitree_g1 (F,) bool - a finger the fit did not measure kept its value
task text - - the reviewed sentence for this frame
take_frame, capture_time_ns, world.sample (1,) frame; ns; sample - joins a row to the take folder and its world state

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 same shirt folding from the person's own eyes (the ego view). (`dataset_shirt_p1_3`)

The action orbits and the ego view from the person's eyes, each with the fitted body and hands drawn on and the reviewed action captions under it. Each is a virtual camera rendered from the reconstruction, not a physical camera.

Uses

take below is Take(take_dir) of the folder quick start further down (code/loader.py).

Hand-object manipulation

The fitted 21-joint hands of every frame, with the reviewed step that frame belongs to and the contacts of the world state.

import numpy as np
hands = np.asarray(ds.hf_dataset.with_format("numpy")["human.hands"]).reshape(-1, 2, 21, 3)  # metres
contacts = [r for r in take.relations(100) if r["kind"] == "contact"]  # world/relations.jsonl

Ego video to action

ego/rgb_skeleton_captioned.mp4 is the take seen from the person's eyes, and ego/poses.json names the take frame of each video frame (source_frame). Pair it with the human action (human.action) or the joint angles of models/<take>.urdf.

import json
poses = json.load(open(take_dir / "ego/poses.json"))
frames = [f["source_frame"] for f in poses["frames"]]  # take frame of each ego frame

4-D reconstruction

Every frame's coloured points from four cameras, and the cameras' calibration.

points = take.points(0)            # (P, 3) float32 metres, world
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

Planning in a persistent 3-D world state

world/ holds free, occupied and unknown space, the distance to the nearest obstacle and every thing in the room, fused over the take.

state, origin_m, edge_m, shape = take.occupancy(100)  # -1 FREE, 0 UNKNOWN, 1 OCCUPIED
distance_m = take.esdf(100)[0]                        # metres to the nearest occupied or unknown cell
objects = take.entities(100)                          # pose, velocity, angular velocity per thing

The robot action is an example

action.unitree_g1 and observation.state.unitree_g1 show that the measured motion can drive a robot. They are an example retargeting, not a goal of this dataset: the human data (human.*, body/smplx.npz, body/mano.npz) is the measurement, and you can retarget it to your own robot. The unitree_g1 ships on all 33 takes. A retarget gate checks each take (joint limits and speeds, feet and floor, self-collision, hand contact, arm direction, body likeness, smoothness, fingers, held objects) as a report, not a filter: 14 of 33 takes pass every check, and meta/lattice.json (takes.<take>.robots.unitree_g1.gate) names each check with what it measured and its bar. The robot's frame is gravity-aligned, with the fit's floor at z = 0 (meta/takes/<take>/robots/unitree_g1/retarget.json world_to_robot). Its URDF, meshes and licence are in meta/robots/unitree_g1/.

Take folders: 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. code/quickstart.ipynb loads the LeRobot dataset, the human motion and the example robot action, and plays the robot in MuJoCo inside the take's room (code/robot_room.py robot_in_room).

Draw your own views

code/render_view.py draws a take's reconstruction from any camera path and writes an MP4. It needs NumPy, zstandard and the ffmpeg program, and uses code/loader.py and code/ltrc_decoder.py. It draws coloured points, nearest point first, so it is a plain viewer, not the renderer of the published orbit/ and ego/ videos. A camera path is a poses.json like those two, or your own file in the same format. Without a path it makes a new orbit:

python code/render_view.py takes/<take> my_orbit.mp4 --seconds 5

--path ego or --path my_path.json draws another path. --cam 2 --frame 100 draws from a physical camera. --size 1280x720 and --point-mm 6 set the picture and the dot size. In Python, render_view.orbit_path(points, up) returns a path you can edit.

Folders

README.md          this card
LICENSE.md         the licence of every take (cc-by-4.0)
code/              loader.py, ltrc_decoder.py, render_view.py, robot_room.py, example.ipynb, quickstart.ipynb
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 stage (room, floor, cameras, skeleton), the room mesh, the URDF rig
  labels/          actions.json, interaction.json, objects.json
  orbit/           the rendered orbit videos, their poses and depth; only captioned videos
  ego/             the reconstruction from the person's eyes with the body drawn on, captioned, its poses
  world/           the persistent 3-D world state (objects, relations, occupancy, distance field, person, cloth)
  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. index/takes.jsonl gives each take's repo path of its files (its scene_ltrc, decoder, usd, urdf, skeleton, calibration and world_state columns):

column path how to load it
scene_ltrc takes/<take>/scene/<take>.ltrc loader.Take('takes/<take>').points(frame), or ltrc_decoder.open_ltrc(path).read_frame(frame)
decoder code/ltrc_decoder.py import ltrc_decoder with code/ on sys.path (pip install numpy zstandard)
usd takes/<take>/models/<take>.usd pxr.Usd.Stage.Open(path) (pip install usd-core)
urdf takes/<take>/models/<take>.urdf yourdfpy.URDF.load(path, load_meshes=False) (pip install yourdfpy)
skeleton takes/<take>/body/skeleton.jsonl loader.Take('takes/<take>').skeleton(frame)
calibration takes/<take>/cameras/calibration.json json.load
world_state takes/<take>/world/header.json loader.Take('takes/<take>').world(), .occupancy(frame), .entities(frame)

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.

World state

takes/<take>/world/ holds one persistent 3-D state of the room for each take. It is fused over the take from the reconstruction. Each take has:

  • the objects in the room, with position, rotation, velocity and angular velocity at each sample (entities.jsonl). An object out of view keeps its last state (presence).
  • the relations: hand contact, held by, supported by, worn by and last contact (relations.jsonl).
  • free, occupied and unknown space on a voxel grid, with every change of state over the take (occupancy.npz, occupancy_events.npz).
  • the distance field: the distance from each cell to the nearest occupied or unknown cell (esdf.npz).
  • the cells the person fills at each sample (person_cells.npz) and the cells of each object (entity_cells.npz).
  • the cloth layer: the shape of each deformable object at each sample (cloth.jsonl, cloth_cells.npz).

An object is deformable when the video shows it bending. Either a reviewed step of labels/actions.json folds, unfolds or refolds it while a hand holds or touches it, or it bounces freely off the floor. deformation_evidence names the steps and the bounce frames. world/header.json gives the grid, the sample frames and every measured input.

Load it with code/loader.py:

world = take.world()                                # header: grid, sample frames, inputs
state, origin_m, edge_m, shape = take.occupancy(100)  # -1 FREE, 0 UNKNOWN, 1 OCCUPIED
distance_m = take.esdf(100)[0]                      # metres to the nearest occupied or unknown cell
objects = take.entities(100)                        # pose, velocity, angular velocity, deformation
relations = take.relations(100)
person = take.person_cells(100)                     # flat indices of the cells the person fills
cloth = take.cloth(100)                             # each cloth's shape, with its cells

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 67 23.91 ddf2738f2072 2026-10-03T05:25:53Z
dataset_balls_p1_2 415 60.002 2 23 67 22.20 29a22ffccda7 2026-10-04T11:56:25Z
dataset_balls_p1_3 647 60.002 2 28 67 34.21 4577bddf5f6b 2026-10-02T07:14:54Z
dataset_balls_p1_4 679 59.999 2 36 67 35.85 6630761636bf 2026-10-03T08:20:42Z
dataset_balls_p1_5 746 60.002 2 32 67 39.99 dd9b451e039a 2026-10-02T05:41:24Z
dataset_balls_p2_1 575 60.002 2 38 67 30.28 8cc8e75b0428 2026-10-03T05:59:20Z
dataset_balls_p2_2 626 59.999 2 18 67 32.95 069012ff3062 2026-10-03T06:13:54Z
dataset_balls_p2_3 744 59.999 2 13 67 39.01 aafe079272f6 2026-10-03T06:30:28Z
dataset_balls_p2_4 987 60.002 2 34 67 51.85 937591387487 2026-10-02T06:27:52Z
dataset_balls_p3_1 492 59.999 2 28 67 26.07 3163ba7e2909 2026-10-03T04:15:57Z
dataset_balls_p3_2 831 60.002 2 55 67 44.00 3d78e9fb0017 2026-10-03T09:05:12Z
dataset_balls_p3_3 821 59.999 2 32 67 43.39 5a894ffccc1c 2026-10-03T08:56:38Z
dataset_balls_p3_4 676 60.002 2 34 67 35.62 7723602a4663 2026-10-03T06:08:48Z
dataset_balls_p4_1 620 60.002 2 20 67 33.30 9a1a2bd5486f 2026-10-03T06:08:02Z
dataset_balls_p4_2 569 59.999 2 27 67 30.40 fa2ef746991c 2026-10-03T06:31:01Z
dataset_balls_p4_3 611 59.999 2 32 67 33.55 a9a56873fb99 2026-10-03T02:27:03Z
dataset_balls_p4_4 558 59.999 2 33 67 30.49 7a0b2bd4a099 2026-10-03T07:28:47Z
dataset_balls_p4_5 893 59.999 2 29 67 47.46 b3081f122bdf 2026-10-03T09:10:31Z
dataset_shirt_p1_1 1793 59.999 2 90 67 96.01 a667c400fbea 2026-10-04T09:21:02Z
dataset_shirt_p1_2 1236 59.999 2 27 67 68.29 d3577822e4b4 2026-10-03T08:10:59Z
dataset_shirt_p1_3 881 59.999 2 19 67 47.26 c55ec9e9a49d 2026-10-03T23:05:48Z
dataset_shirt_p1_4 1395 59.999 2 48 67 76.08 8b106e229d6f 2026-10-03T08:48:06Z
dataset_shirt_p1_5 1274 59.999 2 44 67 69.44 04cfa85b65e2 2026-10-03T14:36:22Z
dataset_shirt_p3_1 771 59.999 2 47 67 42.23 f0f4b4144aa8 2026-10-03T12:47:33Z
dataset_shirt_p3_2 1070 59.999 2 76 67 58.93 72e168ae8908 2026-10-03T07:34:44Z
dataset_shirt_p3_3 1633 59.999 2 97 67 88.24 692c579041fa 2026-10-02T10:10:12Z
dataset_shirt_p3_4 1278 59.999 2 56 67 69.13 d438b7f83bb0 2026-10-03T08:21:34Z
dataset_shirt_p3_5 1567 59.999 2 83 67 84.70 aaafe973690a 2026-10-03T11:29:56Z
dataset_shirt_p4_1 1037 59.999 2 30 67 56.61 2e93f6927492 2026-10-03T07:47:54Z
dataset_shirt_p4_2 1400 59.999 2 25 67 74.53 cc989971c33e 2026-10-03T11:35:27Z
dataset_shirt_p4_3 855 59.999 2 42 67 47.32 65f66b33c5aa 2026-10-03T09:18:56Z
dataset_shirt_p4_4 1269 59.999 2 64 67 69.60 1fd4cae83792 2026-10-03T08:32:39Z
dataset_shirt_p4_5 1417 59.999 2 77 67 77.27 f69b42a3b97c 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

The dataset is small: 33 takes of two tasks (ball handling, shirt folding), all recorded in one room.

The unitree_g1 action is an example retargeting, not a measurement and not a release goal. Where the person sits (most shirt-folding takes), the robot squats in the air: the retarget does not seat it on the room's chair or bench.

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. On a few seated shirt-folding takes the fitted back sits 1-4 cm in front of the person's back that the depth sees. 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
6,720

Space using latticecx/Lattice_4D_Dataset 1