visualize.py

"""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:
            # Alternate neighboring arm joints in opposite directions for a visible, modest motion.
            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()