Download scripts/visualize.py from catachiii/FiveHundredShots: direct link, hf CLI and curl.
- Browser
- Download file 10.4 kB
-
https://huggingface.co/datasets/catachiii/FiveHundredShots/resolve/main/scripts/visualize.py
- Command line
-
hf download hf://datasets/catachiii/FiveHundredShots/scripts/visualize.py
-
curl -L -o visualize.py https://huggingface.co/datasets/catachiii/FiveHundredShots/resolve/main/scripts/visualize.py
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() | |