chess-sim/code/sim/prepare_chess_assets.py

"""Convert the vendored MIT Staunton STLs into metre-scale simulation assets.

Run only when rebuilding assets: uv pip install --python .venv/bin/python -e '.[assets]'
Then: .venv/bin/python sim/prepare_chess_assets.py
Scene generation and simulation use the checked-in outputs without these extra dependencies.
"""
from __future__ import annotations

import hashlib
import json
from pathlib import Path

import coacd
import numpy as np
import trimesh

ROOT = Path(__file__).resolve().parent / "assets" / "chess"
COMMIT = "cef2c79445380c5bffec461a80c7c91caf89b3b2"
KINDS = ("pawn", "rook", "knight", "bishop", "queen", "king")
# One uniform scale for the entire set; the upstream king is 78 units tall.
KING_HEIGHT = 0.046
SCALE = KING_HEIGHT / 78.0
# Estimates, not physical measurements. Replace with weighed masses before deployment.
MASS_KG = dict(pawn=0.006, rook=0.009, knight=0.009, bishop=0.008, queen=0.010, king=0.011)
DECOMPOSITION = dict(threshold=0.035, max_convex_hull=32, resolution=1500,
                     mcts_iterations=60, mcts_nodes=15, decimate=True,
                     max_ch_vertex=80, seed=0)


def convex_slice(mesh, lo, hi):
    """Convex hull of a horizontal slab, including exact triangle/plane crossings."""
    vertices = mesh.vertices
    points = [vertices[(vertices[:, 2] >= lo) & (vertices[:, 2] <= hi)]]
    a, b = vertices[mesh.edges_unique[:, 0]], vertices[mesh.edges_unique[:, 1]]
    for z in (lo, hi):
        mask = ((a[:, 2] <= z) & (b[:, 2] > z)) | ((b[:, 2] <= z) & (a[:, 2] > z))
        aa, bb = a[mask], b[mask]
        points.append(aa + (bb - aa) * ((z - aa[:, 2]) / (bb[:, 2] - aa[:, 2]))[:, None])
    points = np.concatenate(points)
    if len(points) < 4 or np.ptp(points[:, 2]) < 1e-7:
        return None
    # Millimetres avoid welding distinct vertices in sub-millimetre slabs.
    hull = trimesh.Trimesh(vertices=points * 1000, process=False).convex_hull
    hull.apply_scale(0.001)
    return hull


def prepare(kind: str) -> dict:
    source = ROOT / "source" / f"{kind.title()}.stl"
    mesh = trimesh.load_mesh(source)
    # CAD files are Y-up and have different offsets. +90 degrees about X gives Z-up.
    mesh.vertices = mesh.vertices[:, [0, 2, 1]] * [1, -1, 1]
    # Centre using the circular foot, not the asymmetric knight's head.
    foot = mesh.vertices[mesh.vertices[:, 2] < mesh.bounds[0, 2] + 0.1]
    origin = np.r_[(foot[:, :2].min(0) + foot[:, :2].max(0)) / 2, mesh.bounds[0, 2]]
    mesh.apply_translation(-origin)
    mesh.apply_scale(SCALE)
    mesh.export(ROOT / f"{kind}.stl")

    height = float(mesh.extents[2])
    # Choose an actual narrow cross-section in the middle of the body, below the head.
    candidates = []
    fractions = (0.25, 0.39) if kind == "knight" else (0.32, 0.58)
    for z in np.linspace(height * fractions[0], height * fractions[1], 50):
        section = mesh.section(plane_origin=[0, 0, z], plane_normal=[0, 0, 1])
        if section is not None:
            radius = float(np.linalg.norm(section.vertices[:, :2], axis=1).max())
            candidates.append((radius, float(z)))
    radius, grasp_z = min(candidates)

    # Work in millimetres for the decomposition's numerical conditioning.
    settings = dict(DECOMPOSITION)
    parts = coacd.run_coacd(coacd.Mesh(mesh.vertices * 1000, mesh.faces), **settings)
    hulls = [trimesh.Trimesh(vertices=np.asarray(v) / 1000, faces=f).convex_hull for v, f in parts]
    if kind == "knight":
        # Automatic remeshing of the non-watertight horse head also inflates its
        # thin neck. Preserve the foot/neck directly as convex slices (0.25 mm
        # around the gripping region, 1 mm elsewhere) and
        # retain only the upper part of the automatic decomposition for the head.
        split_z = 0.014
        upper = []
        for hull in hulls:
            clipped = convex_slice(hull, split_z, float(mesh.bounds[1, 2]) + 0.01)
            if clipped is not None:
                upper.append(clipped)
        lower = []
        # Split at the narrowest neck itself so its groove is not bridged.
        edges = np.unique(np.round(np.r_[np.linspace(0, split_z, 15), np.linspace(0.007, 0.012, 21), grasp_z], 9))
        for lo, hi in zip(edges[:-1], edges[1:]):
            lower.append(convex_slice(mesh, lo, hi))
        hulls = lower + upper
        settings["lower_exact_slices"] = dict(height_m=split_z, z_edges_m=edges.tolist())
    files = []
    for i, hull in enumerate(hulls):
        if not hull.is_watertight or hull.volume <= 0:
            raise ValueError(f"Invalid collision hull for {kind}: {i}")
        path = ROOT / "collision" / f"{kind}_{i:02d}.stl"
        hull.export(path)
        files.append(str(path.relative_to(ROOT)))
    for stale in (ROOT / "collision").glob(f"{kind}_*.stl"):
        if str(stale.relative_to(ROOT)) not in files:
            stale.unlink()

    # Full-mesh inertia where valid; knight uses the convex approximation. Explicit
    # body inertials prevent duplicate visual and collision geometry adding mass.
    solid = mesh if mesh.is_watertight else trimesh.util.concatenate(hulls)
    mass = MASS_KG[kind]
    inertia = solid.moment_inertia * mass / solid.volume
    return dict(source_file=str(source.relative_to(ROOT)),
                source_sha256=hashlib.sha256(source.read_bytes()).hexdigest(),
                visual=f"{kind}.stl", collision=files, height_m=height,
                bounds_m=mesh.bounds.tolist(), mass_kg=mass,
                center_of_mass_m=solid.center_mass.tolist(),
                fullinertia_kg_m2=[float(inertia[i, j]) for i, j in
                                   ((0, 0), (1, 1), (2, 2), (0, 1), (0, 2), (1, 2))],
                inertia_source="uniform solid mesh" if mesh.is_watertight else "convex parts approximation",
                source_watertight=bool(mesh.is_watertight),
                grasp_z_m=grasp_z, grasp_diameter_m=2 * radius,
                triangles=len(mesh.faces), collision_hulls=len(hulls), decomposition=settings)


def main():
    (ROOT / "collision").mkdir(exist_ok=True)
    coacd.set_log_level("warn")
    manifest = dict(source_url="https://github.com/clarkerubber/Staunton-Pieces",
                    source_commit=COMMIT, license="MIT", units="metres",
                    uniform_scale_from_source=SCALE,
                    mass_note="Estimated masses and uniform-density inertia; calibrate against the real set.",
                    decomposition=DECOMPOSITION, pieces={})
    for kind in KINDS:
        manifest["pieces"][kind] = prepare(kind)
        p = manifest["pieces"][kind]
        print(f"{kind}: {p['height_m']*1000:.1f} mm, {p['triangles']} triangles, "
              f"{p['collision_hulls']} collision hulls", flush=True)
    (ROOT / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")


if __name__ == "__main__":
    main()