#!/usr/bin/env python3 """Run SONIC v1.1 whole-body ONNX on a reconstruction clip (G1 29-DoF). ``G1_MINIMAL_CFG`` is the locomotion USD (wrong joint set). SONIC tracks the 29-DoF G1 (``G1_29DOF_CFG`` / GR00T cylinder G1): waist yaw/roll/pitch and wrist roll/pitch/yaw, no Inspire mimic joints. The DexYCB clip is a tabletop hand. Encoder **teleop** mode uses standing legs + reconstructed right-hand root as the right-wrist target. The coffee can is spawned on the table from ``isaaclab_replay.npz``. cd simulation ./replay_sonic.sh --headless \\ --npz ../reconstruction/runs/20200709_141754_836212060125/obj_tracking_out/isaaclab_replay.npz """ from __future__ import annotations import argparse import os import sys from pathlib import Path from isaaclab.app import AppLauncher if hasattr(sys.stdout, "reconfigure"): sys.stdout.reconfigure(line_buffering=True) _PROJECT = Path(__file__).resolve().parents[2] _DEFAULT_CLIP = ( _PROJECT / "reconstruction" / "runs" / "20200709_141754_836212060125" / "obj_tracking_out" / "isaaclab_replay.npz" ) _DEFAULT_CKPT = _PROJECT / "checkpoints" / "sonic" / "sonic_v1_1" parser = argparse.ArgumentParser(description="SONIC v1.1 play on a v2d reconstruction clip.") parser.add_argument("--npz", type=Path, default=_DEFAULT_CLIP) parser.add_argument("--checkpoint", type=Path, default=_DEFAULT_CKPT) parser.add_argument("--mode", choices=("teleop", "g1"), default="teleop") parser.add_argument("--output", type=Path, default=None) parser.add_argument("--table-z", type=float, default=0.75) parser.add_argument("--robot-x", type=float, default=0.0, help="pelvis x; 0 matches the manip env") parser.add_argument("--object-x", type=float, default=0.36, help="object rest x in the pelvis frame") parser.add_argument("--object-y", type=float, default=-0.20, help="object rest y; right-hand workspace") parser.add_argument("--max-steps", type=int, default=None) parser.add_argument( "--hands", choices=("dex3", "inspire", "wuji"), default="dex3", help="dex3 = stock 3-finger (14 DoF); inspire = 5-finger (24 DoF), needs fetch_inspire_hand.py", ) parser.add_argument( "--track-hand-orientation", action="store_true", help="feed the reconstructed MANO hand rotation as the right-wrist orientation target", ) AppLauncher.add_app_launcher_args(parser) args_cli = parser.parse_args() args_cli.enable_cameras = True app_launcher = AppLauncher(args_cli) simulation_app = app_launcher.app import numpy as np # noqa: E402 import torch # noqa: E402 import isaaclab.sim as sim_utils # noqa: E402 from isaaclab.assets import Articulation, RigidObject, RigidObjectCfg # noqa: E402 from isaaclab.sensors.camera import Camera, CameraCfg # noqa: E402 from isaaclab.sim import SimulationContext # noqa: E402 from v2d_sim.sonic.robot_cfg import g1_sonic_articulation_cfg # noqa: E402 from v2d_sim.sonic import ( # noqa: E402 ACTION_CLIP, DEFAULT_ANGLES, G1_ACTION_SCALE, G1_SONIC_JOINT_NAMES, History, SonicOnnxAgent, load_clip_ref, pack_decoder, pack_encoder, vr3_local_from_bodies, vr3_local_targets, ) _TABLE_SIZE = (0.80, 1.00, 0.05) _TABLE_CENTER_X = 0.60 _CTRL_DT = 0.02 _SIM_DT = 0.005 _DECIMATION = 4 def _as_numpy(x) -> np.ndarray: if hasattr(x, "torch"): x = x.torch if isinstance(x, torch.Tensor): return x.detach().cpu().numpy() return np.asarray(x) def _batch_row(x) -> np.ndarray: a = np.asarray(_as_numpy(x), dtype=np.float64) if a.ndim == 0: raise RuntimeError(f"empty sim tensor {type(x)}") if a.ndim >= 2: a = a[0] return a def _wxyz_to_xyzw(wxyz: np.ndarray) -> np.ndarray: wxyz = np.asarray(wxyz, dtype=np.float64) return np.stack([wxyz[..., 1], wxyz[..., 2], wxyz[..., 3], wxyz[..., 0]], axis=-1) def _xyzw_to_wxyz(xyzw: np.ndarray) -> np.ndarray: """Isaac Lab 3 reports ``*_quat_w`` as (x, y, z, w); SONIC math is wxyz. Reading these as wxyz turns identity into a 180 deg yaw, which makes the policy try to spin around. """ xyzw = np.asarray(xyzw, dtype=np.float64) return np.stack([xyzw[..., 3], xyzw[..., 0], xyzw[..., 1], xyzw[..., 2]], axis=-1) def _rgb_frame(camera: Camera) -> np.ndarray | None: try: out = camera.data.output rgb = out["rgb"] if isinstance(out, dict) or hasattr(out, "__getitem__") else out img = _as_numpy(rgb) except Exception: return None if img.size == 0: return None if img.ndim == 4: img = img[0] img = img[..., :3] if img.dtype != np.uint8: finite = img[np.isfinite(img)] peak = float(np.nanmax(finite)) if finite.size else 1.0 scale = 255.0 if peak <= 1.5 else 1.0 img = np.clip(img * scale, 0, 255).astype(np.uint8) h, w = img.shape[:2] return img[: h - (h % 2), : w - (w % 2)] def _write_mp4(path: Path, frames: list[np.ndarray], fps: float) -> None: if not frames: raise RuntimeError("no frames captured") path.parent.mkdir(parents=True, exist_ok=True) try: import imageio.v2 as imageio imageio.mimsave(str(path), frames, fps=float(fps), codec="libx264", pixelformat="yuv420p") return except Exception as exc: print(f"[sonic] imageio h264 failed ({exc}); trying OpenCV", flush=True) import cv2 h, w = frames[0].shape[:2] writer = cv2.VideoWriter(str(path), cv2.VideoWriter_fourcc(*"mp4v"), float(fps), (w, h)) if not writer.isOpened(): raise RuntimeError(f"could not open VideoWriter for {path}") for fr in frames: writer.write(cv2.cvtColor(fr, cv2.COLOR_RGB2BGR)) writer.release() def _spawn_table(xy: np.ndarray, table_top: float) -> None: """Kinematic slab. Legs at this depth collide with the G1 feet.""" wood = sim_utils.PreviewSurfaceCfg(diffuse_color=(0.48, 0.34, 0.22)) kin = sim_utils.RigidBodyPropertiesCfg(kinematic_enabled=True, disable_gravity=True) col = sim_utils.CollisionPropertiesCfg() mat = sim_utils.RigidBodyMaterialCfg(static_friction=0.9, dynamic_friction=0.7, restitution=0.0) lx, ly, thick = _TABLE_SIZE top = sim_utils.CuboidCfg( size=(lx, ly, thick), rigid_props=kin, mass_props=sim_utils.MassPropertiesCfg(mass=50.0), collision_props=col, visual_material=wood, physics_material=mat, ) top.func( "/World/TableTop", top, translation=(float(xy[0]), float(xy[1]), float(table_top - 0.5 * thick)), ) def _object_cfg(urdf: str, prim: str, pos, rot_xyzw) -> RigidObjectCfg: return RigidObjectCfg( prim_path=prim, spawn=sim_utils.UrdfFileCfg( asset_path=urdf, fix_base=False, joint_drive=None, force_usd_conversion=True, collision_type="Convex Hull", mass_props=sim_utils.MassPropertiesCfg(mass=0.35), rigid_props=sim_utils.RigidBodyPropertiesCfg( disable_gravity=False, kinematic_enabled=False, linear_damping=0.05, angular_damping=0.05, max_depenetration_velocity=1.0, ), collision_props=sim_utils.CollisionPropertiesCfg(collision_enabled=True), physics_material=sim_utils.RigidBodyMaterialCfg( static_friction=1.1, dynamic_friction=0.9, restitution=0.0 ), ), init_state=RigidObjectCfg.InitialStateCfg(pos=tuple(pos), rot=tuple(rot_xyzw)), ) def _g1_cfg(init_pos: tuple[float, float, float]): return g1_sonic_articulation_cfg("/World/Robot", init_pos=init_pos, hands=args_cli.hands) def _stand_vr3_local( robot: Articulation, pelvis_pos: np.ndarray, pelvis_quat: np.ndarray ) -> tuple[np.ndarray, np.ndarray]: """VR 3-point pose of the current (standing) configuration, in the pelvis frame.""" body_pos = np.asarray(_as_numpy(robot.data.body_pos_w), dtype=np.float64) body_quat = _xyzw_to_wxyz(np.asarray(_as_numpy(robot.data.body_quat_w), dtype=np.float64)) if body_pos.ndim == 3: body_pos, body_quat = body_pos[0], body_quat[0] return vr3_local_from_bodies(robot.body_names, body_pos, body_quat, pelvis_pos, pelvis_quat) def _joint_ids(robot: Articulation) -> np.ndarray: names = list(robot.joint_names) ids = [] missing = [] for n in G1_SONIC_JOINT_NAMES: if n not in names: missing.append(n) else: ids.append(names.index(n)) if missing: raise RuntimeError( "SONIC joints missing on this USD (need 29-DoF G1, not g1_minimal): " + ", ".join(missing) ) return np.asarray(ids, dtype=np.int64) def main() -> None: npz_path = args_cli.npz.resolve() ckpt = args_cli.checkpoint.resolve() if not npz_path.is_file(): raise SystemExit(f"missing {npz_path} — run retarget/export_isaaclab.sh first") if not (ckpt / "model_encoder.onnx").is_file(): raise SystemExit(f"missing SONIC ONNX in {ckpt}") out_mp4 = (args_cli.output or (npz_path.parent / "sonic_replay.mp4")).resolve() ref = load_clip_ref( npz_path, table_xy=(_TABLE_CENTER_X, 0.0), table_z=float(args_cli.table_z), robot_xy=(float(args_cli.robot_x), 0.0), object_xy=(float(args_cli.object_x), float(args_cli.object_y)), pelvis_z=0.78, ) agent = SonicOnnxAgent(ckpt) scale = np.asarray(G1_ACTION_SCALE, dtype=np.float64) default = np.asarray(DEFAULT_ANGLES, dtype=np.float64) n_steps = ref.joint_pos.shape[0] if args_cli.max_steps is not None: n_steps = min(n_steps, int(args_cli.max_steps)) print(f"[sonic] clip {npz_path}", flush=True) print(f"[sonic] checkpoint {ckpt} mode={args_cli.mode} steps={n_steps} @ 50 Hz", flush=True) print(f"[sonic] robot G1_29DOF_CFG (not g1_minimal) table_z={ref.table_z:.3f}", flush=True) lx, ly, thick = _TABLE_SIZE table_x0 = float(ref.table_xy[0] - 0.5 * lx) table_x1 = float(ref.table_xy[0] + 0.5 * lx) rw = ref.hand_pos_w[0] print( f"[sonic] layout robot_xy=({ref.robot_xy[0]:.2f},{ref.robot_xy[1]:.2f}) " f"table_x=[{table_x0:.2f},{table_x1:.2f}] front_clearance={table_x0 - ref.robot_xy[0]:.2f} m " f"R_wrist0=({rw[0]:.2f},{rw[1]:.2f},{rw[2]:.2f})", flush=True, ) print(f"[sonic] mp4 {out_mp4}", flush=True) sim = SimulationContext(sim_utils.SimulationCfg(dt=_SIM_DT, device=args_cli.device)) look = np.array([0.40, 0.0, 0.85], dtype=np.float32) eye = np.array([-1.6, -2.2, 1.70], dtype=np.float32) sim.set_camera_view(eye=eye.tolist(), target=look.tolist()) sim_utils.GroundPlaneCfg().func("/World/defaultGroundPlane", sim_utils.GroundPlaneCfg()) sim_utils.DomeLightCfg(intensity=2500.0, color=(0.8, 0.8, 0.8)).func( "/World/Light", sim_utils.DomeLightCfg(intensity=2500.0, color=(0.8, 0.8, 0.8)) ) _spawn_table(ref.table_xy, ref.table_z) robot_xyz = (float(ref.robot_xy[0]), float(ref.robot_xy[1]), float(ref.pelvis_z)) robot = Articulation(_g1_cfg(robot_xyz)) obj = None obj_xyzw0 = (0.0, 0.0, 0.0, 1.0) if ref.object_urdf and Path(ref.object_urdf).is_file() and ref.object_pos is not None: p0 = ref.object_pos[0] if ref.object_wxyz is not None: obj_xyzw0 = tuple(_wxyz_to_xyzw(ref.object_wxyz[0]).tolist()) obj = RigidObject(_object_cfg(ref.object_urdf, "/World/Object", p0, obj_xyzw0)) print( f"[sonic] object rest xy=({p0[0]:.3f},{p0[1]:.3f}) z={p0[2]:.3f} " f"({p0[2] - ref.table_z:.3f} m above table)", flush=True, ) camera = Camera( CameraCfg( prim_path="/World/RecordCamera", update_period=0.0, height=480, width=640, data_types=["rgb"], spawn=sim_utils.PinholeCameraCfg( focal_length=24.0, focus_distance=400.0, horizontal_aperture=20.955, clipping_range=(0.1, 1.0e5), ), ) ) sim.reset() camera.set_world_poses_from_view( torch.tensor(eye, device=sim.device).unsqueeze(0), torch.tensor(look, device=sim.device).unsqueeze(0), ) sonic_ids = _joint_ids(robot) sonic_ids_list = [int(i) for i in sonic_ids.tolist()] print(f"[sonic] articulation joints={len(robot.joint_names)} sonic mapped={len(sonic_ids)}", flush=True) # Whatever SONIC does not drive is a finger joint, available as a separate # action channel for grasping. extra_ids = [i for i in range(len(robot.joint_names)) if i not in set(sonic_ids_list)] if extra_ids: print( f"[sonic] {len(extra_ids)} non-SONIC joints held at default: " f"{[robot.joint_names[i] for i in extra_ids]}", flush=True, ) device = sim.device n_j = len(robot.joint_names) q0 = np.zeros(n_j, dtype=np.float64) q0[sonic_ids] = default robot.write_root_pose_to_sim_index( root_pose=torch.tensor( [[robot_xyz[0], robot_xyz[1], robot_xyz[2], 0.0, 0.0, 0.0, 1.0]], dtype=torch.float32, device=device, ) ) robot.write_root_velocity_to_sim_index(root_velocity=torch.zeros(1, 6, device=device)) robot.write_joint_state_to_sim_index( position=torch.tensor(q0, dtype=torch.float32, device=device).unsqueeze(0), velocity=torch.zeros(1, n_j, device=device), full_data=True, ) robot.write_data_to_sim() hist = History() last_action = np.zeros(29, dtype=np.float32) def _proprio(): q_all = _batch_row(robot.data.joint_pos) dq_all = _batch_row(robot.data.joint_vel) q = q_all[sonic_ids] dq = dq_all[sonic_ids] ang = _batch_row(robot.data.root_ang_vel_b) grav = _batch_row(robot.data.projected_gravity_b) pos = _batch_row(robot.data.root_pos_w) quat = _xyzw_to_wxyz(_batch_row(robot.data.root_quat_w)) return q, dq, ang, grav, pos, quat sim.step() robot.update(_SIM_DT) if obj is not None: obj.update(_SIM_DT) camera.update(_CTRL_DT) q, dq, ang, grav, pos, quat = _proprio() hist.fill(ang_vel=ang, q_rel=q - default, dq=dq, action=last_action, gravity=grav) hip_i = int(robot.joint_names.index("left_hip_pitch_joint")) hip_kp = float(_batch_row(robot.data.joint_stiffness)[hip_i]) print( f"[sonic] start root_z={pos[2]:.3f} q[:4]={np.array2string(q[:4], precision=3)} " f"left_hip_pitch Kp={hip_kp:.3f} (0 = PD wiring bug)", flush=True, ) stand_local_pos, stand_local_quat = _stand_vr3_local(robot, pos, quat) vr_local_pos, vr_local_quat = vr3_local_targets( ref, stand_local_pos=stand_local_pos, stand_local_quat=stand_local_quat, track_hand_orientation=args_cli.track_hand_orientation, ) print( "[sonic] vr3 pelvis-local L=" f"{np.array2string(stand_local_pos[0], precision=3)} " f"R0={np.array2string(vr_local_pos[0, 1], precision=3)} " f"torso={np.array2string(stand_local_pos[2], precision=3)}", flush=True, ) if obj is not None and ref.object_pos is not None and ref.object_wxyz is not None: pose7 = np.concatenate([ref.object_pos[0], _wxyz_to_xyzw(ref.object_wxyz[0])]) obj.write_root_pose_to_sim_index( root_pose=torch.tensor(pose7, dtype=torch.float32, device=device).unsqueeze(0) ) obj.write_root_velocity_to_sim_index(root_velocity=torch.zeros(1, 6, device=device)) frames: list[np.ndarray] = [] try: for t in range(n_steps): if not simulation_app.is_running(): break q, dq, ang, grav, pos, quat = _proprio() enc = pack_encoder( mode=args_cli.mode, t=t, joint_pos=ref.joint_pos, joint_vel=ref.joint_vel, ref_quat_wxyz=ref.root_quat, robot_quat_wxyz=quat, vr_local_pos=vr_local_pos, vr_local_quat=vr_local_quat, ) token = agent.encode(enc) dec = pack_decoder(token, hist) action = np.clip(agent.decode(dec), -ACTION_CLIP, ACTION_CLIP) last_action = action.astype(np.float32) q_des = default + scale * last_action robot.set_joint_position_target_index( target=torch.tensor(q_des, dtype=torch.float32, device=device).unsqueeze(0), joint_ids=sonic_ids_list, ) robot.write_data_to_sim() for _ in range(_DECIMATION): sim.step() robot.update(_SIM_DT) if obj is not None: obj.update(_SIM_DT) camera.update(_CTRL_DT) hist.push(ang_vel=ang, q_rel=q - default, dq=dq, action=last_action, gravity=grav) rgb = _rgb_frame(camera) if rgb is not None: frames.append(rgb) if t % 50 == 0: print( f" step {t}/{n_steps} root_z={pos[2]:.3f} " f"a=[{float(last_action.min()):+.3f},{float(last_action.max()):+.3f}] " f"|a|={float(np.linalg.norm(last_action)):.3f} frames={len(frames)}", flush=True, ) except Exception: import traceback traceback.print_exc() print(f"[sonic] stopped after {len(frames)} frames", flush=True) if frames: _write_mp4(out_mp4, frames, 30.0) print(f"[sonic] wrote partial {out_mp4}", flush=True) raise _write_mp4(out_mp4, frames, 30.0) print(f"[sonic] wrote {out_mp4} ({len(frames)} frames)", flush=True) if __name__ == "__main__": try: main() except Exception: import traceback traceback.print_exc() sys.exit(1) finally: simulation_app.close()