TingtingDu/trimanual-pick-up-cube

Trimanual Pick Up Cube

Teleoperated demonstrations of a cube pick-up task on a three-arm UFACTORY xArm6 rig, recorded for imitation learning / VLA training. Each arm has a different end effector, and each is teleoperated by its own 3Dconnexion SpaceMouse.

• 14 episodes, 4,333 steps, ~8.0 minutes of interaction
• 10 Hz synchronized timeline, 4 RGB camera streams, 3 arms
• Session trail_dumb1, recorded 2026-09-02

Rig

Arm	End effector	Wrist camera
xarm1	parallel finger gripper (xArm end module)	cam1
xarm2	vacuum gripper (xArm end module)	cam2
xarm3	actuated UMI gripper (Dynamixel XL430 over U2D2)	cam3

cam0 is a fixed third-person / agent view.

Layout

episode_XXXX/
  episode_XXXX.hdf5      # all observations + actions
  episode_XXXX_grid.mp4   # 2x2 preview of all four cameras
  meta.yaml               # session metadata, recorded topic list, camera config

Episode indices are non-contiguous (0001 and 0009 were discarded during collection). Only episode_0002 additionally ships per-camera mp4s (episode_0002_cam{0..3}.mp4); for every other episode the per-camera video is available as JPEG frames inside the HDF5.

HDF5 schema

n = number of steps in the episode. Cameras are stored as encoded JPEG bytes (variable-length uint8), not decoded arrays.

timestamps                              (n,)     float64   seconds
observations/
  images/cam{0,1,2,3}                   (n,)     object    JPEG bytes
  images/cam{0..3}_valid                (n,)     bool
  images/cam{0..3}_stamp_offset         (n,)     float32   frame stamp - step stamp (s)
  {xarm1,xarm2,xarm3}/
    qpos, qvel, qeff                    (n, 6)   float32   joint angles (rad), vel, effort
    eef                                 (n, 6)   float32   x,y,z (mm) + rpy (rad)
    eef_pos                             (n, 3)   float32   x,y,z in METRES
    eef_quat_xyzw                       (n, 4)   float32   scalar-last, sign-continuous
    ft_ext                              (n, 6)   float32   external F/T estimate
    gripper                             (n,)     float32   normalized 0=closed .. 1=open
    gripper_raw                         (n,)     float32   native units (ticks / mm / on-off)
    robot_state                         (n, 4)   float32   controller state, mode, err, warn
    *_valid                             (n,)     bool
    *_age                               (n,)     float32   staleness of the held sample (s)
action/
  {xarm1,xarm2,xarm3}/
    joint_vel_mean, joint_vel_last      (n, 6)   float32   commanded joint velocity
    cart_vel_mean, cart_vel_last        (n, 6)   float32   commanded cartesian velocity
    eef_pos                             (n, 3)   float32   next-step eef target (metres)
    eef_quat_xyzw                       (n, 4)   float32
    gripper                             (n,)     float32   commanded, normalized
    *_valid                             (n,)     bool

File-level attrs record fps, n_steps, duration_s, task, session, gripper types, the gripper calibration, measured topic rates, and the git commits of the recording stack.

Conventions

• eef rpy is EXTRINSIC xyz: R = Rz(yaw) @ Ry(pitch) @ Rx(roll), i.e. scipy.spatial.transform.Rotation.from_euler("xyz", rpy). Verified against URDF FK from the recorded joint angles to 0.002 deg mean error.
• observations/<arm>/eef is mm + rad; eef_pos is metres.
• eef_quat_xyzw is scalar-last and made sign-continuous along each episode.

Important caveats

Please read these before training on this data.

1. Always mask on *_valid. Invalid steps are written as rows of exact zeros by the zero-order-hold filler. Unmasked, a single zero row looks like an ~800 deg/s joint jump and will wreck both your statistics and your loss. All-zero joint angles is also a real reachable pose (arm straight up), so never send a raw row to a robot without checking its validity flag.
2. The recorded joint-velocity actions are clipped, not clean velocities. They are the teleop P-controller's output saturated at vel_max = 0.15, so 5-15% of commands sit exactly on the clip and the signal is closer to bang-bang than to a velocity. Prefer absolute joint position or the eef_pos/eef_quat_xyzw targets as the action label.
3. xarm3's end-effector pose is the bare flange. Its controller had no TCP offset configured at recording time, while xarm1 ([-0.6, 0.7, 171.5] mm) and xarm2 ([0, 0, 229] mm) did. xarm3's recorded "end effector" therefore sits roughly 15 cm behind the actual UMI gripper tip; apply your own offset if you train an end-effector policy on that arm.
4. No language instructions. Every episode's task field is the placeholder unlabeled. The task is cube pick-up, but there are no per-episode natural language annotations.
5. Camera skew exceeds the step interval. Mean inter-camera skew is ~139 ms against a 100 ms step, which is why every camera carries a stamp_offset column - filter on it if your method is sensitive to cross-camera timing.
6. cam1 is degraded: it runs at ~48 fps against a 60 fps target with ~870 ms latency (known USB3 instability), versus ~217 ms for the other cameras. It is stored with decimate: 2.
7. gripper normalization for xarm3 is calibration-relative. The Dynamixel runs in extended-position multi-turn mode with no absolute origin, so gripper_raw ticks are only meaningful through the calibration recorded in the file attrs (closed_ticks: 5029, open_ticks: 1594 - increasing ticks close this mechanism).

Loading

import h5py, numpy as np, cv2
from huggingface_hub import snapshot_download

path = snapshot_download("TingtingDu/trimanual-pick-up-cube", repo_type="dataset")

with h5py.File(f"{path}/episode_0000/episode_0000.hdf5", "r") as f:
    valid = f["observations/xarm1/qpos_valid"][:]
    qpos  = f["observations/xarm1/qpos"][valid]        # (n_valid, 6) rad

    # decode one camera frame
    buf   = f["observations/images/cam0"][0]
    frame = cv2.imdecode(np.frombuffer(buf, np.uint8), cv2.IMREAD_COLOR)

Per-episode summary

Episode	Steps	Duration (s)
episode_0000	511	55.6
episode_0002	398	43.9
episode_0003	373	38.6
episode_0004	403	45.0
episode_0005	500	54.2
episode_0006	212	24.2
episode_0007	253	28.9
episode_0008	354	37.5
episode_0010	213	23.6
episode_0011	253	28.0
episode_0012	259	30.1
episode_0013	231	26.4
episode_0014	182	21.8
episode_0015	191	21.2

Per-signal validity is at or near 100% for every arm and camera across all episodes; the lowest single value is 94.6% (xarm3 gripper, episode_0008).