File size: 11,336 Bytes
33c14d6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 | """Check asset scale, grasp collision fit, labels, and five seconds of settling.
Runs headlessly with the base dependencies. Does not certify a manipulation policy.
"""
from __future__ import annotations
import hashlib
import json
import xml.etree.ElementTree as ET
from pathlib import Path
import mujoco
import numpy as np
HERE = Path(__file__).resolve().parent
ROOT = HERE / "assets" / "chess"
def triangles(path):
raw = path.read_bytes()
dtype = np.dtype([("normal", "<f4", 3), ("vertices", "<f4", (3, 3)), ("attribute", "<u2")])
return np.frombuffer(raw, dtype=dtype, offset=84)["vertices"].astype(float)
def cross_section_bounds(paths, z):
points = []
for path in paths:
tri = triangles(path)
for i, j in ((0, 1), (1, 2), (2, 0)):
a, b = tri[:, i], tri[:, j]
mask = ((a[:, 2] <= z) & (b[:, 2] > z)) | ((b[:, 2] <= z) & (a[:, 2] > z))
a, b = a[mask], b[mask]
points.append(a + (b - a) * ((z - a[:, 2]) / (b[:, 2] - a[:, 2]))[:, None])
xy = np.concatenate(points)[:, :2]
return np.array([xy.min(0), xy.max(0)])
def check_finger_hulls(hulls, tolerance=0.0003):
"""Slab hulls must match each finger's cross-sections where it touches pieces.
Samples keep 0.1 mm away from slab cuts: a cut at a step leaves a sliver the
thickness of the step search (0.05 mm) that straddles the step.
"""
from grasp_geometry import section_extent
arm = HERE / "assets" / "so101"
for part, info in hulls.items():
perm = [i for i in range(3) if i != info["axis"]] + [info["axis"]]
mesh = triangles(arm / info["source_file"])[:, :, perm]
hull = np.concatenate([triangles(arm / f) for f in info["collision"]])[:, :, perm]
lo, hi = info["grip_range_mm"]
heights = np.linspace(lo, hi, 400)
edges = np.array(info["slab_edges_mm"])
heights = heights[np.min(np.abs(heights[:, None] - edges[None]), axis=1) > 0.1] / 1000
worst = 0.0
for along in (np.array([1.0, 0.0]), np.array([0.0, 1.0])):
across = np.array([-along[1], along[0]])
a = section_extent(mesh, heights, along, across, 1.0)
b = section_extent(hull, heights, along, across, 1.0)
ok = ~np.isnan(a[0]) & ~np.isnan(b[0])
worst = max(worst, np.abs(a[0] - b[0])[ok].max(), np.abs(a[1] - b[1])[ok].max())
assert worst < tolerance, f"{part} finger hulls differ by {worst*1000:.3f} mm"
print(f"{part}: {len(info['collision'])} finger hulls, worst section error {worst*1000:.3f} mm")
def check_link_hulls(hulls, tolerance=0.00005):
"""Decomposed link hulls must contain every vertex of the part they replace.
Shapes smaller than the real part would let the expert plan moves that collide
on hardware, so the check is one-sided: the hulls may be larger, never smaller.
"""
arm = HERE / "assets" / "so101"
for part, info in hulls.items():
verts = triangles(arm / info["source_file"]).reshape(-1, 3) * info["scale"]
outside = np.full(len(verts), np.inf)
for f in info["collision"]:
tri = triangles(arm / f)
n = np.cross(tri[:, 1] - tri[:, 0], tri[:, 2] - tri[:, 0])
norm = np.linalg.norm(n, axis=1)
keep = norm > 1e-12
n = n[keep] / norm[keep, None]
c = np.einsum("ij,ij->i", n, tri[keep, 0])
outside = np.minimum(outside, (verts @ n.T - c).max(axis=1))
worst = max(outside.max(), 0.0)
assert worst < tolerance, f"{part} hulls miss the part by {worst*1000:.3f} mm"
print(f"{part}: {len(info['collision'])} hulls, {info['pieces_cm3']:.1f} cm3 "
f"(upstream hull {info['single_hull_cm3']:.1f}), cover the part to {worst*1000:.3f} mm")
def main():
# The scene may change appearance, but must preserve the supplied arm mechanics.
upstream = ET.parse(HERE / "assets/so101/so101_camera_upstream.xml").getroot()
patched = ET.parse(HERE / "assets/so101/so101.xml").getroot()
for tag in ("joint", "position", "inertial"):
assert [dict(e.attrib) for e in upstream.iter(tag)] == [dict(e.attrib) for e in patched.iter(tag)], tag
# The one declared change: listed parts' single collision hulls become several hulls
# in the same frame, class and material: finger slabs (prepare_gripper_assets.py) and
# link decompositions (prepare_arm_collision.py).
hulls = json.loads((HERE / "assets/so101/collision/manifest.json").read_text())["parts"]
expected_geoms, expected_meshes = [], [dict(e.attrib) for e in upstream.iter("mesh")]
for e in upstream.iter("geom"):
a = dict(e.attrib)
if a.get("class") == "collision" and a.get("mesh") in hulls:
files = hulls[a["mesh"]]["collision"]
expected_geoms += [{**a, "mesh": f"{a['mesh']}_col_{i}"} for i in range(len(files))]
expected_meshes += [{"name": f"{a['mesh']}_col_{i}", "file": f} for i, f in enumerate(files)]
else:
expected_geoms.append(a)
assert [dict(e.attrib) for e in patched.iter("geom")] == expected_geoms, "geom"
patched_meshes = [dict(e.attrib) for e in patched.iter("mesh")]
assert sorted(map(str, patched_meshes)) == sorted(map(str, expected_meshes)), "mesh"
for part, info in hulls.items():
assert hashlib.sha256((HERE / "assets/so101" / info["source_file"]).read_bytes()).hexdigest() == info["source_sha256"]
check_finger_hulls({k: v for k, v in hulls.items() if v["method"] == "slab"})
check_link_hulls({k: v for k, v in hulls.items() if v["method"] == "coacd"})
original_bodies = {e.get("name"): dict(e.attrib) for e in upstream.iter("body")}
for body in patched.iter("body"):
expected = original_bodies[body.get("name")].copy()
if body.get("name") == "base":
expected["pos"] = "0 0 0.06"
assert dict(body.attrib) == expected, body.get("name")
pieces = json.loads((ROOT / "manifest.json").read_text())["pieces"]
errors = []
for kind, p in pieces.items():
assert hashlib.sha256((ROOT / p["source_file"]).read_bytes()).hexdigest() == p["source_sha256"]
verts = triangles(ROOT / p["visual"]).reshape(-1, 3)
assert np.allclose([verts.min(0), verts.max(0)], p["bounds_m"], atol=1e-7), kind
assert np.max(np.ptp(verts[:, :2], axis=0)) < 0.025, f"{kind} exceeds square"
assert abs(verts[:, 2].min()) < 1e-7, f"{kind} not seated at origin"
visual = cross_section_bounds([ROOT / p["visual"]], p["grasp_z_m"])
contact = cross_section_bounds([ROOT / f for f in p["collision"]], p["grasp_z_m"])
error = float(np.abs(visual - contact).max())
assert error < 0.0002, f"{kind} collision surface differs by {error*1000:.3f} mm at grasp"
errors.append(error)
print(f"{kind}: {p['height_m']*1000:.2f} mm tall; grasp collision error {error*1000:.3f} mm")
m = mujoco.MjModel.from_xml_path(str(HERE / "chess_scene.xml"))
d = mujoco.MjData(m)
mujoco.mj_resetDataKeyframe(m, d, m.key("home").id)
mujoco.mj_forward(m, d)
table = m.geom("table")
assert table.type == mujoco.mjtGeom.mjGEOM_BOX
assert np.isclose(table.pos[2] + table.size[2], 0), "Table contact height changed"
assert not np.any(m.mat_reflectance), "Unexpected mirror material"
ids = [i for i in range(m.nbody) if m.body(i).name.startswith(("w_", "b_"))]
assert len(ids) == 32
for bid in ids:
name = m.body(bid).name
kind = name.split("_")[1]
p = pieces[kind]
assert m.jnt_type[m.body_jntadr[bid]] == mujoco.mjtJoint.mjJNT_FREE
assert np.isclose(m.body_mass[bid], p["mass_kg"])
assert np.isclose(m.site(name + "_grasp").pos[2], p["grasp_z_m"], atol=1e-7)
visual = m.geom(name + "_visual")
assert visual.contype == 0 and visual.conaffinity == 0 and visual.group == 2
collision_ids = np.flatnonzero((m.geom_bodyid == bid) & (m.geom_group == 3))
assert len(collision_ids) == p["collision_hulls"]
assert np.all(m.geom_contype[collision_ids] != 0)
for file in "abcdefgh":
for rank in range(1, 9):
assert m.site(f"sq_{file}{rank}").id >= 0
start = d.xpos[ids].copy()
for _ in range(round(5 / m.opt.timestep)):
mujoco.mj_step(m, d)
mujoco.mj_forward(m, d)
assert np.isfinite(d.qpos).all() and not d.warning.number.any()
drift = np.linalg.norm(d.xpos[ids, :2] - start[:, :2], axis=1).max()
tilt = np.degrees(np.arccos(np.clip(d.xmat[ids, 8], -1, 1))).max()
board_top = d.site_xpos[m.site("board_center").id, 2]
assert drift < 0.001, f"Piece drift {drift*1000:.3f} mm"
assert tilt < 2, f"Piece tilted {tilt:.2f} degrees"
assert np.max(np.abs(d.xpos[ids, 2] - board_top)) < 0.0005
touching = set()
for c in d.contact:
a, b = m.geom_bodyid[c.geom1], m.geom_bodyid[c.geom2]
if a == m.body("board").id:
touching.add(b)
if b == m.body("board").id:
touching.add(a)
assert set(ids) <= touching, "A piece is not supported by the board"
print(f"PASS: 32 supported pieces, 64 square sites, no physics warnings; "
f"5 s max drift {drift*1000:.3f} mm, max tilt {tilt:.3f} degrees.")
# Check frame coverage and line of sight in the actual parked pose. This does
# not imply visibility while the arm is executing a move.
for camera_name in ("overhead", "rover"):
cam = m.camera(camera_name)
eye = d.cam_xpos[cam.id]
rotation = d.cam_xmat[cam.id].reshape(3, 3)
tan_y = np.tan(np.radians(float(cam.fovy[0])) / 2)
mask = np.array([1, 1, 1, 0, 0, 0], dtype=np.uint8)
for file in "abcdefgh":
for rank in range(1, 9):
point = d.site_xpos[m.site(f"sq_{file}{rank}").id]
local = (point - eye) @ rotation
assert -local[2] > 0
assert abs(local[0] / local[2]) < tan_y * 4/3
assert abs(local[1] / local[2]) < tan_y
ray = point - eye
ray /= np.linalg.norm(ray)
hit = np.array([-1], dtype=np.int32)
mujoco.mj_ray(m, d, eye, ray, mask, 1, -1, hit)
assert hit[0] >= 0
body = m.body(m.geom_bodyid[hit[0]]).name
assert body == "board" or body.startswith(("w_", "b_")), f"{file}{rank} obscured by {body}"
rover_body = m.cam_bodyid[m.camera("rover").id]
assert m.body(m.body_parentid[rover_body]).name == "rover_deck"
# Include the board rim and space for tall pieces, not just square centers.
cid = m.camera("rover").id
rotation = d.cam_xmat[cid].reshape(3, 3)
tan_y = np.tan(np.radians(m.cam_fovy[cid]) / 2)
for x in (0.098, 0.322):
for y in (-0.112, 0.112):
for z in (0.008, 0.055):
local = (np.array([x, y, z]) - d.cam_xpos[cid]) @ rotation
assert local[2] < 0 and abs(local[0]/local[2]) < tan_y * 4/3
assert abs(local[1]/local[2]) < tan_y
print("PASS: SO-101 meshes, joints, actuators and inertials preserved; finite tabletop at z=0; "
"overhead and rover each frame 64/64 square centers unobstructed by the parked arm.")
if __name__ == "__main__":
main()
|