EgoHandWM/ego4d-hand-mano

Dataset summary

Per-frame 3D hand annotations and text captions for 1,302,538 egocentric video clips drawn from 3,320 Ego4D videos. Every clip is 121 frames at 30 fps (4.03 s) at a 540-pixel short side.

This is the annotation release accompanying Controllable Egocentric Video Generation via Occlusion-Aware Sparse 3D Hand Joints (ECCV 2026). Each clip carries, for both hands and every frame: 21 3D joints, MANO pose parameters, root rotation and translation, 2D wrist position and hand boxes, plus explicit occlusion / validity information — hands that are not visible are marked, not guessed.

subset	source videos	clips
eccv	531	191,386
post_eccv	2,789	1,111,152
total	3,320	1,302,538

This repository contains no video pixels. It ships the annotations plus extract_clips.py, which rebuilds the exact clips from your own copy of the Ego4D videos. A clip is exactly frames [start_frame, start_frame + 120] of <video_uid>.mp4 in the Ego4D video_540ss variant — no spatial crop, no resize, no frame resampling — and every clip carries a frame_sha256 over its decoded frames so you can prove your rebuild is the one the annotations describe.

download from here	98 GiB
download from Ego4D	the 3,320 video_540ss videos in metadata/video_uids.txt (1.3 TiB)
CPU to rebuild the clips	~1.1 s/clip/core → 25 h on 16 cores, 83 min on a 288-core node
disk for the rebuilt clips	~764 GiB as H.264, or decode on the fly and store nothing

Quick start

1 — get the annotations (needs an approved access request and a token)

pip install huggingface_hub pyarrow
hf auth login
hf download bochen123/ego4d-hand-mano --repo-type dataset --local-dir ./ego4d-hand-mano
cd ./ego4d-hand-mano

2 — get the source videos from Ego4D

Use your own Ego4D access. Download only the videos this dataset uses, in the video_540ss variant — the annotations are in that variant's pixel coordinates:

pip install ego4d
ego4d --output_directory ./ego4d --datasets video_540ss \
      --video_uids $(tr '\n' ' ' < metadata/video_uids.txt)

metadata/video_uids_<subset>.txt lets you take one subset at a time if 1.3 TiB is more than you want to fetch at once.

3 — rebuild the clips and verify them

python3 extract_clips.py \
    --clips metadata/clips.parquet \
    --ego4d-dir ./ego4d/v2/video_540ss \
    --out ./clips --workers 32 --verify

This writes clips/<video_uid>/<clip_id>.mp4 (121 frames, H.264, CRF 23) and checks each clip's decoded frames against frame_sha256. It is re-runnable — finished clips are skipped — and needs ffmpeg on PATH (--ffmpeg /path/to/ffmpeg otherwise). --format frames writes JPEGs instead, --videos <file> restricts it to a list of video_uids.

A frame_sha256 mismatch means your source video is a different Ego4D variant or version, not that your ffmpeg is wrong.

Files

annotations/train-NNNNN.parquet     per-clip 3D joints / MANO parameters  (435 shards)
metadata/clips.parquet              one row per clip: ids, caption, geometry, frame_sha256
metadata/video_uids.txt             all source video_uids you need from Ego4D
metadata/video_uids_<subset>.txt    the same, split by subset
extract_clips.py                    rebuilds the clips from those videos

clip_id is <video_uid>_<start_frame:08d> and joins every table together.

Loading

from datasets import load_dataset

ann  = load_dataset("bochen123/ego4d-hand-mano", "annotations", split="train", streaming=True)
meta = load_dataset("bochen123/ego4d-hand-mano", "metadata",    split="train")
print(meta[0]["caption"], meta[0]["clip_id"])

Arrays are stored flattened float32; reshape with the shapes in the parquet schema metadata:

import json, numpy as np, pyarrow.parquet as pq

t = pq.read_table("annotations/train-00000.parquet")
shapes = json.loads(t.schema.metadata[b"array_shapes"])
row = t.slice(0, 1).to_pylist()[0]

joints = np.asarray(row["joints_local"], np.float32).reshape(shapes["joints_local"])  # (121, 2, 21, 3)
theta  = np.asarray(row["pose_theta45"], np.float32).reshape(shapes["pose_theta45"])  # (121, 2, 45)
valid  = ~np.isnan(joints).any((-1, -2))                                              # (121, 2) bool
print(joints.shape, valid.sum(0))   # frames with a hand, per slot

A clip and its annotations together

import json, subprocess, numpy as np, pyarrow.parquet as pq

meta = pq.read_table("metadata/clips.parquet").to_pylist()
tbl  = pq.read_table("annotations/train-00000.parquet")
shapes = json.loads(tbl.schema.metadata[b"array_shapes"])
ann = {r["clip_id"]: r for r in tbl.to_pylist()}

m = next(r for r in meta if r["clip_id"] in ann)
w, h = m["width"], m["height"]        # the decoded frame size; see annot_width/annot_height

# decode the 121 RGB frames straight from the Ego4D source, no intermediate file
cmd = ["ffmpeg", "-v", "error", "-ss", "%.6f" % (m["start_frame"] / m["fps"]),
       "-i", f"./ego4d/v2/video_540ss/{m['video_uid']}.mp4",
       "-frames:v", "121", "-f", "rawvideo", "-pix_fmt", "rgb24", "-"]
frames = np.frombuffer(subprocess.run(cmd, capture_output=True, check=True).stdout,
                       np.uint8).reshape(-1, h, w, 3)                      # (121, H, W, 3)

r = ann[m["clip_id"]]
root_2d = np.asarray(r["pose_root_2d"], np.float32).reshape(shapes["pose_root_2d"])   # px
bbox    = np.asarray(r["pose_bbox_xyxy"], np.float32).reshape(shapes["pose_bbox_xyxy"])
print(frames.shape, "|", m["caption"])
print("left wrist at frame 0:", root_2d[0, 0], "box:", bbox[0, 0])

pose_root_2d and pose_bbox_xyxy are in pixels of the clip's own resolution (width x height), so they index frames directly.

What the annotations actually look like

clips	1,302,538 over 3,320 source videos (min 1, median 191, max 8312 per video)
every clip	121 frames @ 30 fps (4.03 s), 540-px short side
clips with a valid right hand somewhere	1,180,097 (90.6%)
clips with a valid left hand somewhere	1,065,253 (81.8%)
clips with both hands somewhere	942,812 (72.4%)
clips with neither hand	0 (0.0%)
valid frames per clip (of 121)	left median 100, right median 109
fraction of joints_local that is NaN	median 0.27 (p10 0.00, p90 0.78)
hand tracks per clip (n_tracks)	1: 107,644, 2: 559,069, 3: 559,145, 4: 69,022, 5: 6,479, 6: 863, 7: 223, 8: 59, 9: 26, 10: 5, 11: 1, 12: 2
caption length	median 94 chars, max 2555
clips with a caption	100.0%

Hands are absent from many frames — that is the point of the occlusion-aware formulation, not a defect — so filter before you train. Everything you need is in metadata/clips.parquet (96 MB), so you can choose clips before downloading the annotation shards:

import pyarrow.parquet as pq, pyarrow.compute as pc

m = pq.read_table("metadata/clips.parquet")
both = m.filter(pc.and_(pc.greater(m["left_valid_frames"], 60),
                        pc.greater(m["right_valid_frames"], 60)))
print(both.num_rows, "clips with >60 valid frames for both hands")

Annotation schema

Arrays, with T = 121 frames and a 2-wide hand axis:

column	shape
K	(3, 3)
joints_T_global	(121, 2, 3)
joints_is_right	(121, 2)
joints_local	(121, 2, 21, 3)
pose_T_global	(121, 2, 3)
pose_bbox_xyxy	(121, 2, 4)
pose_is_right	(121, 2)
pose_root_2d	(121, 2, 2)
pose_root_R	(121, 2, 3, 3)
pose_root_aa	(121, 2, 3)
pose_root_cam	(121, 2, 3)
pose_theta45	(121, 2, 45)

Scalars: clip_id, video_uid, subset, start_frame, n_tracks, left_hand_idx, right_hand_idx, left_valid_frames, right_valid_frames, left_present_frames, right_present_frames, frames_with_extra_hands, min_valid_threshold, min_presence_threshold, joints_nan_frac, root_cam_nan_frac.

metadata/clips.parquet adds end_frame, num_frames, fps, width, height, annot_width, annot_height, annot_wh_differs, fx, fy, cx, cy, caption, split, shard, shard_name, frame_sha256.

Read this before you use the arrays

• NaN means "no hand here." Frames and slots with no detected or tracked hand are NaN in every float array, and -1 in the int8 *_is_right fields. This is the occlusion signal, not missing data. Per-clip fractions are in joints_nan_frac / root_cam_nan_frac; per-hand counts in left_valid_frames / right_valid_frames.
• joints_* slots are not fixed left/right. joints_local and joints_T_global have two slots ordered primary / secondary hand, and the handedness of each slot varies per frame: read it from joints_is_right (1 right, 0 left, -1 absent).
• pose_* slots are [left, right]. The upstream tracker emits a variable number of hand tracks per clip (n_tracks); the tracks identified as the left and the right hand (left_hand_idx, right_hand_idx, -1 when absent) were gathered into a fixed [left, right] axis and NaN-filled where absent.
• K is not a camera calibration. It is the fixed weak-perspective placeholder used by the hand-pose estimator, fx = fy = 5000 * width / 256, with cx, cy at the image centre. It is reported per clip only for reproducibility — do not use it as intrinsics.
• joints_T_global and pose_T_global are different quantities and generally disagree. Both are kept so you can use whichever your pipeline expects.
• width/height vs annot_width/annot_height. width x height is the frame size ffmpeg actually decodes from the Ego4D source — use it to reshape decoded frames. annot_width x annot_height is the frame size the annotation pipeline believed it was working in, which is the coordinate frame the 2D values live in. They are identical for all but 817 clips over 4 source videos (annot_wh_differs == True), where the pipeline's width is 1 pixel narrower than the real frame (958 vs 959, 404 vs 405) because it recomputed the width by rounding instead of reading the container. Scale 2D values by width / annot_width if that 0.1 % matters to you, or filter those clips out with annot_wh_differs.
• 2D coordinates can fall outside the frame. pose_root_2d and pose_bbox_xyxy are in pixels of the clip's width x height, but the estimator extrapolates for hands that are partly out of view, so values slightly below 0 or above width/height do occur. Clip them before indexing.
• joints_local is in metres in a hand-local frame; pose_theta45 are MANO pose parameters (15 joints x 3 axis-angle) in radians; pose_root_aa / pose_root_R are the root rotation in axis-angle / matrix form; pose_root_cam is the root translation in the camera frame.

Provenance and limitations

• Clips are cut from Ego4D v2 video_540ss. No Ego4D pixels are redistributed here.
• Hand annotations are automatic model predictions, not human labels. They contain tracking failures, identity swaps between hands, and depth-scale ambiguity inherent to monocular hand estimation. Treat *_valid_frames and the NaN pattern as part of the data.
• Captions are automatically generated clip descriptions, one per clip.
• No manual quality audit was performed over the full set.

Licensing

• These annotations are released under CC BY-NC 4.0 (attribution, non-commercial).
• The underlying Ego4D videos are not covered by that licence and are not distributed here. They remain governed by the Ego4D License Agreement, which you must accept with the Ego4D consortium directly. Access to this repository does not grant you any right to Ego4D video.

Citation

Paper: arXiv:2603.11755

@inproceedings{zhang2026controllable,
  title     = {Controllable Egocentric Video Generation via Occlusion-Aware Sparse 3D Hand Joints},
  author    = {Zhang, Chenyangguang and Ye, Botao and Chen, Boqi and Delitzas, Alexandros
               and Wang, Fangjinhua and Pollefeys, Marc and Wang, Xi},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2026}
}

Please also cite Ego4D, since every clip here comes from it.