#!/usr/bin/env python3 """Repair example_robot_data URDFs for self-contained simulation in tars-fleet. Resolves `package://` mesh URIs to local relative `meshes/...` paths, repairs zero/non-positive masses and non-SPD inertia tensors (Sylvester criterion), and defines missing top-level `` entries referenced by ``. """ from __future__ import annotations import argparse import math import re import shutil import xml.etree.ElementTree as ET from pathlib import Path DEFAULT_SRC = Path("C:/projects/projects.rust.cg/cglibs/tars-rs/target/bench/example_robot_data/robots") DEFAULT_DST = Path("C:/projects/projects.rust.cg/cglibs/tars-fleet/example_robot_data") KNOWN_MATERIAL_RGBA = { "black": "0.1 0.1 0.1 1.0", "flatblack": "0.12 0.12 0.12 1.0", "dark_grey": "0.25 0.25 0.25 1.0", "grey": "0.5 0.5 0.5 1.0", "white": "0.9 0.9 0.9 1.0", "red": "0.8 0.1 0.1 1.0", "blue": "0.1 0.1 0.8 1.0", } def resolve_package_uri(uri: str, src_robots_dir: Path) -> Path | None: """Resolve a `package:///` (or `package:////`) URI against example_robot_data layout.""" m = re.match(r"^package://+([^/]+)/(.+)$", uri.strip()) if not m: return None pkg, rel = m.group(1), m.group(2).lstrip("/") if pkg == "example-robot-data": cand = src_robots_dir.parent / rel return cand if cand.exists() else None for base in (src_robots_dir / pkg, src_robots_dir.parent / pkg): cand = base / rel if cand.exists(): return cand return None def symmetric_3x3_eigenvalues( ixx: float, iyy: float, izz: float, ixy: float, ixz: float, iyz: float ) -> tuple[float, float, float]: """Compute sorted eigenvalues (l0 <= l1 <= l2) of a symmetric 3x3 inertia tensor via Jacobi rotations.""" a = [ [ixx, ixy, ixz], [ixy, iyy, iyz], [ixz, iyz, izz], ] for _ in range(32): # Find largest off-diagonal element p, q, max_val = 0, 1, abs(a[0][1]) for i, j in ((0, 2), (1, 2)): v = abs(a[i][j]) if v > max_val: p, q, max_val = i, j, v if max_val <= 1e-18: break app, aqq, apq = a[p][p], a[q][q], a[p][q] tau = (aqq - app) / (2.0 * apq) t = (1.0 / (tau + math.sqrt(1.0 + tau * tau))) if tau >= 0.0 else (-1.0 / (-tau + math.sqrt(1.0 + tau * tau))) c = 1.0 / math.sqrt(1.0 + t * t) s = t * c a[p][p] = app - t * apq a[q][q] = aqq + t * apq a[p][q] = 0.0 a[q][p] = 0.0 for r in range(3): if r != p and r != q: arp, arq = a[r][p], a[r][q] a[r][p] = a[p][r] = c * arp - s * arq a[r][q] = a[q][r] = s * arp + c * arq vals = sorted((a[0][0], a[1][1], a[2][2])) return (vals[0], vals[1], vals[2]) def is_spd_inertia(ixx: float, iyy: float, izz: float, ixy: float, ixz: float, iyz: float) -> bool: """Return True iff the 3x3 inertia matrix is strictly positive definite and eigenvalues satisfy triangle inequalities.""" l0, l1, l2 = symmetric_3x3_eigenvalues(ixx, iyy, izz, ixy, ixz, iyz) if l0 <= 1e-12: return False return (l0 + l1) > l2 * (1.0 + 1e-6) def fallback_inertia_for_link(link: ET.Element, mass: float) -> tuple[float, float, float]: """Compute a conservative SPD diagonal inertia from link primitive geometry or a 5 cm sphere.""" for tag in ("collision", "visual"): for holder in link.findall(tag): geom = holder.find("geometry") if geom is None: continue box = geom.find("box") if box is not None and "size" in box.attrib: sx, sy, sz = (max(abs(float(v)), 0.02) for v in box.attrib["size"].split()[:3]) return ( mass * (sy * sy + sz * sz) / 12.0, mass * (sx * sx + sz * sz) / 12.0, mass * (sx * sx + sy * sy) / 12.0, ) cyl = geom.find("cylinder") if cyl is not None: r = max(abs(float(cyl.attrib.get("radius", 0.05))), 0.01) h = max(abs(float(cyl.attrib.get("length", 0.1))), 0.02) ixx = mass * (3.0 * r * r + h * h) / 12.0 izz = 0.5 * mass * r * r return (ixx, ixx, izz) sph = geom.find("sphere") if sph is not None: r = max(abs(float(sph.attrib.get("radius", 0.05))), 0.01) i = 0.4 * mass * r * r return (i, i, i) r = 0.05 i = 0.4 * mass * r * r return (i, i, i) def repair_urdf( urdf_path: Path, src_robots_dir: Path, dst_robots_dir: Path, dry_run: bool, ) -> dict[str, int]: """Repair a single URDF and copy its referenced meshes into `//meshes/`.""" rel_urdf = urdf_path.relative_to(src_robots_dir) model_root_name = rel_urdf.parts[0] dst_urdf = dst_robots_dir / rel_urdf dst_model_dir = dst_robots_dir / model_root_name tree = ET.parse(urdf_path) root = tree.getroot() stats = { "meshes_rewritten": 0, "meshes_copied": 0, "meshes_missing": 0, "inertias_repaired": 0, "materials_added": 0, } # 1. Resolve and rewrite package:// mesh paths copied_pairs: set[tuple[Path, Path]] = set() for mesh_el in root.iter("mesh"): fn = mesh_el.attrib.get("filename", "") if not fn.startswith("package://"): continue src_mesh = resolve_package_uri(fn, src_robots_dir) if src_mesh is None: stats["meshes_missing"] += 1 continue m = re.match(r"^package://+[^/]+/(.+)$", fn.strip()) rel_inside_pkg = Path(m.group(1)) # Normalize `robots//meshes/...` -> `meshes/...` when inside the same model parts = rel_inside_pkg.parts if len(parts) >= 2 and parts[0] == "robots" and parts[1] == model_root_name: mesh_rel = Path(*parts[2:]) elif len(parts) >= 2 and parts[0] == "robots": mesh_rel = Path("_shared") / Path(*parts[1:]) else: mesh_rel = rel_inside_pkg dst_mesh = dst_model_dir / mesh_rel rel_from_urdf = Path("..") / mesh_rel if len(rel_urdf.parts) >= 3 else mesh_rel mesh_el.attrib["filename"] = rel_from_urdf.as_posix() stats["meshes_rewritten"] += 1 copied_pairs.add((src_mesh, dst_mesh)) # 2. Repair missing on moving/root links, zero/negative mass, and non-SPD inertia tensors moving_links = set() child_links = set() for j in root.findall("joint"): ch = j.find("child") if ch is not None and "link" in ch.attrib: cname = ch.attrib["link"] child_links.add(cname) if j.attrib.get("type", "fixed") != "fixed": moving_links.add(cname) for link in root.findall("link"): lname = link.attrib.get("name", "") if lname not in child_links and lname.lower() != "world": moving_links.add(lname) for link in root.findall("link"): link_name = link.attrib.get("name", "") iner = link.find("inertial") if iner is None: if link_name in moving_links and link.find("collision") is None: iner = ET.SubElement(link, "inertial") ET.SubElement(iner, "origin", {"xyz": "0 0 0", "rpy": "0 0 0"}) ET.SubElement(iner, "mass", {"value": "0.001"}) f_ixx, f_iyy, f_izz = fallback_inertia_for_link(link, 0.001) ET.SubElement( iner, "inertia", { "ixx": f"{f_ixx:.6e}", "iyy": f"{f_iyy:.6e}", "izz": f"{f_izz:.6e}", "ixy": "0", "ixz": "0", "iyz": "0", }, ) stats["inertias_repaired"] += 1 continue mass_el = iner.find("mass") mass = float(mass_el.attrib.get("value", "0")) if mass_el is not None else 0.0 i_el = iner.find("inertia") if i_el is None: continue ixx = float(i_el.attrib.get("ixx", "0")) iyy = float(i_el.attrib.get("iyy", "0")) izz = float(i_el.attrib.get("izz", "0")) ixy = float(i_el.attrib.get("ixy", "0")) ixz = float(i_el.attrib.get("ixz", "0")) iyz = float(i_el.attrib.get("iyz", "0")) needs_mass = mass <= 0.0 needs_inertia = not is_spd_inertia(ixx, iyy, izz, ixy, ixz, iyz) if needs_mass or needs_inertia: has_geom = link.find("collision") is not None or link.find("visual") is not None fixed_mass = (0.1 if has_geom else 1e-3) if needs_mass else mass if mass_el is None: mass_el = ET.SubElement(iner, "mass") mass_el.attrib["value"] = f"{fixed_mass:.6g}" f_ixx, f_iyy, f_izz = fallback_inertia_for_link(link, fixed_mass) i_el.attrib["ixx"] = f"{f_ixx:.6e}" i_el.attrib["iyy"] = f"{f_iyy:.6e}" i_el.attrib["izz"] = f"{f_izz:.6e}" i_el.attrib["ixy"] = "0" i_el.attrib["ixz"] = "0" i_el.attrib["iyz"] = "0" stats["inertias_repaired"] += 1 # 3. Ensure every referenced exists at root defined_mats = {m.attrib["name"] for m in root.findall("material") if "name" in m.attrib} for link in root.findall("link"): for vis in link.findall("visual"): mat = vis.find("material") if mat is None or "name" not in mat.attrib: continue if mat.find("color") is not None or mat.find("texture") is not None: continue mat_name = mat.attrib["name"] if mat_name not in defined_mats: rgba = KNOWN_MATERIAL_RGBA.get(mat_name.lower(), "0.5 0.5 0.5 1.0") top_mat = ET.Element("material", {"name": mat_name}) ET.SubElement(top_mat, "color", {"rgba": rgba}) root.insert(0, top_mat) defined_mats.add(mat_name) stats["materials_added"] += 1 if not dry_run: dst_urdf.parent.mkdir(parents=True, exist_ok=True) ET.indent(tree, space=" ") tree.write(dst_urdf, encoding="utf-8", xml_declaration=True) for src_mesh, dst_mesh in sorted(copied_pairs): dst_mesh.parent.mkdir(parents=True, exist_ok=True) if not dst_mesh.exists(): shutil.copy2(src_mesh, dst_mesh) stats["meshes_copied"] += 1 else: stats["meshes_copied"] = len(copied_pairs) return stats def main() -> None: parser = argparse.ArgumentParser(description="Repair example_robot_data URDFs for tars-fleet.") parser.add_argument("--src", type=Path, default=DEFAULT_SRC, help="Source example_robot_data/robots directory") parser.add_argument("--dst", type=Path, default=DEFAULT_DST, help="Destination directory in tars-fleet") parser.add_argument("--dry-run", action="store_true", help="Inspect and report repairs without writing files") args = parser.parse_args() urdfs = sorted(args.src.rglob("*.urdf")) totals = { "urdfs": len(urdfs), "meshes_rewritten": 0, "meshes_copied": 0, "meshes_missing": 0, "inertias_repaired": 0, "materials_added": 0, } for u in urdfs: res = repair_urdf(u, args.src, args.dst, dry_run=args.dry_run) for k, v in res.items(): totals[k] += v mode = "DRY-RUN" if args.dry_run else "WROTE" print(f"[{mode}] {totals}") if __name__ == "__main__": main()