"""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()