Louis0411/dexycb_mesh

DexYCB-Mesh — Hand–Object Mesh Sequences (Image-Free DexYCB)

This is a repackaged, image-free distribution of DexYCB (Chao et al., CVPR 2021) intended for mesh-based simulation, replay and evaluation of hand–object interaction. Every RGB / depth image has been stripped; what remains is everything needed to reconstruct hand–object mesh sequences: per-frame MANO hand parameters, per-frame 6D poses of the grasped YCB objects, the full textured YCB object models, complete camera calibration, and the per-camera annotations (segmentation, 2D/3D joints).

Overview

Item	Value
Subjects	10 (YYYYMMDD-subject-01 … -10)
Sessions	100 per subject, 1000 total (each = one right-hand grasp of 1–4 YCB objects)
Cameras	8 synced Intel RealSense per session (640×480)
Frames	72–74 per session (72k frames total)
Hand	1 right hand, MANO parametric model, per-frame 51-dim fit
Objects	21 YCB objects with full textured meshes
Size	≈ 4.2 GB (models 3.5 GB + per-subject annotations 80–90 MB)

Not included (by design): the RGB-D imagery — except the first frame of every camera (color_000000.jpg + aligned_depth_to_color_000000.png for all 1000 sessions × 8 cameras, shipped in tars/rgbd_first_frame.tar.gz), the BOP-format conversion, and the toolkit code. If you need full imagery, get the original dataset from dex-ycb.github.io. Code (viewers / pose & hand-pose evaluation) lives in NVlabs/dex-ycb-toolkit.

Download & extraction

The whole dataset ships as tar archives under tars/ — 1 archive for models + calibration, 1 per subject (annotations), and 1 for the first-frame RGB-D of all cameras (the raw file tree is not distributed: 580k+ tiny .npz files don't work well as repo files).

Download & extract (needs hf CLI, pip install -U huggingface_hub):

hf download Louis0411/dexycb_mesh --repo-type dataset --local-dir dexycb_mesh
cd dexycb_mesh

tar -xzf tars/models_calibration.tar.gz                        # -> models/  calibration/
for f in tars/2020*-subject-*.tar.gz; do tar -xzf "$f"; done  # -> 2020*-subject-*/  annotations
tar -xzf tars/rgbd_first_frame.tar.gz                          # -> first-frame color/depth per camera (optional)

Extraction recreates the exact directory layout shown below (relative mtimes and permissions preserved), so the quick-start code works as-is from the dexycb_mesh folder.

Directory layout

dexycb_mesh/
├── YYYYMMDD-subject-XX/              # one directory per subject (10x)
│   └── YYYYMMDD_HHMMSS/              # one directory per session (100x each)
│       ├── meta.yml                  # session metadata
│       ├── pose.npz                  # per-frame MANO + object poses (world frame)
│       ├── visibility.npz            # per-camera/frame hand visibility (added by this repack)
│       └── <camera-serial>/          # 8x camera directories
│           ├── labels_XXXXXX.npz     # per-frame annotation in that camera's frame
│           ├── color_000000.jpg                  # first-frame color (640x480)
│           └── aligned_depth_to_color_000000.png # first-frame depth, aligned to color, uint16, millimeters
├── calibration/
│   ├── intrinsics/<serial>_640x480.yml
│   ├── extrinsics_<capture-date>/extrinsics.yml
│   └── mano_<date>_subject-XX_right/mano.yml
├── models/                           # 21 YCB object models (mesh + texture + SDF)
├── mano_models/MANO_RIGHT.pkl        # MANO hand model (© MPI-IS, see license notes)
├── tools/mano_to_mesh.py             # pose_m -> hand mesh export tool
└── README.md

File formats

meta.yml (per session)

Field	Example	Meaning
serials	['836212060125', ...]	the 8 camera serials (= subdirectory names)
num_frames	72	number of frames in this session
extrinsics	'20200702_151821'	name of the calibration/extrinsics_<...> dir to use
ycb_ids	[1, 5, 6, 15]	1-based indices into the YCB object table below
ycb_grasp_ind	0	grasp-type index
mano_sides	['right']	hand side (always right in DexYCB)
mano_calib	['20200709_140042_subject-01_right']	MANO calibration id; the dir with this subject's betas is calibration/mano_<this value>/mano.yml (note the mano_ prefix)
pcnn_init	[[0, 2, 1], ...]	initialization used by the original pose fitting

pose.npz (per session, world frame, meters)

Key	Shape	Meaning
pose_y	(N, n_obj, 7)	per-object pose: quaternion scalar-last (qx,qy,qz,qw) + translation (x,y,z)
pose_m	(N, n_hand, 51)	MANO parameters: [0:3] global orientation (axis-angle, world frame), [3:48] 45 hand-pose PCA coefficients, [48:51] wrist translation (meters, world frame). See the MANO section

N = num_frames. Frames where the hand is not in view have an all-zero pose_m row — filter with visibility.npz (below). Object poses are always valid.

labels_XXXXXX.npz (per frame, per camera, camera frame, meters)

Key	Shape	Meaning
seg	(480, 640) uint8	semantic segmentation: 0 background, 1..21 YCB object id, 255 hand
pose_y	(n_obj, 3, 4)	per-object `[R
pose_m	(n_hand, 51)	MANO parameters (camera-frame global orientation / translation)
joint_3d	(n_hand, 21, 3)	21 hand joints in the camera frame; all -1 when the hand is absent
joint_2d	(n_hand, 21, 2)	the 21 joints projected into the image

XXXXXX is the frame index (000000 … 000073). This is the exact annotation the original dataset ships alongside its images.

visibility.npz (per session; added by this repack, not part of original DexYCB)

Derived from seg == 255 in every camera/frame.

Key	Shape	Meaning
serials	(8,)	camera order of the following arrays
hand_px	(8, N) int32	hand pixel count per camera/frame
bbox	(8, N, 4) int32	hand bounding box x1,y1,x2,y2, -1 when no hand
visible	(8, N) bool	hand visible (≥ some pixels) in that camera/frame
covered	(8, N) bool	hand present in any camera at that frame

calibration/

• intrinsics/<serial>_640x480.yml — per camera: color and depth fx/fy/ppx/ppy.
• extrinsics_<date>/extrinsics.yml — per camera serial a 12-number [R|t] that maps camera → world: x_world = R @ x_cam + t. Also contains the master camera and the apriltag rig transform (the world frame is defined by this AprilTag calibration rig, and is shared by all cameras of a capture date).
• mano_<date>_subject-XX_right/mano.yml — the subject's MANO shape betas (10 numbers).

models/ (21 YCB objects)

Each object directory contains textured_simple.obj / textured.obj (+ .mtl and texture_map.png), *.sdf signed distance fields, points.xyz samples, .stl, etc. Model → world placement = pose.npz pose_y (model→world).

YCB object index (ycb_ids / seg value ↔ model directory)

id	model dir	id	model dir	id	model dir
1	002_master_chef_can	8	009_gelatin_box	15	035_power_drill
2	003_cracker_box	9	010_potted_meat_can	16	036_wood_block
3	004_sugar_box	10	011_banana	17	037_scissors
4	005_tomato_soup_can	11	019_pitcher_base	18	040_large_marker
5	006_mustard_bottle	12	021_bleach_cleanser	19	051_large_clamp
6	007_tuna_fish_can	13	024_bowl	20	052_extra_large_clamp
7	008_pudding_box	14	025_mug	21	061_foam_brick

(id = 1-based alphabetical position in models/; same value used in seg maps and ycb_ids.)

Quick start

import os
import numpy as np
import yaml
import trimesh

root = "path/to/dexycb_mesh"
session = "20200709-subject-01/20200709_141754"   # pick any subject/session

# ---- session metadata & world-frame poses --------------------------------
meta = yaml.safe_load(open(f"{root}/{session}/meta.yml"))
pose = np.load(f"{root}/{session}/pose.npz")
N, n_obj = pose["pose_y"].shape[:2]        # frames, objects in this grasp
pose_m = pose["pose_m"][:, 0]              # (N, 51) MANO params, world frame

# ---- object mesh (model frame -> world) ----------------------------------
ycb_dir = sorted(os.listdir(f"{root}/models"))[meta["ycb_ids"][0] - 1]
mesh = trimesh.load(f"{root}/models/{ycb_dir}/textured_simple.obj", force="mesh")

from scipy.spatial.transform import Rotation
R_wo = Rotation.from_quat(pose["pose_y"][0, 0, :4]).as_matrix()   # scalar-last quat
t_wo = pose["pose_y"][0, 0, 4:]
verts_world = mesh.vertices @ R_wo.T + t_wo

# ---- world -> camera 0, then project -------------------------------------
serial = meta["serials"][0]
# NB: use FullLoader — these calibration files contain !!python/tuple tags
extr = yaml.load(open(f"{root}/calibration/extrinsics_{meta['extrinsics']}/extrinsics.yml"),
                 Loader=yaml.FullLoader)
T = np.array(extr["extrinsics"][serial]).reshape(3, 4)   # [R | t], camera -> world
R_c2w, t_c2w = T[:, :3], T[:, 3]
verts_cam = (verts_world - t_c2w) @ R_c2w          # = R_c2w.T @ (x_world - t_c2w)

intr = yaml.load(open(f"{root}/calibration/intrinsics/{serial}_640x480.yml"),
                 Loader=yaml.FullLoader)
fx, fy = intr["color"]["fx"], intr["color"]["fy"]
cx, cy = intr["color"]["ppx"], intr["color"]["ppy"]
uv = verts_cam[:, :2] / verts_cam[:, 2:3] * [fx, fy] + [cx, cy]   # (V, 2) pixels

# ---- hand mesh -> see the "MANO hand mesh reconstruction" section below ----

# ---- per-camera annotations ----------------------------------------------
lab = np.load(f"{root}/{session}/{serial}/labels_000030.npz")
seg = lab["seg"]                 # (480, 640) uint8: 0 bg / ycb_id / 255 hand
joints_cam = lab["joint_3d"][0]  # (21, 3) meters, camera frame

Sanity check for the projection above: joints_cam from labels_*.npz should coincide with R_c2w.T @ (joint_world − t_c2w) built from pose.npz + MANO (they are the same fit, stored per frame).

MANO hand mesh reconstruction

pose_m alone does not directly drive a MANO layer: the 45 hand parameters [3:48] are PCA coefficients, not axis-angle. Multiply them by the PCA basis (hands_components) stored inside MANO_RIGHT.pkl first — this is the same semantics as the official toolkit's ManoLayer(use_pca=True, ncomps=45). Applying them as raw axis-angle twists the fingers.

Quick path — the bundled tool (tools/mano_to_mesh.py, exports one obj/ply per frame; skips frames where the hand is absent; verified to reproduce the official joint_3d to <0.1 mm):

pip install -r requirements.txt    # torch first from pytorch.org if you need a CUDA build

# world frame, all frames of a session
python tools/mano_to_mesh.py --session 20200709-subject-01/20200709_141754

# chosen frames in one camera's frame
python tools/mano_to_mesh.py --session 20200709-subject-01/20200709_141754 \
    --frames 30 31 --frame camera --camera 836212060125

Under the hood (smplx; reproduces the official joint_3d annotations to <0.1 mm — verified against this data):

import pickle
import numpy as np
import torch
import smplx
import trimesh
import yaml

root     = "path/to/dexycb_mesh"
session  = "20200709-subject-01/20200709_141754"
pkl_path = f"{root}/mano_models/MANO_RIGHT.pkl"   # bundled in this repo

meta = yaml.safe_load(open(f"{root}/{session}/meta.yml"))
pose = np.load(f"{root}/{session}/pose.npz")
pm   = pose["pose_m"][30, 0]            # (51,) world frame; zero rows = hand not in scene

# per-subject shape parameters from the calibration
# NB: the dir name prefixes the meta value with `mano_`
betas = torch.tensor([yaml.safe_load(
    open(f"{root}/calibration/mano_{meta['mano_calib'][0]}/mano.yml"))["betas"]]).float()

# 1) MANO layer, pointing smplx at the pkl file itself (the hand side is read
#    from the file name; `smplx.create(dir, "mano")` instead forces a mano/
#    subdir layout, and its kwarg would have to be `is_rhand` — `is_right` is
#    silently swallowed by **kwargs).
mano = smplx.MANO(model_path=pkl_path, use_pca=False, num_betas=10,
                  flat_hand_mean=False)

# 2) PCA coefficients -> axis-angle, via the basis inside the MANO pkl
pkl = pickle.load(open(pkl_path, "rb"), encoding="latin1")
hand_aa = torch.tensor(pm[3:48] @ np.array(pkl["hands_components"])).float()

# 3) forward kinematics -> 778 vertices in the SAME frame as `transl`
#    (world frame here; if you feed `labels_*.npz` `pose_m` instead, it is the camera frame)
out = mano(global_orient=torch.tensor(pm[:3]).unsqueeze(0),
           hand_pose=hand_aa.unsqueeze(0), betas=betas,
           transl=torch.tensor(pm[48:51]).unsqueeze(0), return_verts=True)
hand_mesh = trimesh.Trimesh(out.vertices[0].detach().numpy(),
                            mano.faces, process=False)

• Faces: mano.faces (1538 triangles, 778 vertices).
• Joints: smplx returns 16 joints (out.joints) in MANO kinematic order. The 21 joint_3d in labels_*.npz follow OpenPose order (wrist, thumb×4, index×4, middle×4, ring×4, pinky×4). Mapping MANO→OpenPose for the 16 non-fingertip joints, verified on this data: [0, 5, 6, 7, 9, 10, 11, 17, 18, 19, 13, 14, 15, 1, 2, 3].
• Rendering with pyrender/OpenGL: flip vertices to OpenGL conventions first — verts_gl = verts @ np.diag([1, -1, -1]).T — and build the camera from pyrender.IntrinsicsCamera(fx, fy, cx, cy) with the color intrinsics.
• manopth works too: ManoLayer(use_pca=True, ncomps=45, side='right', flat_hand_mean=False, ...) consumes the 48-dim pose_m[:48] directly as full_pose (it applies hands_components internally); pass the calibration betas and use pose_m[48:51] as transl.

Notes & conventions

• Units: meters everywhere (angles in radians).
• Coordinate frames: pose.npz lives in the world frame (the shared AprilTag rig frame from extrinsics.yml); labels_*.npz and joint_3d/joint_2d live in each camera's frame. Convert with the per-serial [R|t] as shown above (verified against the original annotations to ~1e-7).
• Quaternion convention: scalar-last (qx, qy, qz, qw) — matches scipy.spatial.transform.Rotation.from_quat.
• Hand visibility: MANO params are all-zero and joint_3d is all -1 before the hand enters the scene; use visibility.npz["visible"] to skip those frames.
• MANO model — bundled as mano_models/MANO_RIGHT.pkl for convenience. MANO is © MPI-IS, licensed for non-commercial research purposes only upon registration; any use of the bundled file remains subject to those terms. See the MANO hand mesh reconstruction section (mind the PCA-coefficient encoding of pose_m[3:48]).
• The original image-based dataset, its BOP conversion and the dex-ycb-toolkit are available from the official site / GitHub.

Provenance

• Source: official DexYCB v2 release (20200709-subject-01 … 20201022-subject-10, calibration, models).
• Modifications by this repack: removed all imagery (color_*.jpg, aligned_depth_to_color_*.png), removed bop/ and tooling; added per-session visibility.npz; added this README. Annotations, calibration and models are bit-identical to the source.

License & citation

The dataset is released under the same terms as DexYCB: CC BY-NC 4.0 — non-commercial use only with attribution. The YCB object models and the MANO hand model are subject to their own licenses; in particular mano_models/MANO_RIGHT.pkl is © MPI-IS and may only be used for non-commercial research in accordance with the MANO license.

@inproceedings{chao2021dexycb,
  title     = {DexYCB: A Benchmark for Capturing Hand Grasping of Objects},
  author    = {Chao, Yu-Wei and Yang, Weiye and Xiang, Yu and Molchanov, Pavlo and Daniilidis, Abhinav and Fox, Dieter},
  booktitle = {IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  year      = {2021}
}