roboteur/r1_block_tower_fixed_view

Simulated bimanual manipulation on Roboteur R1 — an OpenArm v2 pair on a legged torso — rendered in SAPIEN with path tracing. Generated with r1-sim.

What is in it

episodes	300
frames	225341
control / video rate	30 Hz
camera streams	4 x 640x360
robot	roboteur_r1_openarm2, 19 state channels

Cameras: head_left, head_right, wrist_left, wrist_right.

Features

feature	dtype	shape	units
action	float32	[19]	rad (absolute joint positions; gripper = signed finger angle, 0 shut)
action.tcp_pose	float32	[16]	m (xyz) / unit quaternion (wxyz) / rad (gripper), robot base frame
observation.state	float32	[19]	rad (absolute joint positions; gripper = signed finger angle, 0 shut)
observation.velocity	float32	[19]
observation.tcp_pose	float32	[16]	m (xyz) / unit quaternion (wxyz) / rad (gripper), robot base frame
observation.body	float32	[4]
subtask_index	int64	[1]
observation.images.head_left	video	[360, 640, 3]	uint8 RGB
observation.images.head_right	video	[360, 640, 3]	uint8 RGB
observation.images.wrist_left	video	[360, 640, 3]	uint8 RGB
observation.images.wrist_right	video	[360, 640, 3]	uint8 RGB

Channel names follow the OpenArm dataset spec (v0.4.0): f"{component}_{joint}.pos" with the right arm first, then the left. So observation.state is exactly the real recorder's 19-vector (openarm-teleop) — state[:16] the spec's 16-wide OpenArm block, state[16:19] the head pan/tilt/roll — byte-compatible with a real teleop recording, no slicing needed. The sim-only waist and leg joints ride in a separate observation.body feature that a real dataset simply does not have.

action is the same 19 channels in the same order (arm targets plus the head hold command), so state and action are index-comparable — column i of one is the same physical joint as column i of the other. observation.velocity carries the measured joint velocities under .vel names; there is no effort feature because the sim does not measure torque, and a zero-filled placeholder would be worse than an absent one.

Per-step object poses are deliberately not exported. They are privileged state, and on a task whose point is that the instruction picks the object, a policy handed exact poses can succeed without reading the instruction or the image. They remain in the source HDF5, and the scene ground truth is in meta/r1_scenes.jsonl.

Units and conventions

quantity	unit	note
joint positions	radians	absolute, not deltas; matches the spec's own sample values
gripper	radians, signed	0.0 = jaws shut; the right finger opens toward -0.785, the left toward +0.785
end-effector position	metres	x y z, in the robot base frame
end-effector rotation	unit quaternion	qw qx qy qz — w first
object poses	metres + qw qx qy qz	world frame, not the base frame
timestamp	seconds
images	uint8 RGB	640x360

Gripper polarity

The raw signed finger angle, matching the real recorder (openarm-teleop). 0.0 is shut on both arms; the URDF mirrors the arms, so the right finger joint runs 0 → −0.7854 as it opens where the left runs 0 → +0.7854. Nothing is folded to a magnitude: |value| is the openness, and the sign is the side. meta/r1_frames.json restates this per side, machine-readably.

• The controller takes the gripper as a normalised command in [−1, +1] while it takes the arm joints as absolute radians. The exporter converts that command into the same signed radians the state reports, so left_gripper.pos means the same quantity in action as it does in observation.state.
• Each gripper has two finger joints in the URDF and the second is a <mimic> of the first (multiplier 1, offset 0) — the same number twice. Only one is logged.

|openness| maps to a fingertip gap at the grasp point, measured off the collision meshes:

openness (rad)	0.000	0.196	0.393	0.589	0.785
jaw gap (mm)	0	36	57	74	92

Frames

End-effector poses are relative to the robot base, not the world. The two coincide numerically throughout this dataset — every stance here parks the base at the world origin with identity rotation — so a reader that assumes world frame gets the right answer by luck. Two stances in the library do not, and meta/r1_frames.json records the frame of every Cartesian feature. The base pose that converts between them is in meta/r1_scenes.jsonl per episode, as task_info.robot_pose.

Variation

Every episode randomises the scene and the robot's posture; the recipe for each one is in meta/r1_scenes.jsonl, keyed by episode index. The run-level settings those draws came from — shader and ray-tracing settings, lighting/dressing mode, clutter and posture ranges — are in meta/r1_generation.json.

• distractors — 3–10 objects drawn from a 415-instance library, placed clear of the task and of each other
• appearance — floor, wall and table textures drawn independently, plus lighting jitter
• posture — six initial arm-posture families with elbow swivel, sampled per arm; the idle arm stays where it starts
• height — the robot stands at one of five measured leg configurations
• roles — which objects play the task's roles varies per episode

Success

300 of 300 episodes end with the task's success check satisfied. The generator retries a seed whose scripted expert fails and keeps only successes, so this is a clean-demonstration corpus, not a measure of the expert's success rate.

Where the expert had to fall back from a Cartesian path to a joint-space one, the step is noted per episode in expert_failures (57 across the corpus). These are recovered episodes, not failed ones.