| """Visualize downloaded grippers and arms with an animated viser server.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| import time |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| import numpy as np |
| import trimesh |
| import viser |
| import yaml |
| import yourdfpy |
|
|
|
|
| ROOT = Path(__file__).resolve().parent |
|
|
|
|
| @dataclass |
| class Embodiment: |
| """Hold a loaded URDF and the endpoints of its animation.""" |
|
|
| name: str |
| kind: str |
| robot: yourdfpy.URDF |
| start: dict[str, float] |
| end: dict[str, float] |
|
|
|
|
| def discover(kind: str) -> dict[str, Path]: |
| """Find one preferred URDF for each downloaded embodiment.""" |
| found = {} |
| for folder in sorted((ROOT / kind).iterdir()): |
| if not folder.is_dir() or folder.name.lower() == "armbot": |
| continue |
| candidates = [folder / "gripper.urdf"] if kind == "grippers" else [] |
| config_path = folder / "config.yml" |
| if config_path.exists(): |
| config = yaml.safe_load(config_path.read_text()) or {} |
| if config.get("urdf_path"): |
| candidates.append(folder / config["urdf_path"]) |
| candidates += sorted(folder.glob("*.urdf")) |
| candidates += sorted((folder / "urdf").glob("*.urdf")) |
| for path in candidates: |
| if path.is_file(): |
| found[folder.name] = path |
| break |
| return found |
|
|
|
|
| def load_embodiment(kind: str, name: str, path: Path) -> Embodiment: |
| """Load visual geometry and choose motion endpoints from asset metadata.""" |
| robot = yourdfpy.URDF.load(str(path), build_scene_graph=True, load_meshes=True, |
| build_collision_scene_graph=False, load_collision_meshes=False) |
| joints = {joint.name: joint for joint in robot.robot.joints |
| if joint.type in ("revolute", "continuous", "prismatic") and joint.mimic is None} |
| start = {} |
| end = {} |
| folder = path.parent if path.parent.name != "urdf" else path.parent.parent |
| gripper_config = folder / "config.json" |
| arm_config = folder / "config.yml" |
| open_pose = close_pose = {} |
| home_pose = {} |
| if kind == "grippers" and gripper_config.exists(): |
| config = json.loads(gripper_config.read_text()) |
| open_pose, close_pose = config.get("open", {}), config.get("close", {}) |
| if kind == "arms" and arm_config.exists(): |
| config = yaml.safe_load(arm_config.read_text()) or {} |
| names = config.get("arm_joints_name", [[]])[0] |
| values = config.get("homestate", [[]])[0] |
| home_pose = dict(zip(names, values)) |
|
|
| for index, (joint_name, joint) in enumerate(joints.items()): |
| lower = float(joint.limit.lower) if joint.limit and joint.limit.lower is not None else -math.pi |
| upper = float(joint.limit.upper) if joint.limit and joint.limit.upper is not None else math.pi |
| if lower > upper: |
| lower, upper = upper, lower |
| initial = float(open_pose.get(joint_name, home_pose.get(joint_name, 0.0))) |
| start[joint_name] = float(np.clip(initial, lower, upper)) |
| if joint_name in close_pose: |
| target = float(close_pose[joint_name]) |
| elif kind == "arms" and joint_name in home_pose: |
| |
| target = initial + (0.35 if index % 2 == 0 else -0.35) |
| else: |
| target = upper if abs(upper - initial) >= abs(initial - lower) else lower |
| end[joint_name] = float(np.clip(target, lower, upper)) |
| return Embodiment(name, kind, robot, start, end) |
|
|
|
|
| def add_visuals(server: viser.ViserServer, item: Embodiment, offset: np.ndarray) -> list[tuple[str, object]]: |
| """Create each visual mesh once and retain handles for transform updates.""" |
| handles = [] |
| scene = item.robot.scene |
| for index, (geometry_name, geometry) in enumerate(scene.geometry.items()): |
| if isinstance(geometry, trimesh.Scene): |
| geometry = geometry.dump(concatenate=True) |
| if not isinstance(geometry, trimesh.Trimesh) or len(geometry.vertices) == 0: |
| continue |
| handle = server.scene.add_mesh_trimesh(f"/{item.kind}/{item.name}/mesh_{index}", geometry) |
| handles.append((geometry_name, handle)) |
| server.scene.add_label(f"/{item.kind}/{item.name}/label", item.name, |
| position=tuple(offset + [0, 0, -0.08])) |
| return handles |
|
|
|
|
| def update_pose(item: Embodiment, handles: list[tuple[str, object]], offset: np.ndarray, phase: float) -> None: |
| """Apply interpolated joint positions and update all mesh transforms.""" |
| pose = {name: value + phase * (item.end[name] - value) for name, value in item.start.items()} |
| item.robot.update_cfg(pose) |
| for geometry_name, handle in handles: |
| transform = item.robot.scene.graph.get(geometry_name)[0] |
| handle.position = tuple(transform[:3, 3] + offset) |
| handle.wxyz = tuple(trimesh.transformations.quaternion_from_matrix(transform)) |
|
|
|
|
| def main() -> None: |
| """Discover selected assets and serve their looping motion in viser.""" |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--kind", choices=("grippers", "arms"), default="grippers") |
| parser.add_argument("--name", help="Embodiment directory name") |
| parser.add_argument("--all", action="store_true", help="Show all gripper URDFs") |
| parser.add_argument("--list", action="store_true", help="List available URDFs and exit") |
| parser.add_argument("--port", type=int, default=8080) |
| args = parser.parse_args() |
| if args.all and args.kind != "grippers": |
| parser.error("--all is only available for grippers") |
| available = discover(args.kind) |
| if args.list: |
| for kind in ("grippers", "arms"): |
| print(f"{kind}: {', '.join(discover(kind))}") |
| return |
| if not args.all and args.name not in available: |
| all_hint = " (or use --all)" if args.kind == "grippers" else "" |
| parser.error(f"Choose --name from: {', '.join(available)}{all_hint}") |
| selected = available if args.all else {args.name: available[args.name]} |
| server = viser.ViserServer(port=args.port) |
| models = [] |
| for index, (name, path) in enumerate(selected.items()): |
| try: |
| item = load_embodiment(args.kind, name, path) |
| spacing = 1.2 if args.kind == "arms" else 0.35 |
| offset = np.array([index % 5 * spacing, index // 5 * spacing, 0.0]) |
| handles = add_visuals(server, item, offset) |
| update_pose(item, handles, offset, 0.0) |
| models.append((item, handles, offset)) |
| print(f"Loaded {args.kind}/{name}: {len(handles)} visuals, {len(item.start)} joints") |
| except Exception as exc: |
| if not args.all: |
| raise |
| print(f"Failed {args.kind}/{name}: {exc}") |
| if not models: |
| raise RuntimeError("No embodiments could be loaded") |
| phase_slider = server.gui.add_slider("Pose", min=0.0, max=1.0, step=0.01, initial_value=0.0) |
| playing = server.gui.add_checkbox("Play", initial_value=True) |
| print(f"Viewer: http://localhost:{server.get_port()}") |
| previous = time.monotonic() |
| phase = 0.0 |
| while True: |
| now = time.monotonic() |
| if playing.value: |
| phase = (phase + (now - previous) / 3.0) % 2.0 |
| phase_slider.value = round(phase if phase <= 1.0 else 2.0 - phase, 2) |
| previous = now |
| for item, handles, offset in models: |
| update_pose(item, handles, offset, phase_slider.value) |
| time.sleep(0.05) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
