Config	Path	What it is	Size
Rigid grasp WM (v1)	repo root — `objects/`, `reconstructions/`, …	closing-phase contact dynamics of rigid grasps: predict how a grasped object tilts/settles in the jaws	15,013 grasps · 171 objects
Grasp outcomes (v2) — ★ new	`outcomes_v2/`	full `close → lift → outcome` SE(3) trajectories, labeled by what happens on pickup (holds / slips / drops / never lifts)	53,917 episodes · 562 objects

★ New in this update — outcomes_v2/. Every grasp attempt is stored as a variable-length trajectory in which the outcome is visible in the data itself: a dropped object rises with the gripper and then falls back to the table; a rigid grasp stays put; a persistent slip keeps moving. This fixes a prior limitation where only the finger-closing window was stored — which made a DROPPED episode indistinguishable from a SUCCESS one and gave a world model no drop signal. The labels are unchanged (re-deriving them from the extended trajectories reproduces the released labels for 53,917/53,917 episodes). Outcome taxonomy, trajectory format, and a load_example.py are in outcomes_v2/README.md.

Rigid grasp WM (v1) — the sections below document this config

A per-object dataset for learning a contact-dynamics world model (WM): given a static 3D reconstruction of an object and a parallel-jaw grasp on it, predict how the grasped object settles and tilts in the gripper over a short horizon. Everything here is derived from rigid-body simulation in MuJoCo with photorealistic 3D Gaussian Splatting (3DGS) reconstructions of real scanned objects.

171 objects, 15,013 grasps (each grasp = one rigid lift-success episode).
Per object: mesh ground truth, 3DGS reconstruction, the point cloud the WM consumes, and the grasp poses with their outcome rotations (the WM targets).
Self-contained: only numpy (required) and trimesh (optional, to load meshes) are needed. No absolute paths, no project code.

Start here: python load_example.py — it loads one object, prints every array's shape, and runs two self-checks (A: re-derives the target from the raw trajectory; B: inverts the target back to world pose). If both print ≈ 0, you have read the conventions below correctly.

1. What problem this data is for

A deployed robot faces a finite, known world — the same workspace and the same handful of objects. Instead of hoping a generalist model transfers, we reconstruct each object once (3DGS + collision mesh) and simulate grasping it from many poses. The WM learns, per object, the mapping:

(object reconstruction, grasp pose)  ->  how the object rotates/translates in the gripper as it settles + lifts

The hard, useful signal is the tilt: when you close on an object off its center of mass, it rotates in the jaws. Predicting the direction and magnitude of that tilt is what the WM is graded on.

2. Directory layout & size tiers

cdwm_grasp_dataset_v1/
├── README.md                 <- this file
├── load_example.py           <- standalone loader + convention self-check
├── manifest.csv / .json      <- one row per object (metadata + relative paths)
├── normalization/            <- OPTIONAL: exact WM network standardization (see §7)
│   ├── cloud_feat_stats.npz
│   └── target_stats.npz
├── objects/                  <- CORE tier (~3.1 GB)
│   └── <OBJECT_ID>/
│       ├── mesh.obj          <- GT mesh geometry (Wavefront OBJ)
│       ├── material_0.png    <- GT mesh texture (appearance only; geometry is in mesh.obj)
│       ├── point_cloud.npz   <- the WM input: colorless 12-feat gaussians
│       └── grasps.npz        <- grasp poses + WM targets + per-grasp outcome metadata
└── reconstructions/          <- FULL tier only (~7.7 GB); the complete 3DGS splats (adds color/SH)
    └── <OBJECT_ID>.npz

Tier	Contents	Size	Use it if…
CORE	`objects/` + docs + `normalization/` (everything except splats)	~3.1 GB	You want to train/eval the WM. This is sufficient.
FULL	CORE + `reconstructions/`	~10.8 GB	You also want to re-render / re-color / re-clean the 3DGS.

The point cloud in CORE is the WM's actual input — you do not need reconstructions/ to use the data. The full splats are only for people who want the color/spherical-harmonic channels (e.g. to render images).

CORE size breakdown: meshes 2.0 GB, point clouds 1.2 GB, grasps 34 MB.

3. The task and the exact success criterion

Every packaged grasp is a rigid lift-success under this criterion (computed by re-simulating in MuJoCo):

Approach the logged grasp pose, close the parallel jaws, hold to settle.
Lift 50 mm over 0.5 s, then hold.
Success ⇔ the object is lifted ≥ 25 mm and its pose relative to the gripper drifts < 6° and < 8 mm between (lift-start + 2 logged frames) and the end of the trajectory. A one-time establishment reorientation as the jaws seat the object is allowed (it is not counted as drift; it is recorded as establish_deg).

This is the corrected "margin-2" rigid set (anchor_margin = 2). Grasps that slip, spin, or drop are not included. See §9 for what was deliberately excluded and why.

Each grasp's "outcome" is summarized by its net tilt — the geodesic angle between the object's orientation at the start of the settle window and at the end (net_tilt_deg), bucketed into tilt_band ∈ {0-2, 2-5, 5-15, 15-30, 30+}.

4. Coordinate systems, units & conventions ← read this before using the data

Units. Lengths are meters. Angles in stored metadata are degrees. Simulation timestep between logged frames is fixed (the WM treats the horizon as H = 32 discrete steps; absolute time is not needed).

Quaternions. All quaternions are (w, x, y, z) (scalar-first, MuJoCo convention), unit norm. Convert with the quat_to_R in load_example.py.

Rotation ↔ 6D. Rotations that are network-facing (the target) use the 6D representation of Zhou et al. 2019: the 6D vector is the first two columns of the 3×3 rotation matrix, R_to_6d(R) = [R[:,0], R[:,1]]. Recover the matrix by Gram-Schmidt, sixd_to_R (in load_example.py). First two columns, not rows — this matters.

Frames.

Frame	Origin / axes
World	MuJoCo global frame, z up, gravity −z. `obj_pos`, `obj_quat`, `base_pos`, `base_quat` live here.
Object	The object body frame at logged step t: position `obj_pos[t]`, orientation `obj_quat[t]`.
Gripper	The floating parallel-jaw mount: position `base_pos`, orientation `base_quat`. Constant across a grasp's logged settle window (the mount is commanded fixed while the jaws close).
Reconstruction	The frame of `point_cloud.npz` / `mesh.obj` — object-centered, centroid ≈ origin, gravity-aligned as scanned. The point cloud is stored in this frame and is NEVER transformed by the grasp pose (the grasp meets the cloud only inside the network, via `base_rel`).

The WM target — grasps.npz['target'], shape (K, H, 9). For grasp k, step t (t = 0…H−1):

Let Rg = quat_to_R(base_quat[k]), R0 = quat_to_R(obj_quat[k,0]), p0 = obj_pos[k,0] (the object pose at the first settle frame, t = 0). Then

dp_t = obj_pos[k,t] - p0                     # world displacement of the object since t0
dR_t = quat_to_R(obj_quat[k,t]) @ R0.T       # world rotation of the object since t0
target[k,t] = concat( Rg.T @ dp_t ,          # (3) displacement, expressed in the GRIPPER frame
                      R_to_6d( Rg.T @ dR_t @ Rg ) )   # (6) rotation-since-t0, conjugated into the GRIPPER frame

Read this as: "how has the object moved and rotated, relative to where it was when the jaws closed, as seen from the gripper." It is cumulative from t0 (a delta against the first settle frame), not frame-to-frame. Everything is in the gripper frame at t0 — the only admissible frame for a time-invariant target (the gripper mount doesn't rotate during the window, so this frame is fixed).

The conditioning grasp pose — grasps.npz['base_rel'], shape (K, 9). The gripper pose expressed in the object's t0 frame, concat( R0.T @ (base_pos - p0), R_to_6d(R0.T @ Rg) ). This is what the WM is told about the grasp; it is paired with the (untransformed) point cloud inside the network.

To consume a target (invert it back to a world object pose) — this is exactly CHECK B in load_example.py:

p_world_t = p0 + Rg @ target[k,t,:3]
R_world_t = (Rg @ sixd_to_R(target[k,t,3:]) @ Rg.T) @ R0

5. File formats (npz keys, shapes, dtypes)

Let N = #gaussians for the object (~50k–200k, varies), K = #rigid grasps for the object, H = 32.

`objects/<id>/point_cloud.npz` — the WM input (colorless 12-feature gaussians)

key	shape	dtype	meaning
`mu`	(N, 3)	float32	gaussian center, meters, reconstruction frame
`rot_quat`	(N, 4)	float32	gaussian orientation, (w,x,y,z) unit
`scale`	(N, 3)	float32	gaussian axis lengths, meters (≈ 0–6 mm)
`opacity`	(N, 1)	float32	raw (pre-sigmoid) opacity logit
`is_completed`	(N,)	float32	1 = gaussian added by shape-completion/inpainting, 0 = observed

The 12 features the WM stacks are [mu(3), rot_quat(4), scale(3), opacity(1), is_completed(1)]. Color/SH is intentionally dropped — this WM is colorless. (Full color lives in reconstructions/.)

`objects/<id>/grasps.npz` — grasp poses, WM targets, outcome metadata

key	shape	dtype	meaning
`grasp_id`	(K,)	int	grasp index within the object
`base_pos`	(K, 3)	float32	gripper mount position at t0, world, m
`base_quat`	(K, 4)	float32	gripper mount orientation at t0, world, (w,x,y,z)
`grasp_point`	(K, 3)	float32	grasp center on the object, world, m
`approach`	(K, 3)	float32	unit approach direction (into the object)
`closing`	(K, 3)	float32	unit jaw-closing direction (finger travel), world
`obj_pos`	(K, H+1, 3)	float32	object position trajectory over the settle window, world, m
`obj_quat`	(K, H+1, 4)	float32	object orientation trajectory, world, (w,x,y,z)
`target`	(K, H, 9)	float32	the WM target — gripper-frame SE(3) delta, see §4
`base_rel`	(K, 9)	float32	the WM grasp-pose conditioning, see §4
`net_tilt_deg`	(K,)	float32	net object tilt over the window (geodesic, deg)
`tilt_band`	(K,)	str	bucket of `net_tilt_deg`: `0-2 / 2-5 / 5-15 / 15-30 / 30+`
`split`	(K,)	str	`train` / `valgrasp` (held-out grasps of train objects) / `heldout_object`
`establish_deg`	(K,)	float32	one-time seat/establishment reorientation as jaws close (deg)
`lift_rot_drift_deg`	(K,)	float32	rel-pose rotational drift during the lift phase (deg; < 6° by criterion)
`lift_tr_drift_mm`	(K,)	float32	rel-pose translational drift during the lift phase (mm; < 8 mm)
`lifted_mm`	(K,)	float32	how far the object was lifted (mm; ≥ 25 mm)

Note obj_pos/obj_quat are H+1 = 33 long (poses at step 0…H); target is H = 32 long (deltas for step 0…H−1 against t0). base_pos/base_quat are stored as the single t0 value (they are constant across the window).

`reconstructions/<id>.npz` — full 3DGS splat (FULL tier only)

Superset of point_cloud.npz, additionally carrying sh_dc (N,3), sh_rest (N,45), obj_dc (N,16), normals (N,3), meta. Same mu/rot_quat/scale/opacity/is_completed as the point cloud. Use this if you want to render or re-color.

`mesh.obj` — GT geometry

Standard Wavefront OBJ (triangulated), the original scanned mesh used for MuJoCo collision and for the chamfer/coverage numbers in the manifest. material_0.png is its texture (appearance only). Objects are Google Scanned Objects (license: CC-BY 4.0).

6. Splits

heldout_object grasps belong to 35 objects never seen in training — use these to measure cross-object generalization. In the manifest these 35 objects have split = held-out.
train grasps + valgrasp grasps belong to the 136 training objects (split = train in the manifest). valgrasp are unseen grasps of seen objects (a within-object held-out set). The split field is per grasp (inside grasps.npz); the manifest split is per object (held-out iff the object has any heldout_object grasp).

7. Reproducing the exact WM network tensors (optional)

The packaged point_cloud and target are raw (physical units). The WM applies two standardizations you can reproduce with normalization/:

Cloud: subsample 4096 gaussians (the training + eval code draws them uniformly at random each forward — rng.choice(N, 4096), not farthest-point sampling; the packaged full cloud lets you sample however you like), then per-channel standardize with cloud_feat_stats.npz ((feat - mean) / std, in the 12-feature order above). Caveat: uniform-random subsampling oversamples dense regions, so thin structures (handles, rims, antennas) are represented by fewer of the 4096 points than farthest-point sampling would give — see §9.
Target: z-score with target_stats.npz ((target - mean) / std) and clip to ±8σ. Stats were computed from the train split only. These are a training convenience; the raw target in grasps.npz is the ground truth.

8. `manifest.csv` columns

object_id, shape_class, n_rigid_grasps, split, chamfer_mm, coverage_2p5mm, coverage_med_mm, accuracy_med_mm, n_recon_gaussians, mesh, point_cloud, grasps, reconstruction

shape_class ∈ convex / bottle-can / concave / handled / other.
chamfer_mm — symmetric chamfer between the packaged point cloud and the GT mesh surface (median object 0.86 mm).
coverage_2p5mm — fraction of GT surface within 2.5 mm of a gaussian (median 0.977).
accuracy_med_mm — median recon→surface distance (~0.7 mm; this is also the mesh↔cloud alignment sanity check).
The path columns are relative to the package root.

9. Known limitations (please read before drawing conclusions)

Direction is the hard part. Tilt magnitude is well determined by geometry; tilt direction has an intrinsic spread — for a given grasp, ±2.5 mm of grasp-center jitter alone produces ~~2–5° of direction variation, and the WM's cross-object direction error sits meaningfully above that floor. Treat sub-~~5° direction claims skeptically.
Center of mass is approximate. The simulator uses uniform-density inertia from the mesh hull, so hollow or unevenly-weighted real objects will tilt differently than these labels imply.
Coverage, and how to read the number. coverage_2p5mm (fraction of GT surface within 2.5 mm of a gaussian) has median 0.977 over the shipped 171 objects — computed on the exact packaged clouds (accuracy_med_mm ~0.7 mm is the alignment sanity check). An earlier internal audit (2026-06-30) reported median 0.927; that lower figure is object-set composition, not a different or more-aggressive cloud. The two agree per-object to < 0.002 on shared objects (the audit read byte-identical files), but the audit pool was a broader 100 objects, ~75 of which (median coverage 0.879) were later dropped and are not in this package. The shipped 171 are the cleaner-covered subset.
Thin / open / complex geometry is the coverage floor. The lowest-coverage shipped objects are open vessels and thin/protruding shapes: Room_Essentials_Salad_Plate 0.66, Wilton_Easy_Layers_Cake_Pan 0.76, Netgear_N750_Router 0.64, several flat game boxes ~0.72. The earlier audit found handled/open-vessel objects worst as a class (0.80 median on its pool); most of those specific objects were dropped, so the class-wide gap does not appear in the 171 (only 2 handled objects remain, both ≥ 0.93) — but per-object thin-structure coverage is still the weak axis, and the uniform-random 4096-subsample (§7) thins those regions further. Check coverage_2p5mm in the manifest per object.
Point clouds are floater-cleaned, per-object variable. Cleaning removes floaters/artifacts; how much is removed varies widely by object (kept counts range ~50k–200k gaussians — this is not a fixed downsample). Manifest chamfer/coverage describe the packaged cloud, not the raw splat; a few reconstructions may retain minor artifacts.
WM accuracy: high-tilt concave grasps are the largest errors (distinct from coverage above).
Rigid successes only. Slips/drops/spinners are excluded (see §3). Non-rigid episodes exist in the source pipeline and can be provided separately on request — they are not in this package, and rigid/non-rigid are never mixed.
Alignment is bbox-center-based. Mesh↔cloud alignment uses bounding-box center vs cloud centroid (median residual ~0.7 mm); it is not an ICP-tight registration.

10. Provenance

Grasp set: the corrected margin-2 rigid classification (rigid_final_aug_m2), the finalized version after fixing an earlier rigid-criterion bug that mislabeled spinners as rigid. Superseded/buggy grasp sets are not included.
Reconstructions: the current validated cleaned 3DGS clusters — verified to be the exact files the WM dataloader loads (point_cloud.npz round-trips against the live ChunkDS to ~1e-6), so the coverage numbers here describe the model's true input.
Everything here was copied from the source pipeline; originals were not modified.

11. Transferring the package

# CORE (~3.1 GB) — sufficient to use the data:
tar czf cdwm_core.tar.gz --exclude=reconstructions cdwm_grasp_dataset_v1

# FULL (~10.8 GB) — includes the color splats:
tar czf cdwm_full.tar.gz cdwm_grasp_dataset_v1

Then python load_example.py inside the extracted folder to confirm it loads.

Downloads last month: 49

Total file size:

8.02 GB

You need to agree to share your contact information to access this dataset

CD-WM Grasp Dataset

📂 This repository contains TWO datasets (configs)