chess-sim/code/sim/prepare_gripper_assets.py

"""Build slab-hull collision shapes for the two SO-101 gripper fingers.

MuJoCo collides a mesh geom through its convex hull. The upstream fixed-jaw part
(`wrist_roll_follower_so101_v1`) carries the finger and the wrist mount in one mesh,
so its hull fills the gap between the jaws: 7 mm into the gap 8 mm above the tip,
13 mm at 18 mm. Nothing can be pinched the way the real gripper pinches.

This script cuts each finger mesh into thin slabs along the finger and keeps the
convex hull of each slab, like the knight's neck in `prepare_chess_assets.py`.
Hulls stay in the original mesh frame, so `make_scene.py` gives them the same
geom pos/quat as the upstream collision geom they replace. Visual meshes, joints,
actuators and inertials are untouched.

Run only when rebuilding assets: uv pip install --python .venv/bin/python -e '.[assets]'
Then: .venv/bin/python sim/prepare_gripper_assets.py
"""
from __future__ import annotations

import hashlib
import json
from pathlib import Path

import numpy as np
import trimesh

from grasp_geometry import section_extent

ROOT = Path(__file__).resolve().parent / "assets" / "so101"
OUT = ROOT / "collision"

# axis: mesh axis running along the finger. fine: range (mm) covering the finger,
# cut into FINE_MM slabs. The rest of the part (mount, horn) uses COARSE_MM slabs.
# grip: the 40 mm nearest the fingertip, which touches pieces; validate_scene.py
# checks the hulls against the mesh there.
FINGERS = {
    "wrist_roll_follower_so101_v1": dict(axis=2, fine=(40.0, 105.5), grip=(65.5, 105.4)),
    "moving_jaw_so101_v1": dict(axis=1, fine=(-82.1, -22.0), grip=(-82.0, -42.0)),
}
FINE_MM = 2.0
COARSE_MM = 6.0
STEP_SCAN_MM = 0.05      # resolution of the search for steps in the finger profile
STEP_JUMP_MM = 0.15      # a section extent jumping this much between samples is a step


def convex_slab(mesh: trimesh.Trimesh, axis: int, lo: float, hi: float):
    """Convex hull of the part of `mesh` between two planes normal to `axis`."""
    v = mesh.vertices
    points = [v[(v[:, axis] >= lo) & (v[:, axis] <= hi)]]
    a, b = v[mesh.edges_unique[:, 0]], v[mesh.edges_unique[:, 1]]
    for c in (lo, hi):
        mask = ((a[:, axis] <= c) & (b[:, axis] > c)) | ((b[:, axis] <= c) & (a[:, axis] > c))
        aa, bb = a[mask], b[mask]
        points.append(aa + (bb - aa) * ((c - aa[:, axis]) / (bb[:, axis] - aa[:, axis]))[:, None])
    points = np.concatenate(points)
    if len(points) < 4 or np.ptp(points[:, axis]) < 1e-7:
        return None
    hull = trimesh.Trimesh(vertices=points * 1000, process=False).convex_hull
    hull.apply_scale(0.001)
    return hull


def profile_steps(mesh: trimesh.Trimesh, axis: int, fine: tuple[float, float]) -> np.ndarray:
    """Heights (mm) along the finger where its cross-section changes abruptly.

    A slab spanning such a step would fill it in, so a cut is placed at each step.
    """
    perm = [i for i in range(3) if i != axis] + [axis]
    tris = mesh.triangles[:, :, perm]
    h = np.arange(fine[0], fine[1], STEP_SCAN_MM) / 1000
    extents = []
    for along in (np.array([1.0, 0.0]), np.array([0.0, 1.0])):
        extents += section_extent(tris, h, along, np.array([-along[1], along[0]]), 1.0)
    jumps = np.flatnonzero(np.nanmax(np.abs(np.diff(np.array(extents), axis=1)), axis=0) > STEP_JUMP_MM / 1000)
    # Cut at the last sample before a step and the first sample after it, so only a
    # sliver as thin as the scan spacing straddles it. A sloped step is a run of jumps.
    cuts, run = [], []
    for j in jumps:
        if run and j > run[-1] + 2:
            cuts += [h[run[0]], h[run[-1] + 1]]
            run = []
        run.append(j)
    if run:
        cuts += [h[run[0]], h[run[-1] + 1]]
    return np.array(cuts) * 1000


def slab_edges(lo_mm, hi_mm, fine, steps) -> np.ndarray:
    edges = [np.arange(lo_mm, fine[0], COARSE_MM), np.arange(fine[0], fine[1], FINE_MM),
             np.arange(fine[1], hi_mm, COARSE_MM), [fine[0], fine[1], lo_mm, hi_mm]]
    edges = np.unique(np.round(np.concatenate(edges), 6))
    # Regular cuts closer than 0.4 mm to a step cut are dropped to avoid sliver slabs.
    edges = [e for e in edges if len(steps) == 0 or np.all(np.abs(e - steps) > 0.4)] + list(steps)
    edges = np.unique(np.round(edges, 6))
    return edges[(edges >= lo_mm - 1e-6) & (edges <= hi_mm + 1e-6)] / 1000


def prepare(name: str, axis: int, fine: tuple[float, float], grip: tuple[float, float]) -> dict:
    source = ROOT / f"{name}.stl"
    mesh = trimesh.load_mesh(source)
    lo, hi = mesh.bounds[:, axis] * 1000
    files = []
    steps = profile_steps(mesh, axis, fine)
    edges = slab_edges(lo - 0.01, hi + 0.01, fine, steps)
    for i, (a, b) in enumerate(zip(edges[:-1], edges[1:])):
        hull = convex_slab(mesh, axis, a, b)
        # A cut lying exactly on a flat face can leave a degenerate hull; nudge it.
        for nudge in (1e-5, -1e-5, 2e-5):
            if hull is None or (hull.is_watertight and hull.volume > 0):
                break
            hull = convex_slab(mesh, axis, a + nudge, b - nudge)
        if hull is None:
            continue
        if not hull.is_watertight or hull.volume <= 0:
            raise ValueError(f"invalid hull {name} slab {i}")
        path = OUT / f"{name}_{len(files):02d}.stl"
        hull.export(path)
        files.append(path.name)
    for stale in OUT.glob(f"{name}_*.stl"):
        if stale.name not in files:
            stale.unlink()
    return dict(source_file=source.name, source_sha256=hashlib.sha256(source.read_bytes()).hexdigest(),
                axis=axis, fine_range_mm=list(fine), grip_range_mm=list(grip),
                fine_slab_mm=FINE_MM, coarse_slab_mm=COARSE_MM,
                step_cuts_mm=np.round(steps, 3).tolist(), slab_edges_mm=np.round(edges * 1000, 4).tolist(),
                collision=[f"collision/{f}" for f in files])


def main():
    OUT.mkdir(exist_ok=True)
    # The manifest also lists prepare_arm_collision.py's parts; replace only the fingers.
    path = OUT / "manifest.json"
    manifest = json.loads(path.read_text()) if path.exists() else dict(parts={})
    manifest.setdefault("note", "Slab convex hulls replacing the upstream single-hull finger collision geoms.")
    for name, cfg in FINGERS.items():
        manifest["parts"][name] = dict(method="slab", **prepare(name, **cfg))
        print(f"{name}: {len(manifest['parts'][name]['collision'])} hulls")
    path.write_text(json.dumps(manifest, indent=2) + "\n")


if __name__ == "__main__":
    main()