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