tars-fleet / scripts /repair_example_robot_data.py
kthulhu's picture
Update scripts/repair_example_robot_data.py for tars-fleet rename and repair report
590da42 verified
Raw History Blame Contribute Delete
11.9 kB
#!/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 `<material>` entries referenced by `<visual>`.
"""
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://<pkg>/<rel>` (or `package:///<pkg>/<rel>`) 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 `<dst>/<rel_dir>/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/<model>/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 <inertial> 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 <visual><material name="..."/> exists at <robot> 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()