Upload folder using huggingface_hub

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/ability.py

@@ -0,0 +1,84 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+ability_asset_dir = "ability_hand/"
+left_rel_urdf = join(ability_asset_dir, "ability_hand_left_6dof.urdf")
+right_rel_urdf = join(ability_asset_dir, "ability_hand_right_6dof.urdf")
+
+ABILITY_MIMIC_JOINTS = {
+    "index_q2": ("index_q1", 1.05851325),
+    "middle_q2": ("middle_q1", 1.05851325),
+    "ring_q2": ("ring_q1", 1.05851325),
+    "pinky_q2": ("pinky_q1", 1.05851325),
+}
+
+ABILITY_ACT_FINGER_JOINTS = ["thumb_q1", "thumb_q2", "index_q1", "middle_q1", "ring_q1", "pinky_q1"]
+
+ABILITY_MIMIC=dict(left=dict(), right=dict())
+for name, (target, multiplier) in ABILITY_MIMIC_JOINTS.items():
+    for side in ["left", "right"]:
+        ABILITY_MIMIC[side][name] = (target, multiplier)
+
+ABILITY_LINKS=["thumb_tip",  "index_tip", "middle_tip", "ring_tip", "pinky_tip", "thumb_L1", "index_L1", "middle_L1", "ring_L1", "pinky_L1"]
+
+ABILITY_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "base",
+    "mimic_joint_map": ABILITY_MIMIC['left'].copy(),
+    "kpt_link_names": ABILITY_LINKS.copy(),
+    "joint_limits": {
+        "index_q1": (0.26, 2.0943951),
+        "index_q2": (0.26, 2.6586),
+        "middle_q1": (0.26, 2.0943951),
+        "middle_q2": (0.26, 2.6586),
+        "ring_q1": (0.26, 2.0943951),
+        "ring_q2": (0.26, 2.6586),
+        "pinky_q1": (0.26, 2.0943951),
+        "pinky_q2": (0.26, 2.6586),
+    },
+    "actuators": {
+        "finger": dict(
+            joint_exprs=['.*q1', '.*q2'],
+            kp=40.0,
+            kv=3.0,
+            force_range=50.0,
+        ),
+        "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=80,
+            kv=4.5,
+            force_range=50.0,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=300,
+            kv=4.0,
+            force_range=100,
+        ),
+    },
+    "collision_groups": {7: 0, 8: 0, 14: 1, 15: 2, 16: 3, 17: 4, 18: 5},
+    "collision_palm_name": "thumb_base",
+}
+
+ABILITY_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "base",
+    "mimic_joint_map": ABILITY_MIMIC['right'].copy(),
+    "kpt_link_names": ABILITY_LINKS.copy(),
+    "joint_limits": {
+        "index_q1": (0.26, 2.0943951),
+        "index_q2": (0.26, 2.6586),
+        "middle_q1": (0.26, 2.0943951),
+        "middle_q2": (0.26, 2.6586),
+        "ring_q1": (0.26, 2.0943951),
+        "ring_q2": (0.26, 2.6586),
+        "pinky_q1": (0.26, 2.0943951),
+        "pinky_q2": (0.26, 2.6586),
+    }, 
+    "actuators": ABILITY_LEFT_CFG["actuators"].copy(),
+    "collision_groups": {7: 0, 8: 0, 14: 1, 15: 2, 16: 3, 17: 4, 18: 5},
+    "collision_palm_name": "thumb_base",
+}
+
+ABILITY_CFGs=dict(left=ABILITY_LEFT_CFG, right=ABILITY_RIGHT_CFG)

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/allegro.py

@@ -0,0 +1,49 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+allegro_asset_dir = "allegro_hand/"
+left_rel_urdf = join(allegro_asset_dir, "allegro_hand_left_6dof.urdf") 
+right_rel_urdf = join(allegro_asset_dir, "allegro_hand_right_6dof.urdf")
+
+ALLEGRO_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "base_dummy_link",
+    "kpt_link_names": ["link_15.0_tip", "link_11.0_tip", "link_7.0_tip", "link_3.0_tip" ],
+    "actuators": {
+        "finger": dict(
+            joint_exprs=['.*.0.+'],
+            kp=30.0,
+            kv=2.0,
+            force_range=100.0,
+        ),
+        "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=60,
+            kv=5.0,
+            force_range=100.0,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=350.0,
+            kv=20.0,
+            force_range=100.0,
+        ),
+    },
+    "collision_groups": {8: 0, 13: 1, 14: 2, 15: 3, 16: 4, 17: 1, 18: 2, 19: 3, 20: 4, 21: 1, 22: 2, 23: 3, 24: 4, 25: 1, 26: 2, 27: 3, 28: 4},
+    "collision_palm_name": "base_link",
+}
+
+ALLEGRO_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "base_dummy_link",
+    "kpt_link_names": ["link_15.0_tip", "link_3.0_tip", "link_7.0_tip", "link_11.0_tip" ],
+    "actuators": ALLEGRO_LEFT_CFG["actuators"].copy(),
+    "collision_groups": {8: 0, 13: 1, 14: 2, 15: 3, 16: 4, 17: 1, 18: 2, 19: 3, 20: 4, 21: 1, 22: 2, 23: 3, 24: 4, 25: 1, 26: 2, 27: 3, 28: 4},
+    "collision_palm_name": "base_link",
+}
+
+ALLEGRO_CFGs=dict(
+    left=ALLEGRO_LEFT_CFG,
+    right=ALLEGRO_RIGHT_CFG,
+)

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/dex3.py

@@ -0,0 +1,49 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+dex3_asset_dir = "dex3_hand/" 
+left_rel_urdf = join(dex3_asset_dir, "dex3_left_6dof.urdf")
+right_rel_urdf = join(dex3_asset_dir, "dex3_right_6dof.urdf")
+
+DEX3_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "left_hand_palm_link",
+    "kpt_link_names": ['left_hand_palm_link', 'left_hand_thumb_0_link', 'left_hand_middle_0_link', 'left_hand_index_0_link', 'left_hand_thumb_1_link', 'left_hand_middle_1_link', 'left_hand_index_1_link', 'left_hand_thumb_2_link'],
+    "actuators": {
+      "finger": dict(
+        joint_exprs=[".*0_joint", ".*1_joint", ".*2_joint"],
+        kp=100.0,
+        kv=6,
+        force_range=50.0,
+      ),
+      "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=200,
+            kv=10,
+            force_range=50.0,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=300,
+            kv=5.0,
+            force_range=50.0,
+        ),
+    },
+    "collision_groups": {7: 0, 11: 1, 12: 2, 13: 3, 14: 1},
+    "collision_palm_name": "left_hand_palm_link", 
+}
+
+DEX3_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "right_hand_palm_link",
+    "kpt_link_names": ['right_hand_palm_link', 'right_hand_thumb_0_link', 'right_hand_middle_0_link', 'right_hand_index_0_link', 'right_hand_thumb_1_link', 'right_hand_middle_1_link', 'right_hand_index_1_link', 'right_hand_thumb_2_link'],    
+    "collision_groups": {7: 0, 11: 1, 12: 2, 13: 3, 14: 1},
+    "collision_palm_name": "right_hand_palm_link", 
+    "actuators": DEX3_LEFT_CFG["actuators"].copy(),
+}
+
+DEX3_CFGs=dict(
+    left=DEX3_LEFT_CFG,
+    right=DEX3_RIGHT_CFG,
+)

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/dexrobot.py

@@ -0,0 +1,49 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+dex_asset_dir = "dexrobot_hand/"
+left_rel_urdf = join(dex_asset_dir, "dexhand021_left_6dof.urdf")
+right_rel_urdf = join(dex_asset_dir, "dexhand021_right_6dof.urdf")
+
+DEX_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "base_dummy",
+    "kpt_link_names": ["l_f_link1_tip",  "l_f_link2_tip", "l_f_link3_tip", "l_f_link4_tip", "l_f_link5_tip"], # should be overwritten with retargeting
+    "actuators": {
+        "finger": dict(
+            joint_exprs=['[lr]_f.*'],
+            kp=50.0,
+            kv=3,
+            force_range=100.0,
+        ),
+        "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=70,
+            kv=4,
+            force_range=100.0,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=300.0,
+            kv=15.0,
+            force_range=100.0,
+        ),
+    },
+    "collision_groups": {7: 0, 14: 2, 15: 3, 16: 4, 17: 5, 18: 6, 19: 2, 20: 3, 21: 4, 22: 5, 23: 6, 24: 2, 25: 3, 26: 4, 27: 5, 28: 6, 29: 2, 30: 2, 31: 3, 32: 3, 33: 4, 34: 4, 35: 5, 36: 5, 37: 6, 38: 6},
+    "collision_palm_name": "left_hand_base",
+}
+
+DEX_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "base_dummy",
+    "kpt_link_names": ["r_f_link1_tip",  "r_f_link2_tip", "r_f_link3_tip", "r_f_link4_tip", "r_f_link5_tip"], # should be overwritten with retargeting
+    "actuators": DEX_LEFT_CFG["actuators"].copy(),
+    "collision_groups": {7: 0, 14: 2, 15: 3, 16: 4, 17: 5, 18: 6, 19: 2, 20: 3, 21: 4, 22: 5, 23: 6, 24: 2, 25: 3, 26: 4, 27: 5, 28: 6, 29: 2, 30: 2, 31: 3, 32: 3, 33: 4, 34: 4, 35: 5, 36: 5, 37: 6, 38: 6},
+    "collision_palm_name": "right_hand_base",
+} 
+
+DEX_CFGs=dict(
+    left=DEX_LEFT_CFG,
+    right=DEX_RIGHT_CFG,
+)

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/inspire.py

@@ -0,0 +1,91 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+inspire_asset_dir = "inspire_hand/" 
+left_rel_urdf = join(inspire_asset_dir, "left_xyz_copy.urdf")
+right_rel_urdf = join(inspire_asset_dir, "right_xyz_copy.urdf")
+
+MIMIC_JOINTS={
+    "TH_J3": ("TH_J2", 1.0),
+    "TH_J4": ("TH_J2", 1.13),
+    "FF_J2": ("FF_J1", 1.13),
+    "MF_J2": ("MF_J1", 1.13),
+    "RF_J2": ("RF_J1", 1.08),
+    "LF_J2": ("LF_J1", 1.13),
+}
+INSPIRE_LEFT_MIMIC_JOINTS=dict()
+for name, (parent, ratio) in MIMIC_JOINTS.items():
+    INSPIRE_LEFT_MIMIC_JOINTS[f"L_{name}"] = (f"L_{parent}", ratio)
+INSPIRE_RIGHT_MIMIC_JOINTS=dict()
+for name, (parent, ratio) in MIMIC_JOINTS.items():
+    INSPIRE_RIGHT_MIMIC_JOINTS[f"R_{name}"] = (f"R_{parent}", ratio) 
+
+INSPIRE_LINK_NAMES=["TH_Tip", "FF_Tip", "MF_Tip", "RF_Tip", "LF_Tip"]
+INSPIRE_DEFAULT_QPOS={ 
+    'left':  [0.25, 0.11, 1.0, 0.76, 0.18, 0.58, 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  ],
+    'right': [-0.35, 0.1, 1.05, -0.37, 0.23,  2.64,  0.  ,  0.  ,  0.  , 0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ]
+}
+
+INSPIRE_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "base_link",
+    "mimic_joint_map": INSPIRE_LEFT_MIMIC_JOINTS.copy(),
+    "kpt_link_names": ['L_'+name for name in INSPIRE_LINK_NAMES],
+    # NOTE: this gets reset by demo data
+    "joint_limits": {    
+        "L_forearm_tx_link_joint": (-0.05, 0.3),
+        "L_forearm_ty_link_joint": (-0.1, 0.2),
+        "L_forearm_tz_link_joint": (1.0, 1.3),
+
+        "L_forearm_roll_link_joint": (-0.25, 0.5),
+        "L_forearm_pitch_link_joint": (0.2, 0.6),
+        "L_forearm_yaw_link_joint": (-0.7, 0.4),
+    },
+    "default_qpos": INSPIRE_DEFAULT_QPOS['left'],
+    "actuators": {
+        "finger": dict(
+            joint_exprs=['.*J1', '.*J2', '.*J3', '.*J4'],
+            kp=20.0,
+            kv=1.0,
+            force_range=50.0,
+        ),
+        "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=80,
+            kv=5.0,
+            force_range=50.0,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=350,
+            kv=12.0,
+            force_range=50.0,
+        ),
+    },
+    "collision_groups": {7: 0, 13: 1, 14: 2, 15: 3, 16: 4, 17: 5, 18: 1, 23: 1},
+    "collision_palm_name": "base_link", 
+}
+
+INSPIRE_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "base_link",
+    "mimic_joint_map": INSPIRE_RIGHT_MIMIC_JOINTS.copy(),
+    "kpt_link_names": ['R_'+name for name in INSPIRE_LINK_NAMES],
+    # NOTE: this gets reset by demo data
+    "joint_limits": {
+        "R_forearm_tx_link_joint": (-0.4, -0.1),
+        "R_forearm_ty_link_joint": (-0.1, 0.2),
+        "R_forearm_tz_link_joint": (1.0, 1.3),
+        
+        "R_forearm_roll_link_joint": (-0.4, 0.2), 
+        "R_forearm_pitch_link_joint": (0.0, 0.6),
+        "R_forearm_yaw_link_joint": (2.5, 3.1), 
+    },
+    "default_qpos": INSPIRE_DEFAULT_QPOS['right'],
+    "actuators": INSPIRE_LEFT_CFG["actuators"].copy(),
+    "collision_groups": INSPIRE_LEFT_CFG["collision_groups"].copy(),
+    "collision_palm_name": INSPIRE_LEFT_CFG["collision_palm_name"],
+}
+
+INSPIRE_CFGs=dict(left=INSPIRE_LEFT_CFG, right=INSPIRE_RIGHT_CFG)

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/schunk.py

@@ -0,0 +1,76 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+schunk_asset_dir = "schunk_hand/"
+left_rel_urdf = join(schunk_asset_dir, "schunk_hand_left_6dof.urdf")
+right_rel_urdf = join(schunk_asset_dir, "schunk_hand_right_6dof.urdf")
+
+SCHUNK_MIMIC_JOINTS_LEFT = {
+    'left_hand_j5': ('left_hand_Thumb_Opposition', 1.0),
+    'left_hand_j3': ('left_hand_Thumb_Flexion', 1.01511),
+    'left_hand_j4': ('left_hand_Thumb_Flexion', 1.44889),
+    'left_hand_j14': ('left_hand_Index_Finger_Distal', 1.045),
+    'left_hand_j15': ('left_hand_Middle_Finger_Distal', 1.0454),
+    'left_hand_j12': ('left_hand_Ring_Finger', 1.3588),
+    'left_hand_j16': ('left_hand_Ring_Finger', 1.42093),
+    'left_hand_j13': ('left_hand_Pinky', 1.3588),
+    'left_hand_j17': ('left_hand_Pinky', 1.42307),
+    'left_hand_index_spread': ('left_hand_Finger_Spread', 0.5),
+    'left_hand_ring_spread': ('left_hand_Finger_Spread', 0.5),
+}  
+
+SCHUNK_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "left_hand_base_link",
+    "kpt_link_names": ["thtip", "fftip", "mftip", "rftip", "lftip", "left_hand_b", "left_hand_p", "left_hand_o", "left_hand_n", "left_hand_i"],
+    "mimic_joint_map": SCHUNK_MIMIC_JOINTS_LEFT.copy(),
+    "actuators": {
+        "finger": dict(
+            joint_exprs=['.*hand.+'],
+            kp=80,
+            kv=4.5,
+            force_range=80,
+        ),
+        "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=80,
+            kv=5,
+            force_range=100,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=350,
+            kv=8,
+            force_range=100,
+        ),
+    },
+    "collision_groups": {7: 0, 8: 0, 13: 1, 14: 1, 15: 2, 16: 3, 17: 4, 18: 1, 19: 1, 20: 2, 21: 3, 22: 4, 23: 1, 24: 1, 25: 2, 26: 3, 27: 4, 28: 1, 29: 1},
+    "collision_palm_name": "left_hand_e1",  
+}
+
+SCHUNK_MIMIC_JOINTS_RIGHT={
+    'right_hand_j5': ('right_hand_Thumb_Opposition', 1.0),
+    'right_hand_j3': ('right_hand_Thumb_Flexion', 1.01511),
+    'right_hand_j4': ('right_hand_Thumb_Flexion', 1.44889),
+    'right_hand_j14': ('right_hand_Index_Finger_Distal', 1.045),
+    'right_hand_j15': ('right_hand_Middle_Finger_Distal', 1.0454),
+    'right_hand_j12': ('right_hand_Ring_Finger', 1.3588),
+    'right_hand_j16': ('right_hand_Ring_Finger', 1.42093),
+    'right_hand_j13': ('right_hand_Pinky', 1.3588),
+    'right_hand_j17': ('right_hand_Pinky', 1.42307),
+    'right_hand_index_spread': ('right_hand_Finger_Spread', 0.5),
+    'right_hand_ring_spread': ('right_hand_Finger_Spread', 0.5),
+} 
+
+SCHUNK_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "right_hand_base_link",
+    "kpt_link_names": ["thtip", "fftip", "mftip", "rftip", "lftip", "right_hand_b", "right_hand_p", "right_hand_o", "right_hand_n", "right_hand_i"],
+    "mimic_joint_map": SCHUNK_MIMIC_JOINTS_RIGHT.copy(),
+    "actuators": SCHUNK_LEFT_CFG["actuators"].copy(),
+    "collision_groups": {7: 0, 8: 0, 13: 1, 14: 1, 15: 2, 16: 3, 17: 4, 18: 1, 19: 1, 20: 2, 21: 3, 22: 4, 23: 1, 24: 1, 25: 2, 26: 3, 27: 4, 28: 1, 29: 1},
+    "collision_palm_name": "right_hand_e1",
+}
+
+SCHUNK_CFGs=dict(left=SCHUNK_LEFT_CFG, right=SCHUNK_RIGHT_CFG)

outputs/_runtime_patches/dexmachina/envs/hand_cfgs/xhand.py

@@ -0,0 +1,49 @@
+import os  
+from os.path import join
+from dexmachina.asset_utils import get_urdf_path
+
+xhand_asset_dir = "xhand/"
+left_rel_urdf = join(xhand_asset_dir, "xhand_left_6dof.urdf")
+right_rel_urdf = join(xhand_asset_dir, "xhand_right_6dof.urdf")
+
+XHAND_LEFT_CFG={
+    "urdf_path": get_urdf_path(left_rel_urdf),
+    "wrist_link_name": "left_hand_link",
+    "kpt_link_names": ["left_hand_thumb_rota_tip", "left_hand_index_rota_tip", "left_hand_mid_tip", "left_hand_ring_tip", "left_hand_pinky_tip"], 
+    "actuators": {
+        "finger": dict(
+            joint_exprs=['.*joint.+'],
+            kp=20.0,
+            kv=1.5,
+            force_range=100.0,
+        ),
+        "wrist_rot": dict(
+            joint_exprs=[r'[LR]_forearm_(roll|pitch|yaw)_link_joint'],
+            kp=60.0,
+            kv=3.0,
+            force_range=100,
+        ),
+        "wrist_trans": dict(
+            joint_exprs=[r'[LR]_forearm_t[xyz]_link_joint'],
+            kp=350.0,
+            kv=15.0,
+            force_range=100,
+        ),
+    },
+    "collision_groups": {7: 0, 13: 1, 14: 2, 15: 3, 16: 4, 17: 5, 18: 1, 19: 2},
+    "collision_palm_name": "left_hand_link",
+}
+
+XHAND_RIGHT_CFG={
+    "urdf_path": get_urdf_path(right_rel_urdf),
+    "wrist_link_name": "right_hand_link",
+    "kpt_link_names": ["right_hand_thumb_rota_tip", "right_hand_index_rota_tip", "right_hand_mid_tip", "right_hand_ring_tip", "right_hand_pinky_tip"],
+    "actuators": XHAND_LEFT_CFG["actuators"].copy(),
+    "collision_groups": {7: 0, 13: 1, 14: 2, 15: 3, 16: 4, 17: 5, 18: 1, 19: 2},
+    "collision_palm_name": "right_hand_link",
+}
+
+XHAND_CFGs=dict(
+    left=XHAND_LEFT_CFG,
+    right=XHAND_RIGHT_CFG,
+)

outputs/_scripts/scene_demo.py

@@ -0,0 +1,186 @@
+"""End-to-end Genesis/dexmachina scene demo.
+
+Runs inside the `benchmarking/dexmachina:latest` container. Patches the
+installed `dexmachina` package with the missing `envs/hand_cfgs/` submodule
+(copied to `outputs/_runtime_patches` on the host, volume-mounted at
+`/workspace/outputs/_runtime_patches`), verifies imports, builds a small
+Genesis scene (ground plane + xhand URDF), renders 60 frames and muxes them
+into an mp4 via `shared.bench.VideoRecorder`.
+
+All output artefacts are written under `/workspace/outputs/`.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import time
+import traceback
+from pathlib import Path
+
+OUT_ROOT = Path("/workspace/outputs")
+LOG_PATH = OUT_ROOT / "logs" / "dexmachina_scene_demo.log"
+MP4_PATH = OUT_ROOT / "videos" / "dexmachina_xhand_demo.mp4"
+LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+MP4_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+log_buf = []
+
+def log(msg: str) -> None:
+    print(msg, flush=True)
+    log_buf.append(str(msg))
+
+
+def flush_log() -> None:
+    LOG_PATH.write_text("\n".join(log_buf) + "\n")
+
+
+# ---- 1. runtime-patch dexmachina.envs.hand_cfgs (missing in installed wheel)
+def patch_hand_cfgs() -> None:
+    import dexmachina
+    dst = Path(dexmachina.__file__).parent / "envs" / "hand_cfgs"
+    src = Path("/workspace/outputs/_runtime_patches/dexmachina/envs/hand_cfgs")
+    if not dst.exists():
+        if not src.exists():
+            raise RuntimeError(f"hand_cfgs staged source missing: {src}")
+        shutil.copytree(src, dst)
+        log(f"patched: copied {src} -> {dst}")
+    else:
+        log(f"hand_cfgs already present at {dst}")
+
+
+# ---- 2. import graph
+def do_imports() -> dict:
+    import importlib.metadata as im
+    import torch, genesis, rl_games, dexmachina  # noqa: F401
+    from dexmachina.envs.hand_cfgs.xhand import XHAND_CFGs
+    from dexmachina.envs import base_env
+
+    info = {
+        "torch": torch.__version__,
+        "genesis": getattr(genesis, "__version__", "ok"),
+        "rl_games": im.version("rl_games"),
+        "dexmachina": im.version("dexmachina"),
+        "cuda_available": bool(torch.cuda.is_available()),
+        "BaseEnv": base_env.BaseEnv.__name__,
+        "XHAND_CFGs_keys": list(XHAND_CFGs.keys()),
+    }
+    return info
+
+
+# ---- 3. scene demo
+def run_scene_demo() -> dict:
+    import numpy as np
+    import torch
+    import genesis as gs
+    sys.path.insert(0, "/workspace/shared")
+    from bench.video_recorder import VideoRecorder
+
+    backend = gs.cuda if torch.cuda.is_available() else gs.cpu
+    log(f"genesis.init backend={backend}")
+    gs.init(backend=backend, logging_level="warning")
+
+    scene = gs.Scene(show_viewer=False)
+
+    # ground plane
+    scene.add_entity(gs.morphs.Plane())
+
+    # xhand URDF (right hand is the standard variant)
+    # Preference order: staging-backed /workspace/assets symlinks (but in this
+    # image those aren't mounted, so the symlink target is missing), then the
+    # dexmachina-shipped URDF. We try both so future mount changes "just work".
+    candidates = [
+        "/workspace/assets/urdf/xhand/xhand_urdf/xhand_right/urdf/xhand_right.urdf",
+        "/usr/local/lib/python3.10/dist-packages/dexmachina/assets/xhand/xhand_right.urdf",
+    ]
+    urdf_path = next((p for p in candidates if Path(p).exists()), None)
+    assert urdf_path is not None, f"no xhand urdf found among {candidates}"
+    log(f"urdf_path={urdf_path}")
+    hand = scene.add_entity(
+        gs.morphs.URDF(
+            file=urdf_path,
+            pos=(0.0, 0.0, 0.25),
+            fixed=True,
+        )
+    )
+
+    W, H = 640, 480
+    camera = scene.add_camera(
+        res=(W, H),
+        pos=(0.6, 0.6, 0.45),
+        lookat=(0.0, 0.0, 0.2),
+        fov=45,
+        GUI=False,
+    )
+
+    scene.build()
+    log(f"scene built; hand entity: {hand}")
+
+    rec = VideoRecorder(MP4_PATH, fps=30, size=(W, H))
+    n_frames = 60
+    t0 = time.time()
+    for i in range(n_frames):
+        scene.step()
+        out = camera.render()
+        # Genesis camera.render returns a tuple (rgb, depth, seg, normal)
+        rgb = out[0] if isinstance(out, tuple) else out
+        if hasattr(rgb, "cpu"):
+            rgb = rgb.cpu().numpy()
+        if rgb.dtype != np.uint8:
+            rgb = rgb.astype(np.uint8)
+        if rgb.shape[-1] == 4:
+            rgb = rgb[..., :3]
+        rec.log_frame(np.ascontiguousarray(rgb))
+    rec.close()
+    dt = time.time() - t0
+
+    size_bytes = MP4_PATH.stat().st_size
+    log(f"rendered {n_frames} frames {W}x{H} in {dt:.2f}s; mp4={MP4_PATH} ({size_bytes} bytes)")
+    return {
+        "mp4_path": str(MP4_PATH),
+        "frames": n_frames,
+        "resolution": [W, H],
+        "mp4_size_bytes": size_bytes,
+        "backend": str(backend),
+        "elapsed_s": round(dt, 3),
+    }
+
+
+def main() -> int:
+    result = {"ok": True, "steps": {}}
+    try:
+        patch_hand_cfgs()
+        imports = do_imports()
+        result["steps"]["imports"] = imports
+        log("IMPORTS: " + json.dumps(imports))
+    except Exception as e:
+        result["ok"] = False
+        result["steps"]["imports_error"] = repr(e)
+        log("IMPORT ERROR: " + repr(e))
+        log(traceback.format_exc())
+        flush_log()
+        (OUT_ROOT / "logs" / "dexmachina_scene_demo.json").write_text(json.dumps(result, indent=2))
+        return 2
+
+    try:
+        scene_info = run_scene_demo()
+        result["steps"]["scene"] = scene_info
+        log("SCENE: " + json.dumps(scene_info))
+    except Exception as e:
+        result["ok"] = False
+        result["steps"]["scene_error"] = repr(e)
+        log("SCENE ERROR: " + repr(e))
+        log(traceback.format_exc())
+        flush_log()
+        (OUT_ROOT / "logs" / "dexmachina_scene_demo.json").write_text(json.dumps(result, indent=2))
+        return 3
+
+    flush_log()
+    (OUT_ROOT / "logs" / "dexmachina_scene_demo.json").write_text(json.dumps(result, indent=2))
+    log("DONE")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

outputs/logs/dexmachina_scene_demo.json

@@ -0,0 +1,28 @@
+{
+  "ok": true,
+  "steps": {
+    "imports": {
+      "torch": "2.5.1+cu121",
+      "genesis": "0.3.3",
+      "rl_games": "1.6.1",
+      "dexmachina": "0.1.0",
+      "cuda_available": true,
+      "BaseEnv": "BaseEnv",
+      "XHAND_CFGs_keys": [
+        "left",
+        "right"
+      ]
+    },
+    "scene": {
+      "mp4_path": "/workspace/outputs/videos/dexmachina_xhand_demo.mp4",
+      "frames": 60,
+      "resolution": [
+        640,
+        480
+      ],
+      "mp4_size_bytes": 20042,
+      "backend": "backend.cuda",
+      "elapsed_s": 34.933
+    }
+  }
+}

outputs/logs/dexmachina_scene_demo.log

@@ -0,0 +1,7 @@
+patched: copied /workspace/outputs/_runtime_patches/dexmachina/envs/hand_cfgs -> /usr/local/lib/python3.10/dist-packages/dexmachina/envs/hand_cfgs
+IMPORTS: {"torch": "2.5.1+cu121", "genesis": "0.3.3", "rl_games": "1.6.1", "dexmachina": "0.1.0", "cuda_available": true, "BaseEnv": "BaseEnv", "XHAND_CFGs_keys": ["left", "right"]}
+genesis.init backend=gs.cuda
+urdf_path=/usr/local/lib/python3.10/dist-packages/dexmachina/assets/xhand/xhand_right.urdf
+scene built; hand entity: <gs.RigidEntity>
+rendered 60 frames 640x480 in 34.93s; mp4=/workspace/outputs/videos/dexmachina_xhand_demo.mp4 (20042 bytes)
+SCENE: {"mp4_path": "/workspace/outputs/videos/dexmachina_xhand_demo.mp4", "frames": 60, "resolution": [640, 480], "mp4_size_bytes": 20042, "backend": "backend.cuda", "elapsed_s": 34.933}

outputs/logs/spider_lift_board_allegro.log

@@ -0,0 +1,25 @@
+   Building spider @ file:///opt/spider
+      Built spider @ file:///opt/spider
+Uninstalled 1 package in 20ms
+Installed 1 package in 2ms
+Warp 1.11.0.dev20251120 initialized:
+   Git commit: bf8830d11365ac5061c779c55b5278d733076d4f
+   CUDA Toolkit 12.8, Driver 13.0
+   Devices:
+     "cpu"      : "x86_64"
+     "cuda:0"   : "NVIDIA A100 80GB PCIe" (79 GiB, sm_80, mempool enabled)
+   Kernel cache:
+     /root/.cache/warp/1.11.0.dev20251120
+Error executing job with overrides: ['+override=oakink', 'task=lift_board', 'data_id=0', 'robot_type=allegro', 'embodiment_type=bimanual']
+Traceback (most recent call last):
+  File "/opt/spider/examples/run_mjwp.py", line 615, in run_main
+    main(config)
+  File "/opt/spider/examples/run_mjwp.py", line 185, in main
+    config = process_config(config)
+             ^^^^^^^^^^^^^^^^^^^^^^
+  File "/opt/spider/spider/config.py", line 448, in process_config
+    model = mujoco.MjModel.from_xml_path(config.model_path)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ValueError: ParseXML: Error opening file '/opt/spider/example_datasets/processed/oakink/allegro/bimanual/lift_board/0/../scene.xml'
+
+Set the environment variable HYDRA_FULL_ERROR=1 for a complete stack trace.

outputs/logs/spider_record_frames.py

@@ -0,0 +1,79 @@
+"""Offscreen render the Spider Allegro bimanual hand scene to mp4.
+
+Used by the end-to-end evaluation to prove:
+ 1. MuJoCo (the Spider sim backend) loads the hand assets baked into the image.
+ 2. shared.bench.VideoRecorder encodes rendered frames into a valid mp4.
+
+Runs inside the `benchmarking/spider:latest` image with MUJOCO_GL=egl.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import mujoco
+import numpy as np
+
+# shared/bench is on the default PYTHONPATH of the spider container.
+from bench.video_recorder import VideoRecorder
+
+XML = "/opt/spider/spider/assets/robots/allegro/bimanual.xml"
+OUT = Path("/workspace/outputs/videos/spider_allegro_oakink_lift_board_bimanual_data0.mp4")
+W, H = 640, 480
+FPS = 30
+N_FRAMES = 60  # 2s of video
+
+
+def main() -> int:
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    model = mujoco.MjModel.from_xml_path(XML)
+    data = mujoco.MjData(model)
+    print(f"model loaded: nq={model.nq} nv={model.nv} nu={model.nu} nbody={model.nbody}")
+
+    # Basic sweep: oscillate each hinge around its midrange to prove the scene
+    # is alive and frames differ. We don't have a retargeted qpos trajectory
+    # (preprocessed npz isn't in the image), so this is a synthetic wave.
+    jnt_range = model.jnt_range.copy()
+    mid = 0.5 * (jnt_range[:, 0] + jnt_range[:, 1])
+    amp = 0.5 * (jnt_range[:, 1] - jnt_range[:, 0])
+    limited = model.jnt_limited.astype(bool)
+    mid = np.where(limited, mid, 0.0)
+    amp = np.where(limited, amp, 0.2)
+
+    renderer = mujoco.Renderer(model, height=H, width=W)
+
+    with VideoRecorder(OUT, fps=FPS, size=(W, H)) as rec:
+        for t in range(N_FRAMES):
+            phase = 2.0 * np.pi * t / N_FRAMES
+            qpos_joint = mid + amp * 0.3 * np.sin(phase + np.arange(model.njnt) * 0.1)
+            # Set per-joint qpos via qpos_addr to avoid size mismatches when
+            # some joints (e.g. free joints) span multiple qpos entries.
+            data.qpos[:] = 0.0
+            for j in range(model.njnt):
+                addr = model.jnt_qposadr[j]
+                jtype = model.jnt_type[j]
+                if jtype == mujoco.mjtJoint.mjJNT_HINGE or jtype == mujoco.mjtJoint.mjJNT_SLIDE:
+                    data.qpos[addr] = qpos_joint[j]
+                elif jtype == mujoco.mjtJoint.mjJNT_FREE:
+                    # leave pose at identity, just set position z=0
+                    data.qpos[addr : addr + 3] = 0.0
+                    data.qpos[addr + 3] = 1.0
+                    data.qpos[addr + 4 : addr + 7] = 0.0
+            mujoco.mj_forward(model, data)
+            renderer.update_scene(data)
+            frame = renderer.render()  # H x W x 3 uint8
+            assert frame.shape == (H, W, 3), frame.shape
+            assert frame.dtype == np.uint8, frame.dtype
+            rec.log_frame(frame)
+        out_path = rec.close()
+
+    size_bytes = out_path.stat().st_size if out_path.exists() else 0
+    print(f"wrote {out_path} bytes={size_bytes} frames={N_FRAMES} res={W}x{H}")
+    if size_bytes < 1024:
+        print("ERROR: mp4 too small", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

outputs/logs/spider_vnc_check.log

@@ -0,0 +1,17 @@
+VNC stack verification — 2026-04-16
+container: c0da598ab305 (benchmarking/spider:latest, viz overlay)
+ports: 0.0.0.0:5903->5901/tcp (RFB), 0.0.0.0:6903->6901/tcp (noVNC)
+
+curl http://localhost:6903/vnc.html
+  HTTP_CODE=200 SIZE=15850
+  <!DOCTYPE html><html class="noVNC_loading">...<title>noVNC</title>...
+
+docker exec ... ps -eo pid,comm,args (filtered):
+  45 Xvnc       Xvnc :1 -geometry 1600x900 -depth 24 -rfbport 5901 -SecurityTypes None -AlwaysShared
+  46 fluxbox    fluxbox
+  47 websockify /usr/bin/python3 /usr/bin/websockify --web=/usr/share/novnc 6901 localhost:5901
+
+xwininfo not installed inside the spider image — fell back to `ps` to prove the
+Xvnc+fluxbox+websockify chain is live. Geometry matches docker-compose.viz.yml
+(VIZ_GEOMETRY=1600x900). A browser pointed at http://<host>:6903/vnc.html with
+password `bench` would attach to :1 and see fluxbox.

outputs/sweep.log

@@ -0,0 +1 @@
+[sweep.sh] 2026-04-16T20:54:46+00:00 skip-existing run_id=maniptrans_xhand_oakink_v2_lift_board_bimanual_seed42_ours

outputs/videos/dexmachina_xhand_demo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77073ee148832b7fe6961abbd2d4fcb28ed2ce4c233cf06d899e67a0f6b33e40
+size 20042

outputs/videos/spider_allegro_oakink_lift_board_bimanual_data0.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a94fd74c17a6db1a3bd28f41a96b84cf83b5d7057f86ee6ed9ddf8a1a9b59fea
+size 44232