FiveHundredShots / scripts /visualize.py
catachiii's picture
Initial release: 500 tennis strokes for the Unitree G1
390e994 verified
Raw History Blame Contribute Delete
10.4 kB
"""Play FiveHundredShots clips on the G1 + racket model with MuJoCo.
python scripts/visualize.py # browse all 500 shots
python scripts/visualize.py --stroke backhand # only backhands
python scripts/visualize.py --shot shot_0042 shot_0107 # chosen shots
python scripts/visualize.py --shot shot_0042 --record shot_0042.mp4 # offscreen video
Markers: yellow = racket sweet spot now | red = sweet spot at ball contact | green = hit direction
Keys: SPACE pause | RIGHT/N next shot | LEFT/B previous shot | R restart | H jump to contact
V markers on/off | UP/DOWN playback speed | close the window to quit
"""
from __future__ import annotations
import argparse
import time
from pathlib import Path
import mujoco
import numpy as np
from fivehundredshots import FPS, JOINT_NAMES, ROOT, load_clip, load_metadata
KEY_SPACE, KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP = 32, 262, 263, 264, 265 # GLFW key codes
END_PAUSE_S = 0.5 # hold on the last frame before a shot loops
YELLOW, RED, GREEN = (0.95, 0.85, 0.20, 1.0), (0.95, 0.25, 0.25, 1.0), (0.20, 0.80, 0.30, 1.0)
def rotation_z_to(direction) -> np.ndarray:
"""Rotation matrix taking +z onto ``direction`` (MuJoCo arrows point along their z axis)."""
d = np.asarray(direction, float) / np.linalg.norm(direction)
v, c = np.cross([0.0, 0.0, 1.0], d), d[2]
if np.linalg.norm(v) < 1e-9:
return np.eye(3) if c > 0 else np.diag([1.0, -1.0, -1.0])
vx = np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]])
return np.eye(3) + vx + vx @ vx / (1.0 + c)
def add_geom(scene, geom_type, size, pos, mat, rgba):
if scene.ngeom < scene.maxgeom:
mujoco.mjv_initGeom(scene.geoms[scene.ngeom], geom_type, np.asarray(size, float), np.asarray(pos, float),
np.asarray(mat, float).flatten(), np.asarray(rgba, np.float32))
scene.ngeom += 1
class Player:
"""Holds the playlist and writes one frame of the current shot into ``data``."""
def __init__(self, model, data, shots, root: Path):
self.model, self.data, self.shots, self.root = model, data, shots, root
self.qadr = [model.joint(name).qposadr[0] for name in JOINT_NAMES]
self.site = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, "racket_sweetspot")
self.index = self.frame = 0
self.paused, self.speed, self.show_markers = False, 1.0, True
self.keys: list[int] = []
self._hold_until = 0.0
self.load(0)
def load(self, index: int):
self.index = index % len(self.shots)
self.shot = self.shots[self.index]
clip = load_clip(self.root / self.shot["file"])
self.qpos = np.zeros((len(clip), self.model.nq))
self.qpos[:, 0:3], self.qpos[:, 3:7], self.qpos[:, self.qadr] = clip.root_pos, clip.root_quat, clip.joint_pos
self.frame, self._hold_until = 0, 0.0
self.apply()
print(f"[{self.index + 1}/{len(self.shots)}] {self.shot['id']} {self.shot['stroke']} "
f"{self.shot['n_frames']} frames, contact at frame {self.shot['hit_frame']}")
def apply(self):
self.data.qpos[:] = self.qpos[self.frame]
mujoco.mj_forward(self.model, self.data)
def step(self):
"""Advance one frame; loop the shot after a short hold on its last frame."""
now = time.monotonic()
if self.paused or now < self._hold_until:
return
self.frame += 1
if self.frame >= len(self.qpos):
self.frame, self._hold_until = 0, now + END_PAUSE_S
def hit_yaw_deg(self) -> float:
d = self.shot["hit_direction_world"]
return float(np.degrees(np.arctan2(d[1], d[0])))
def label(self) -> tuple[str, str]:
s = self.shot
return (f"{s['id']} {s['stroke']}\nframe {self.frame} / {s['n_frames'] - 1}",
f"{self.index + 1} of {len(self.shots)}\ncontact at {s['hit_frame']} x{self.speed:.2f}")
def draw_markers(self, scene):
"""Append the sweet-spot spheres and the hit-direction arrow to an ``MjvScene``."""
if not self.show_markers:
return
hit, direction = self.shot["sweetspot_hit_world"], self.shot["hit_direction_world"]
if self.site >= 0:
add_geom(scene, mujoco.mjtGeom.mjGEOM_SPHERE, [0.022] * 3, self.data.site_xpos[self.site], np.eye(3), YELLOW)
add_geom(scene, mujoco.mjtGeom.mjGEOM_SPHERE, [0.030] * 3, hit, np.eye(3), RED)
add_geom(scene, mujoco.mjtGeom.mjGEOM_ARROW, [0.012, 0.012, 0.42], hit, rotation_z_to(direction), GREEN)
def handle_keys(self) -> bool:
"""Apply queued key presses; returns True when the shot changed."""
before = self.index
while self.keys:
key = self.keys.pop(0)
if key == KEY_SPACE:
self.paused = not self.paused
elif key in (KEY_RIGHT, ord("N")):
self.load(self.index + 1)
elif key in (KEY_LEFT, ord("B")):
self.load(self.index - 1)
elif key == ord("R"):
self.frame = 0
elif key == ord("H"):
self.frame, self.paused = self.shot["hit_frame"], True
elif key == ord("V"):
self.show_markers = not self.show_markers
elif key == KEY_UP:
self.speed = min(self.speed * 1.5, 8.0)
elif key == KEY_DOWN:
self.speed = max(self.speed / 1.5, 0.125)
return self.index != before
def aim(cam, model, player: Player, args):
"""Track the pelvis from a fixed angle relative to the shot's hit direction."""
cam.type = mujoco.mjtCamera.mjCAMERA_TRACKING
cam.trackbodyid = model.body("pelvis").id
cam.distance, cam.elevation = args.distance, args.elevation
cam.azimuth = player.hit_yaw_deg() + args.azimuth
def play(model, data, player: Player, args):
import mujoco.viewer
player.speed = args.speed
with mujoco.viewer.launch_passive(model, data, key_callback=player.keys.append,
show_left_ui=False, show_right_ui=False) as viewer:
aim(viewer.cam, model, player, args)
while viewer.is_running():
tic = time.perf_counter()
with viewer.lock():
if player.handle_keys():
aim(viewer.cam, model, player, args)
player.step()
player.apply()
viewer.user_scn.ngeom = 0
player.draw_markers(viewer.user_scn)
if hasattr(viewer, "set_texts"): # mujoco >= 3.2
viewer.set_texts((None, None, *player.label()))
viewer.sync()
time.sleep(max(0.0, 1.0 / (FPS * player.speed) - (time.perf_counter() - tic)))
def record(model, data, player: Player, args):
"""Render every frame of the playlist offscreen; ``--speed`` only changes the output frame rate."""
import imageio
model.vis.global_.offwidth = max(model.vis.global_.offwidth, args.width)
model.vis.global_.offheight = max(model.vis.global_.offheight, args.height)
fps = FPS * args.speed / args.every
is_gif = args.record.suffix.lower() == ".gif"
options = {"duration": 1000.0 / fps, "loop": 0} if is_gif else {"fps": fps, "quality": 8}
cam = mujoco.MjvCamera()
with mujoco.Renderer(model, args.height, args.width) as renderer, \
imageio.get_writer(args.record, **options) as writer:
for index in range(len(player.shots)):
player.load(index)
aim(cam, model, player, args)
for frame in range(0, len(player.qpos), args.every):
player.frame = frame
player.apply()
renderer.update_scene(data, cam)
player.draw_markers(renderer.scene)
writer.append_data(renderer.render())
print(f"wrote {args.record} ({len(player.shots)} shots, {fps:g} fps)")
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--root", type=Path, default=ROOT, help="dataset folder (default: the one this script is in)")
ap.add_argument("--scene", type=Path, default=None, help="MuJoCo XML (default: robot/scene_tennis.xml)")
ap.add_argument("--shot", nargs="+", metavar="ID", help="play only these shots, e.g. shot_0042")
ap.add_argument("--stroke", choices=("forehand", "backhand"), help="play only this stroke type")
ap.add_argument("--speed", type=float, default=1.0, help="playback speed factor (default 1.0)")
ap.add_argument("--azimuth", type=float, default=135.0, help="camera yaw relative to the hit direction [deg]")
ap.add_argument("--elevation", type=float, default=-15.0, help="camera elevation [deg]")
ap.add_argument("--distance", type=float, default=3.2, help="camera distance to the pelvis [m]")
ap.add_argument("--no-markers", action="store_true", help="hide the sweet-spot markers and hit arrow")
ap.add_argument("--record", type=Path, metavar="FILE", help="render to FILE (.mp4 or .gif) instead of opening a window")
ap.add_argument("--every", type=int, default=1, help="when recording, keep every N-th frame (default 1)")
ap.add_argument("--width", type=int, default=1280, help="recording width [px]")
ap.add_argument("--height", type=int, default=720, help="recording height [px]")
args = ap.parse_args()
shots = load_metadata(args.root)
if args.stroke:
shots = [s for s in shots if s["stroke"] == args.stroke]
if args.shot:
by_id = {s["id"]: s for s in shots}
missing = [i for i in args.shot if i not in by_id]
if missing:
raise SystemExit(f"no such shot{' with stroke ' + args.stroke if args.stroke else ''}: {', '.join(missing)}")
shots = [by_id[i] for i in args.shot]
if args.record and not args.shot:
raise SystemExit("--record needs the shots to render, e.g. --shot shot_0000 shot_0007")
scene = args.scene or args.root / "robot" / "scene_tennis.xml"
model = mujoco.MjModel.from_xml_path(str(scene))
data = mujoco.MjData(model)
player = Player(model, data, shots, args.root)
player.show_markers = not args.no_markers
(record if args.record else play)(model, data, player, args)
if __name__ == "__main__":
main()