| """Shared helpers to rebuild robot USDs whose joints and links match a URDF.""" |
|
|
| import math |
| import xml.etree.ElementTree as ET |
|
|
| import numpy as np |
| from pxr import Gf, Sdf, Usd, UsdGeom, UsdPhysics, Vt |
|
|
| |
|
|
|
|
| def _origin(el): |
| xyz = [float(v) for v in (el.get("xyz", "0 0 0") if el is not None else "0 0 0").split()] |
| rpy = [float(v) for v in (el.get("rpy", "0 0 0") if el is not None else "0 0 0").split()] |
| cr, sr = math.cos(rpy[0]), math.sin(rpy[0]) |
| cp, sp = math.cos(rpy[1]), math.sin(rpy[1]) |
| cy, sy = math.cos(rpy[2]), math.sin(rpy[2]) |
| T = np.eye(4) |
| T[:3, :3] = [ |
| [cy * cp, cy * sp * sr - sy * cr, cy * sp * cr + sy * sr], |
| [sy * cp, sy * sp * sr + cy * cr, sy * sp * cr - cy * sr], |
| [-sp, cp * sr, cp * cr], |
| ] |
| T[:3, 3] = xyz |
| return T |
|
|
|
|
| def _rot(axis, angle): |
| axis = np.asarray(axis, float) |
| axis = axis / np.linalg.norm(axis) |
| x, y, z = axis |
| c, s, C = math.cos(angle), math.sin(angle), 1 - math.cos(angle) |
| T = np.eye(4) |
| T[:3, :3] = [ |
| [c + x * x * C, x * y * C - z * s, x * z * C + y * s], |
| [y * x * C + z * s, c + y * y * C, y * z * C - x * s], |
| [z * x * C - y * s, z * y * C + x * s, c + z * z * C], |
| ] |
| return T |
|
|
|
|
| def _trans(v): |
| T = np.eye(4) |
| T[:3, 3] = v |
| return T |
|
|
|
|
| def urdf_joints(path): |
| root = ET.parse(path).getroot() |
| joints = [] |
| for j in root.findall("joint"): |
| axis = j.find("axis") |
| lim = j.find("limit") |
| mimic = j.find("mimic") |
| joints.append( |
| { |
| "name": j.get("name"), |
| "type": j.get("type"), |
| "parent": j.find("parent").get("link"), |
| "child": j.find("child").get("link"), |
| "origin": _origin(j.find("origin")), |
| "axis": [float(v) for v in axis.get("xyz").split()] if axis is not None else [1, 0, 0], |
| "limit": (float(lim.get("lower", 0)), float(lim.get("upper", 0))) if lim is not None else None, |
| "mimic": (mimic.get("joint"), float(mimic.get("multiplier", 1)), float(mimic.get("offset", 0))) |
| if mimic is not None |
| else None, |
| } |
| ) |
| links = [l.get("name") for l in root.findall("link")] |
| return links, joints |
|
|
|
|
| def urdf_fk(path, q): |
| """World pose of every link for joint values `q` (radians / meters).""" |
| links, joints = urdf_joints(path) |
| by_child = {j["child"]: j for j in joints} |
| out = {} |
|
|
| def value(j): |
| if j["mimic"]: |
| name, mult, off = j["mimic"] |
| return q.get(name, 0.0) * mult + off |
| return q.get(j["name"], 0.0) |
|
|
| def world(link): |
| if link in out: |
| return out[link] |
| j = by_child.get(link) |
| if j is None: |
| out[link] = np.eye(4) |
| return out[link] |
| T = world(j["parent"]) @ j["origin"] |
| if j["type"] in ("revolute", "continuous"): |
| T = T @ _rot(j["axis"], value(j)) |
| elif j["type"] == "prismatic": |
| T = T @ _trans(np.asarray(j["axis"], float) * value(j)) |
| out[link] = T |
| return T |
|
|
| for l in links: |
| world(l) |
| return out |
|
|
|
|
| |
|
|
|
|
| def np_matrix(m): |
| """Gf (row vectors) to numpy (column vectors).""" |
| return np.array(m, dtype=float).T |
|
|
|
|
| def _quat(q): |
| im = q.GetImaginary() |
| return Gf.Quatd(q.GetReal(), Gf.Vec3d(im[0], im[1], im[2])) |
|
|
|
|
| def _frame(pos, rot): |
| T = np.eye(4) |
| T[:3, :3] = np.array(Gf.Matrix3d(Gf.Rotation(_quat(rot))), dtype=float).T |
| T[:3, 3] = [pos[0], pos[1], pos[2]] |
| return T |
|
|
|
|
| AXES = {"X": [1, 0, 0], "Y": [0, 1, 0], "Z": [0, 0, 1]} |
|
|
|
|
| def usd_model(stage): |
| cache = UsdGeom.XformCache() |
| bodies, joints = {}, [] |
| for p in stage.Traverse(): |
| if p.HasAPI(UsdPhysics.RigidBodyAPI): |
| bodies[str(p.GetPath())] = np_matrix(cache.GetLocalToWorldTransform(p)) |
| for p in stage.Traverse(): |
| if not p.IsA(UsdPhysics.Joint): |
| continue |
| j = UsdPhysics.Joint(p) |
| b0 = j.GetBody0Rel().GetTargets() |
| b1 = j.GetBody1Rel().GetTargets() |
| kind = "fixed" |
| axis, limit = None, None |
| if p.IsA(UsdPhysics.RevoluteJoint): |
| kind, s = "revolute", UsdPhysics.RevoluteJoint(p) |
| elif p.IsA(UsdPhysics.PrismaticJoint): |
| kind, s = "prismatic", UsdPhysics.PrismaticJoint(p) |
| if kind != "fixed": |
| axis = s.GetAxisAttr().Get() |
| limit = (s.GetLowerLimitAttr().Get(), s.GetUpperLimitAttr().Get()) |
| |
| |
| def owner(targets, local_frame): |
| if not targets: |
| return None, local_frame |
| prim = stage.GetPrimAtPath(targets[0]) |
| body = prim |
| while body and body.IsValid() and str(body.GetPath()) not in bodies: |
| body = body.GetParent() |
| if not body or not body.IsValid() or body.IsPseudoRoot(): |
| return str(targets[0]), local_frame |
| offset = np.linalg.inv(bodies[str(body.GetPath())]) @ np_matrix(cache.GetLocalToWorldTransform(prim)) |
| return str(body.GetPath()), offset @ local_frame |
|
|
| body0, J0 = owner(b0, _frame(j.GetLocalPos0Attr().Get(), j.GetLocalRot0Attr().Get())) |
| body1, J1 = owner(b1, _frame(j.GetLocalPos1Attr().Get(), j.GetLocalRot1Attr().Get())) |
| joints.append( |
| { |
| "name": p.GetName(), |
| "path": str(p.GetPath()), |
| "type": kind, |
| "body0": body0, |
| "body1": body1, |
| "J0": J0, |
| "J1": J1, |
| "axis": axis, |
| "limit": limit, |
| } |
| ) |
| return bodies, joints |
|
|
|
|
| def usd_fk(model, q): |
| """World pose of every body for joint values `q` (degrees / meters), keyed by body path.""" |
| bodies, joints = model |
| |
| by_body1 = {j["body1"]: j for j in joints if j["body0"] in bodies and j["body1"]} |
| out = {} |
|
|
| def world(b): |
| if b in out: |
| return out[b] |
| j = by_body1.get(b) |
| if j is None: |
| out[b] = bodies[b] |
| return out[b] |
| M = np.eye(4) |
| v = q.get(j["name"], 0.0) |
| if j["type"] == "revolute": |
| M = _rot(AXES[j["axis"]], math.radians(v)) |
| elif j["type"] == "prismatic": |
| M = _trans(np.asarray(AXES[j["axis"]], float) * v) |
| out[b] = world(j["body0"]) @ j["J0"] @ M @ np.linalg.inv(j["J1"]) |
| return out[b] |
|
|
| for b in bodies: |
| world(b) |
| return out |
|
|
|
|
| def check_against_urdf(stage, urdf, samples=200, seed=0): |
| """Pose USD and URDF with the same random joint values and compare every link. |
| |
| USD bodies are matched to URDF links by name. Each link may differ from the URDF by a constant |
| offset at rest (a different frame convention); after that, motion must agree exactly. |
| """ |
| model = usd_model(stage) |
| bodies, joints = model |
| links, ujoints = urdf_joints(urdf) |
| name_of = {p.rsplit("/", 1)[1]: p for p in bodies} |
| |
| cache = UsdGeom.XformCache() |
| riders = {} |
| for p in stage.Traverse(): |
| if p.GetName() in links and p.GetName() not in name_of and p.IsA(UsdGeom.Xformable): |
| anc = p.GetParent() |
| while anc and str(anc.GetPath()) not in bodies: |
| anc = anc.GetParent() |
| if anc: |
| b = str(anc.GetPath()) |
| riders[p.GetName()] = (b, np.linalg.inv(bodies[b]) @ np_matrix(cache.GetLocalToWorldTransform(p))) |
| def fk_all(model, q): |
| out = usd_fk(model, q) |
| for name, (b, rel) in riders.items(): |
| out["rider:" + name] = out[b] @ rel |
| return out |
|
|
| name_of.update({n: "rider:" + n for n in riders}) |
| bodies = {**bodies, **{"rider:" + n: bodies[b] @ rel for n, (b, rel) in riders.items()}} |
| shared = [l for l in links if l in name_of] |
| movable = [j for j in ujoints if j["type"] in ("revolute", "prismatic", "continuous") and not j["mimic"]] |
| mimics = [j for j in ujoints if j["mimic"]] |
| rest_u = urdf_fk(urdf, {}) |
| rest_s = fk_all(model, {}) |
| ref = shared[0] |
| A = rest_s[name_of[ref]] @ np.linalg.inv(rest_u[ref]) |
| D = {l: np.linalg.inv(A @ rest_u[l]) @ rest_s[name_of[l]] for l in shared} |
| rest_err = max(np.abs(rest_s[p] - bodies[p]).max() for p in bodies) |
| rng = np.random.default_rng(seed) |
| worst_pos, worst_rot = 0.0, 0.0 |
| for _ in range(samples): |
| qu = {} |
| for j in movable: |
| lo, hi = j["limit"] if j["limit"] else (-math.pi, math.pi) |
| qu[j["name"]] = rng.uniform(lo, hi) |
| for j in mimics: |
| name, mult, off = j["mimic"] |
| qu[j["name"]] = qu[name] * mult + off |
| qs = {k: (math.degrees(v) if any(j["name"] == k and j["type"] != "prismatic" for j in ujoints) else v) for k, v in qu.items()} |
| fu = urdf_fk(urdf, qu) |
| fs = fk_all(model, qs) |
| for l in shared: |
| expected = A @ fu[l] @ D[l] |
| got = fs[name_of[l]] |
| worst_pos = max(worst_pos, np.linalg.norm(expected[:3, 3] - got[:3, 3])) |
| R = expected[:3, :3].T @ got[:3, :3] |
| worst_rot = max(worst_rot, math.degrees(math.acos(max(-1, min(1, (np.trace(R) - 1) / 2))))) |
| frame_offsets = { |
| l: (round(float(np.linalg.norm(D[l][:3, 3])) * 1000, 2), round(math.degrees(math.acos(max(-1, min(1, (np.trace(D[l][:3, :3]) - 1) / 2)))), 2)) |
| for l in shared |
| } |
| return { |
| "links_missing": [l for l in links if l not in name_of], |
| "joints_missing": [j["name"] for j in ujoints if j["type"] != "fixed" and j["name"] not in {k["name"] for k in joints}], |
| "rest_consistency_m": float(rest_err), |
| "worst_pos_mm": worst_pos * 1000, |
| "worst_rot_deg": worst_rot, |
| "frame_offsets_mm_deg": frame_offsets, |
| } |
|
|
|
|
| |
|
|
|
|
| def flatten(path, variants=None): |
| """One layer holding the composed stage, every instance turned into its own prims.""" |
| stage = Usd.Stage.Open(path) |
| stage.SetEditTarget(stage.GetSessionLayer()) |
| for name, selection in (variants or {}).items(): |
| stage.GetDefaultPrim().GetVariantSet(name).SetVariantSelection(selection) |
| while True: |
| instances = [p for p in stage.Traverse() if p.IsInstance()] |
| if not instances: |
| break |
| for p in instances: |
| p.SetInstanceable(False) |
| return stage.Flatten(addSourceFileComment=False) |
|
|
|
|
| def _remap_list(listop, fn): |
| for field in ("explicitItems", "prependedItems", "appendedItems", "addedItems", "deletedItems", "orderedItems"): |
| items = list(getattr(listop, field)) |
| mapped = [fn(i) for i in items] |
| mapped = [m for m in mapped if m is not None] |
| if mapped != items: |
| setattr(listop, field, mapped) |
|
|
|
|
| def remap_targets(layer, fn): |
| """Applies `fn(path) -> path | None` to every relationship target and attribute connection.""" |
|
|
| def visit(path): |
| if not path.IsPropertyPath(): |
| return |
| spec = layer.GetObjectAtPath(path) |
| if isinstance(spec, Sdf.RelationshipSpec): |
| _remap_list(spec.targetPathList, fn) |
| elif isinstance(spec, Sdf.AttributeSpec): |
| _remap_list(spec.connectionPathList, fn) |
|
|
| layer.Traverse(Sdf.Path.absoluteRootPath, visit) |
|
|
|
|
| def rename(layer, path, new_name): |
| old = Sdf.Path(path) |
| new = old.ReplaceName(new_name) |
| edit = Sdf.BatchNamespaceEdit() |
| edit.Add(Sdf.NamespaceEdit.Rename(old, new_name)) |
| if not layer.Apply(edit): |
| raise RuntimeError(f"rename {old} -> {new_name}") |
| remap_targets(layer, lambda p: p.ReplacePrefix(old, new) if p.HasPrefix(old) else p) |
| return str(new) |
|
|
|
|
| def remove(layer, path): |
| path = Sdf.Path(path) |
| edit = Sdf.BatchNamespaceEdit() |
| edit.Add(Sdf.NamespaceEdit.Remove(path)) |
| if not layer.Apply(edit): |
| raise RuntimeError(f"remove {path}") |
| remap_targets(layer, lambda p: None if p.HasPrefix(path) else p) |
|
|
|
|
| def add_frame(stage, parent_path, name, world): |
| """An Xform under `parent_path` placed at `world` (numpy, column vectors).""" |
| parent = stage.GetPrimAtPath(parent_path) |
| parent_world = np_matrix(UsdGeom.XformCache().GetLocalToWorldTransform(parent)) |
| local = np.linalg.inv(parent_world) @ world |
| x = UsdGeom.Xform.Define(stage, f"{parent_path}/{name}") |
| x.AddTransformOp().Set(Gf.Matrix4d(local.T.tolist())) |
| return x |
|
|
|
|
| |
|
|
|
|
| def crease_normals(points, faces, crease_deg=30.0): |
| """Splits vertices along edges sharper than `crease_deg` and returns per-vertex normals.""" |
| a, b, c = (points[faces[:, k]] for k in range(3)) |
| fn = np.cross(b - a, c - a) |
| area = np.linalg.norm(fn, axis=1) |
| keep = area > 1e-20 |
| faces, fn, area = faces[keep], fn[keep], area[keep] |
| unit = fn / area[:, None] |
| m = len(faces) |
| corner_vertex = faces.reshape(-1) |
| corner_face = np.repeat(np.arange(m), 3) |
| order = np.argsort(corner_vertex, kind="stable") |
| sorted_v = corner_vertex[order] |
| starts = np.flatnonzero(np.r_[True, sorted_v[1:] != sorted_v[:-1]]) |
| ends = np.r_[starts[1:], len(sorted_v)] |
| cos_t = math.cos(math.radians(crease_deg)) |
| corner_normal = np.zeros((3 * m, 3)) |
| for s, e in zip(starts, ends): |
| corners = order[s:e] |
| fs = corner_face[corners] |
| u = unit[fs] |
| similar = (u @ u.T) > cos_t |
| corner_normal[corners] = similar.astype(float) @ fn[fs] |
| corner_normal /= np.maximum(np.linalg.norm(corner_normal, axis=1, keepdims=True), 1e-30) |
| q = np.round(corner_normal * 1024).astype(np.int32) |
| key = np.concatenate([corner_vertex[:, None], q], axis=1) |
| unique, first, inverse = np.unique(key, axis=0, return_index=True, return_inverse=True) |
| new_points = points[unique[:, 0]] |
| new_normals = corner_normal[first] |
| new_faces = inverse.reshape(-1).reshape(m, 3) |
| return new_points, new_faces, new_normals |
|
|
|
|
| def weld(points, faces): |
| unique, inverse = np.unique(points, axis=0, return_inverse=True) |
| return unique, inverse.reshape(-1)[faces] |
|
|
|
|
| def author_mesh(stage, path, points, faces, normals, material=None): |
| mesh = UsdGeom.Mesh.Define(stage, path) |
| mesh.CreatePointsAttr(Vt.Vec3fArray.FromNumpy(points.astype(np.float32))) |
| mesh.CreateFaceVertexCountsAttr(Vt.IntArray.FromNumpy(np.full(len(faces), 3, dtype=np.int32))) |
| mesh.CreateFaceVertexIndicesAttr(Vt.IntArray.FromNumpy(faces.reshape(-1).astype(np.int32))) |
| mesh.CreateNormalsAttr(Vt.Vec3fArray.FromNumpy(normals.astype(np.float32))) |
| mesh.SetNormalsInterpolation(UsdGeom.Tokens.vertex) |
| mesh.CreateSubdivisionSchemeAttr(UsdGeom.Tokens.none) |
| mesh.CreateExtentAttr(Vt.Vec3fArray([Gf.Vec3f(*points.min(0)), Gf.Vec3f(*points.max(0))])) |
| if material is not None: |
| from pxr import UsdShade |
|
|
| UsdShade.MaterialBindingAPI.Apply(mesh.GetPrim()).Bind(UsdShade.Material(stage.GetPrimAtPath(material))) |
| return mesh |
|
|
|
|
| def compare_visual_bounds(source, out, renames=None): |
| """Worst corner offset (mm) between each body's drawn geometry in `source` and in `out`.""" |
| renames = renames or {} |
|
|
| def bounds(stage): |
| cache = UsdGeom.BBoxCache(Usd.TimeCode.Default(), ["default"], useExtentsHint=False) |
| found = {} |
| for p in stage.Traverse(Usd.TraverseInstanceProxies()): |
| if p.HasAPI(UsdPhysics.RigidBodyAPI): |
| |
| lo, hi = np.full(3, np.inf), np.full(3, -np.inf) |
| it = iter(Usd.PrimRange(p, Usd.TraverseInstanceProxies())) |
| for q in it: |
| if q != p and q.HasAPI(UsdPhysics.RigidBodyAPI): |
| it.PruneChildren() |
| continue |
| if q.IsA(UsdGeom.Mesh) and UsdGeom.Imageable(q).ComputePurpose() == "default": |
| r = cache.ComputeWorldBound(q).ComputeAlignedRange() |
| lo, hi = np.minimum(lo, r.GetMin()), np.maximum(hi, r.GetMax()) |
| if np.isfinite(lo).all(): |
| found[renames.get(p.GetName(), p.GetName())] = (lo, hi) |
| return found |
|
|
| a, b = bounds(source), bounds(out) |
| return {k: round(float(max(np.abs(a[k][0] - b[k][0]).max(), np.abs(a[k][1] - b[k][1]).max())) * 1000, 2) if k in b else "missing" for k in a} |
|
|
|
|
| |
|
|
|
|
| def read_stl(path): |
| """Points and triangles of a binary STL.""" |
| data = open(path, "rb").read() |
| n = int(np.frombuffer(data, np.uint32, 1, 80)[0]) |
| tris = np.frombuffer(data, np.dtype([("n", "<f4", 3), ("v", "<f4", (3, 3)), ("a", "<u2")]), n, 84) |
| return tris["v"].reshape(-1, 3).astype(float), np.arange(3 * n).reshape(n, 3) |
|
|
|
|
| def srgb_to_linear(c): |
| c = np.asarray(c, float) |
| return np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4) |
|
|
|
|
| def _axis_frame(axis): |
| """The USD axis token for a URDF axis along X, Y or Z, and the rotation turning that token into it.""" |
| a = np.asarray(axis, float) |
| i = int(np.argmax(np.abs(a))) |
| if not np.allclose(np.abs(a), np.eye(3)[i]): |
| raise ValueError(f"axis {axis} is not along X, Y or Z") |
| R = np.eye(4) if a[i] > 0 else _rot(np.eye(3)[(i + 1) % 3], math.pi) |
| return "XYZ"[i], R |
|
|
|
|
| def _set_matrix(xformable, M): |
| xformable.ClearXformOpOrder() |
| xformable.AddTransformOp().Set(Gf.Matrix4d(M.T.tolist())) |
|
|
|
|
| def _pose(M): |
| q = Gf.Matrix4d(M.T.tolist()).ExtractRotationQuat() |
| im = q.GetImaginary() |
| return Gf.Vec3f(*M[:3, 3]), Gf.Quatf(q.GetReal(), Gf.Vec3f(im[0], im[1], im[2])) |
|
|
|
|
| def from_urdf(urdf, name, colors=None): |
| """A stage drawing the URDF's visual meshes, with a rigid body per link a moving joint drives. |
| |
| Links fixed to another are frames under its body, so every link keeps the URDF's name and frame; |
| joints are UsdPhysics joints (limits in degrees), the root link at the origin. `colors` maps a |
| link to an sRGB color replacing its URDF material. |
| """ |
| from pxr import UsdShade |
|
|
| root_el = ET.parse(urdf).getroot() |
| mesh_dir = urdf.rsplit("/", 1)[0] if "/" in urdf else "." |
| links, joints = urdf_joints(urdf) |
| by_child = {j["child"]: j for j in joints} |
| rest = urdf_fk(urdf, {}) |
| named_colors = {m.get("name"): [float(v) for v in m.find("color").get("rgba").split()[:3]] for m in root_el.findall("material") if m.find("color") is not None} |
|
|
| stage = Usd.Stage.CreateInMemory() |
| UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z) |
| UsdGeom.SetStageMetersPerUnit(stage, 1.0) |
| UsdPhysics.SetStageKilogramsPerUnit(stage, 1.0) |
| robot = UsdGeom.Xform.Define(stage, f"/{name}") |
| stage.SetDefaultPrim(robot.GetPrim()) |
| Usd.ModelAPI(robot.GetPrim()).SetKind("component") |
| UsdGeom.Scope.Define(stage, f"/{name}/Materials") |
| UsdGeom.Scope.Define(stage, f"/{name}/Geometry") |
| UsdGeom.Scope.Define(stage, f"/{name}/Joints") |
|
|
| materials = {} |
|
|
| def material(rgb): |
| key = tuple(round(c, 5) for c in rgb) |
| if key not in materials: |
| path = f"/{name}/Materials/material_{len(materials)}" |
| mat = UsdShade.Material.Define(stage, path) |
| shader = UsdShade.Shader.Define(stage, f"{path}/PreviewSurface") |
| shader.CreateIdAttr("UsdPreviewSurface") |
| shader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set(Gf.Vec3f(*srgb_to_linear(rgb))) |
| shader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) |
| shader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.5) |
| mat.CreateSurfaceOutput().ConnectToSource(shader.ConnectableAPI(), "surface") |
| materials[key] = path |
| return materials[key] |
|
|
| |
| def body_of(link): |
| j = by_child.get(link) |
| return link if j is None or j["type"] != "fixed" else body_of(j["parent"]) |
|
|
| paths = {} |
| for link in links: |
| body = body_of(link) |
| if body == link: |
| paths[link] = f"/{name}/Geometry/{link}" |
| x = UsdGeom.Xform.Define(stage, paths[link]) |
| _set_matrix(x, rest[link]) |
| UsdPhysics.RigidBodyAPI.Apply(x.GetPrim()) |
| if by_child.get(link) is None: |
| UsdPhysics.ArticulationRootAPI.Apply(x.GetPrim()) |
| for link in links: |
| body = body_of(link) |
| if body != link: |
| paths[link] = f"{paths[body]}/{link}" |
| _set_matrix(UsdGeom.Xform.Define(stage, paths[link]), np.linalg.inv(rest[body]) @ rest[link]) |
|
|
| for el in root_el.findall("link"): |
| link = el.get("name") |
| inertial = el.find("inertial") |
| if inertial is not None and body_of(link) == link: |
| mass = UsdPhysics.MassAPI.Apply(stage.GetPrimAtPath(paths[link])) |
| mass.CreateMassAttr(float(inertial.find("mass").get("value"))) |
| mass.CreateCenterOfMassAttr(Gf.Vec3f(*_origin(inertial.find("origin"))[:3, 3])) |
| for k, visual in enumerate(el.findall("visual")): |
| mesh_el = visual.find("geometry/mesh") |
| if mesh_el is None: |
| raise ValueError(f"{link}: only mesh visuals are supported") |
| points, faces = read_stl(f"{mesh_dir}/{mesh_el.get('filename')}") |
| scale = [float(v) for v in mesh_el.get("scale", "1 1 1").split()] |
| T = _origin(visual.find("origin")) |
| points = (T[:3, :3] @ (points * scale).T).T + T[:3, 3] |
| points, faces = weld(points, faces) |
| points, faces, normals = crease_normals(points, faces) |
| mat_el = visual.find("material") |
| rgb = (colors or {}).get(link) |
| if rgb is None and mat_el is not None: |
| color_el = mat_el.find("color") |
| rgb = [float(v) for v in color_el.get("rgba").split()[:3]] if color_el is not None else named_colors[mat_el.get("name")] |
| author_mesh(stage, f"{paths[link]}/visual" + (f"_{k}" if k else ""), points, faces, normals, material(rgb) if rgb else None) |
|
|
| for j in joints: |
| if j["type"] == "fixed": |
| continue |
| kind = {"revolute": UsdPhysics.RevoluteJoint, "continuous": UsdPhysics.RevoluteJoint, "prismatic": UsdPhysics.PrismaticJoint}[j["type"]] |
| joint = kind.Define(stage, f"/{name}/Joints/{j['name']}") |
| token, R = _axis_frame(j["axis"]) |
| parent = body_of(j["parent"]) |
| frame = rest[j["child"]] @ R |
| pos0, rot0 = _pose(np.linalg.inv(rest[parent]) @ frame) |
| pos1, rot1 = _pose(R) |
| joint.CreateBody0Rel().SetTargets([paths[parent]]) |
| joint.CreateBody1Rel().SetTargets([paths[j["child"]]]) |
| joint.CreateLocalPos0Attr(pos0) |
| joint.CreateLocalRot0Attr(rot0) |
| joint.CreateLocalPos1Attr(pos1) |
| joint.CreateLocalRot1Attr(rot1) |
| joint.CreateAxisAttr(token) |
| if j["type"] != "continuous" and j["limit"]: |
| lo, hi = j["limit"] |
| if j["type"] == "revolute": |
| lo, hi = math.degrees(lo), math.degrees(hi) |
| joint.CreateLowerLimitAttr(lo) |
| joint.CreateUpperLimitAttr(hi) |
| if j["mimic"]: |
| |
| |
| reference, multiplier, offset = j["mimic"] |
| if offset: |
| raise NotImplementedError(f"{j['name']}: a mimic offset needs its units settled first") |
| dof = ("trans" if j["type"] == "prismatic" else "rot") + token |
| prim = joint.GetPrim() |
| prim.AddAppliedSchema(f"PhysxMimicJointAPI:{dof}") |
| prim.CreateRelationship(f"physxMimicJoint:{dof}:referenceJoint").SetTargets([f"/{name}/Joints/{reference}"]) |
| prim.CreateAttribute(f"physxMimicJoint:{dof}:gearing", Sdf.ValueTypeNames.Float).Set(-multiplier) |
| return stage |
|
|
