| """Convert every pinned URDF plus the AlienGo/Z1 Xacro assembly to portable USD. |
| |
| Run in the supplied Linux container. Source files remain unmodified. Converter |
| inputs live in a temporary directory; all published USD geometry is embedded. |
| """ |
| import argparse, concurrent.futures, json, os, pathlib, re, shutil, subprocess, sys, tempfile, traceback |
| from lxml import etree as ET |
|
|
| ROOT = pathlib.Path(__file__).resolve().parent |
| OUT = ROOT.parent if ROOT.name == 'scripts' else ROOT / 'dataset' |
| ROS = OUT / 'sources/unitree_ros/robots' |
|
|
| def jobs(): |
| result = [] |
| for p in sorted(ROS.rglob('*.urdf')): |
| result.append((p, p.relative_to(ROS).parts[0] + '/' + p.stem)) |
| result += [ |
| (ROS / 'aliengoZ1_description/xacro/robot.xacro', 'aliengoZ1_description/aliengo_z1'), |
| (OUT / 'sources/Qmini/urdf/Qmini.urdf', 'Qmini/Qmini'), |
| (OUT / 'sources/UniArmL1/assets/uniarml1/urdf/UniArmL1.urdf', 'UniArmL1/UniArmL1'), |
| (OUT / 'sources/z1_ros/z1_controller/config/z1.urdf', 'z1_ros/z1'), |
| (OUT / 'sources/xr_teleoperate/assets/brainco_hand/brainco_left.urdf', 'brainco_hand/brainco_left'), |
| (OUT / 'sources/xr_teleoperate/assets/brainco_hand/brainco_right.urdf', 'brainco_hand/brainco_right'), |
| (OUT / 'sources/unitree_rl_gym/resources/robots/g1_description/g1_12dof.urdf', 'unitree_rl_gym/g1_12dof'), |
| (OUT / 'sources/unitree_rl_gym/resources/robots/h1_2/h1_2_12dof.urdf', 'unitree_rl_gym/h1_2_12dof'), |
| (OUT / 'sources/unitree_rl_gym/resources/robots/h1_2/h1_2_simplified.urdf', 'unitree_rl_gym/h1_2_simplified'), |
| ] |
| return result |
|
|
| def flatten_bodies(stage): |
| from pxr import Usd, UsdGeom, UsdPhysics, Sdf |
| root = stage.GetDefaultPrim() |
| root_world = UsdGeom.XformCache().GetLocalToWorldTransform(root) |
| bodies = [p for p in stage.Traverse() if p.HasAPI(UsdPhysics.RigidBodyAPI)] |
| worlds = {str(p.GetPath()): UsdGeom.XformCache().GetLocalToWorldTransform(p) for p in bodies} |
| scope = root.GetPath().AppendChild('Bodies') |
| UsdGeom.Xform.Define(stage, scope) |
| for p in sorted(bodies, key=lambda p: len(str(p.GetPath())), reverse=True): |
| old = str(p.GetPath()) |
| new = scope.AppendChild(p.GetName()) |
| if stage.GetPrimAtPath(new): raise RuntimeError('Duplicate rigid body name: ' + p.GetName()) |
| edit = Usd.NamespaceEditor(stage) |
| if not edit.MovePrimAtPath(Sdf.Path(old), new): raise RuntimeError('Cannot move: ' + old) |
| if not edit.CanApplyEdits(): raise RuntimeError('Cannot apply body flattening: ' + old) |
| if not edit.ApplyEdits(): raise RuntimeError('Body flattening failed: ' + old) |
| xform = UsdGeom.Xformable(stage.GetPrimAtPath(new)) |
| xform.ClearXformOpOrder() |
| xform.AddTransformOp().Set(worlds[old] * root_world.GetInverse()) |
| for p in stage.Traverse(): |
| if p.HasAPI(UsdPhysics.ArticulationRootAPI): p.RemoveAPI(UsdPhysics.ArticulationRootAPI) |
| UsdPhysics.ArticulationRootAPI.Apply(root) |
|
|
| def convert_one(source, ident): |
| from pxr import Usd, UsdGeom, UsdPhysics, Sdf, Gf |
| import urdf_usd_converter |
| changes = [] |
| packages = {p.name: p for p in ROS.iterdir() if p.is_dir()} |
| if source.suffix == '.xacro': |
| import xacro, xacro.substitution_args |
| xacro.substitution_args._eval_find = lambda name: str(packages[name]) |
| doc = xacro.process_file(str(source), mappings={'DEBUG': 'false'}) |
| tree = ET.fromstring(doc.toxml().encode()) |
| changes.append('Expanded Xacro with DEBUG=false and default gripper enabled.') |
| else: |
| tree = ET.parse(str(source)).getroot() |
| tree.set('name', re.sub(r'[^a-zA-Z0-9_]', '_', ident.rsplit('/', 1)[-1])) |
| for i, material in enumerate(tree.iter('material')): |
| if not material.get('name'): |
| material.set('name', 'unnamed_material_' + str(i)) |
| changes.append('Assigned missing material name at index ' + str(i)) |
| for mesh in list(tree.iter('mesh')) + list(tree.iter('texture')): |
| name = mesh.get('filename') |
| if not name: continue |
| if name.startswith('package://'): |
| pkg, rel = name[len('package://'):].split('/', 1) |
| p = packages.get(pkg, source.parent) / rel |
| elif name.startswith('file://'): p = pathlib.Path(name[7:]) |
| else: p = source.parent / name |
| p = p.resolve() |
| if not p.is_file(): |
| candidates = sorted(set(source.parent.rglob(pathlib.Path(name).name))) |
| if not candidates: |
| pkgroot = next((q for q in source.parents if q.parent == ROS), source.parent) |
| candidates = sorted(set(pkgroot.rglob(pathlib.Path(name).name))) |
| if len(candidates) != 1: raise FileNotFoundError(f'{name}: expected {p}; found {len(candidates)} alternatives') |
| p = candidates[0] |
| changes.append(f'Resolved mesh {name} to {p.relative_to(OUT)}') |
| if p.stat().st_size < 256 and p.read_bytes().startswith(b'version https://git-lfs'): raise ValueError('Unresolved Git LFS pointer: ' + str(p)) |
| mesh.set('filename', str(p)) |
| dest = OUT / 'generated' / ident |
| dest.mkdir(parents=True, exist_ok=True) |
| with tempfile.TemporaryDirectory() as tmp: |
| normalized = pathlib.Path(tmp) / (tree.get('name') + '.urdf') |
| ET.ElementTree(tree).write(str(normalized), encoding='utf-8', xml_declaration=True) |
| converter = urdf_usd_converter.Converter(layer_structure=False, scene=False, |
| comment=f'Converted from {source.relative_to(OUT)}; see manifest.json for provenance.', |
| ros_packages=[{'name': n, 'path': str(p)} for n, p in packages.items()]) |
| asset = converter.convert(str(normalized), str(dest)) |
| path = pathlib.Path(asset.path) |
| stage = Usd.Stage.Open(str(path)) |
| if not stage or not stage.GetDefaultPrim(): raise RuntimeError('No default prim') |
| flatten_bodies(stage) |
| |
| |
| links = {link.get('name'): link for link in tree.findall('link')} |
| for prim in stage.Traverse(): |
| if not prim.HasAPI(UsdPhysics.RigidBodyAPI): continue |
| name = prim.GetDisplayName() or prim.GetName() |
| inertial = links[name].find('inertial') |
| if inertial is None: continue |
| origin = inertial.find('origin') |
| xyz = origin.get('xyz', '0 0 0') if origin is not None else '0 0 0' |
| UsdPhysics.MassAPI(prim).CreateCenterOfMassAttr(Gf.Vec3f(*map(float, xyz.split()))) |
| fixed_packages = ('r1_7a_description', 'r1_a5_description', 'r1_a7_description', 'z1_description', 'z1_ros', 'dexterous_hand_description', 'UniArmL1', 'brainco_hand') |
| fixed_base = ident.split('/')[0] in fixed_packages or 'dual_arm' in ident or '/inspire_hand/' in str(source) |
| if not fixed_base: |
| root_joint = stage.GetDefaultPrim().GetPath().AppendPath('Physics/root_joint') |
| if stage.GetPrimAtPath(root_joint): stage.RemovePrim(root_joint) |
| stage.GetRootLayer().Save() |
| checks = validate_stage(path) |
| active_types = ('revolute', 'continuous', 'prismatic') |
| source_active = sum(j.get('type') in active_types for j in tree.findall('joint')) |
| usd_active = sum(p.IsA(UsdPhysics.RevoluteJoint) or p.IsA(UsdPhysics.PrismaticJoint) for p in stage.Traverse()) |
| if source_active != usd_active: |
| raise RuntimeError(f'Active joint loss: source={source_active}, USD={usd_active}') |
| source_mass = sum(float(n.get('value')) for n in tree.findall('link/inertial/mass')) |
| usd_mass = sum(UsdPhysics.MassAPI(p).GetMassAttr().Get() or 0 for p in stage.Traverse() if p.HasAPI(UsdPhysics.MassAPI)) |
| if abs(source_mass - usd_mass) > max(1e-5, source_mass * 1e-5): |
| raise RuntimeError(f'Mass mismatch: source={source_mass}, USD={usd_mass}') |
| checks.update({'source_active_joints': source_active, 'usd_active_joints': usd_active, |
| 'source_mass_kg': source_mass, 'usd_mass_kg': usd_mass}) |
| |
| for mesh in list(tree.iter('mesh')) + list(tree.iter('texture')): |
| if mesh.get('filename'): |
| mesh.set('filename', os.path.relpath(mesh.get('filename'), dest)) |
| ET.ElementTree(tree).write(str(dest / 'input.urdf'), encoding='utf-8', xml_declaration=True, pretty_print=True) |
| return {'id': ident, 'source': str(source.relative_to(OUT)), 'usd': str(path.relative_to(OUT)), |
| 'status': 'converted', 'fixed_base': fixed_base, 'normalizations': changes, |
| 'source_links': len(tree.findall('link')), 'source_joints': len(tree.findall('joint')), |
| 'validation': checks} |
|
|
| def validate_stage(path): |
| from pxr import Usd, UsdGeom, UsdPhysics, UsdUtils, Sdf |
| stage = Usd.Stage.Open(str(path)) |
| if not stage: raise RuntimeError('USD cannot be opened') |
| layers, assets, unresolved = UsdUtils.ComputeAllDependencies(str(path)) |
| if unresolved: raise RuntimeError('Unresolved USD dependencies: ' + repr(unresolved)) |
| meshes = bodies = colliders = joints = 0 |
| for p in stage.Traverse(): |
| if p.IsA(UsdGeom.Mesh): |
| m = UsdGeom.Mesh(p) |
| if not m.GetPointsAttr().Get() or not m.GetFaceVertexCountsAttr().Get(): raise RuntimeError('Empty mesh: '+str(p.GetPath())) |
| meshes += 1 |
| bodies += int(p.HasAPI(UsdPhysics.RigidBodyAPI)) |
| colliders += int(p.HasAPI(UsdPhysics.CollisionAPI)) |
| if p.IsA(UsdPhysics.Joint): |
| joints += 1 |
| j = UsdPhysics.Joint(p) |
| for target in j.GetBody0Rel().GetTargets() + j.GetBody1Rel().GetTargets(): |
| if not stage.GetPrimAtPath(target): raise RuntimeError('Dangling joint body: '+str(target)) |
| if p.HasAPI(UsdPhysics.RigidBodyAPI): |
| parent = p.GetParent() |
| while parent and not parent.IsPseudoRoot(): |
| if parent.HasAPI(UsdPhysics.RigidBodyAPI): raise RuntimeError('Nested rigid bodies: '+str(p.GetPath())) |
| parent = parent.GetParent() |
| if not meshes or not bodies or not joints: raise RuntimeError('Incomplete robot geometry or physics') |
| return {'usd_opens': True, 'unresolved_dependencies': 0, 'meshes': meshes, |
| 'rigid_bodies': bodies, 'colliders': colliders, 'joints': joints, |
| 'flat_rigid_body_hierarchy': True, 'isaac_sim_runtime_tested': False} |
|
|
| def run_job(job): |
| source, ident = job |
| logdir = ROOT / 'logs' |
| logdir.mkdir(exist_ok=True) |
| target = ROOT / 'results' / (ident.replace('/', '__') + '.json') |
| target.parent.mkdir(exist_ok=True) |
| with (logdir / (ident.replace('/', '__') + '.log')).open('w') as log: |
| result = subprocess.run([sys.executable, __file__, '--one', str(source), '--id', ident, '--result', str(target)], stdout=log, stderr=log) |
| if result.returncode: |
| data = {'id': ident, 'source': str(source.relative_to(OUT)), 'status': 'failed', |
| 'error': (logdir / (ident.replace('/', '__') + '.log')).read_text()[-4000:]} |
| target.write_text(json.dumps(data, indent=2)) |
| else: |
| data = json.loads(target.read_text()) |
| warnings = [line.split(' -- ', 1)[-1] for line in (logdir / (ident.replace('/', '__') + '.log')).read_text().splitlines() if line.startswith('Warning:')] |
| data['conversion_warnings'] = warnings |
| if any('Failed to convert mesh' in w for w in warnings): |
| data['status'] = 'failed' |
| data['error'] = 'Converter omitted source mesh geometry; see conversion_warnings.' |
| target.write_text(json.dumps(data, indent=2) + '\n') |
| print(data['status'], ident, flush=True) |
| return data |
|
|
| if __name__ == '__main__': |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--one') |
| parser.add_argument('--id') |
| parser.add_argument('--result') |
| parser.add_argument('--only-new', action='store_true', help='Preserve existing manifest entries and convert newly added source jobs only') |
| args = parser.parse_args() |
| if args.one: |
| result = convert_one(pathlib.Path(args.one), args.id) |
| pathlib.Path(args.result).write_text(json.dumps(result, indent=2) + '\n') |
| else: |
| previous = json.loads((OUT / 'manifest.json').read_text())['models'] if args.only_new else [] |
| existing = {m['id']: m for m in previous} |
| selected = [(p, ident) for p, ident in jobs() if ident not in existing] |
| with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool: |
| added = list(pool.map(run_job, selected)) |
| if any(m['status'] != 'converted' for m in added): |
| raise SystemExit('Conversion failed; existing manifest preserved. Inspect results and logs.') |
| existing.update({m['id']: m for m in added}) |
| results = [existing[ident] for _, ident in jobs()] |
| (OUT / 'manifest.json').write_text(json.dumps({'converter': 'urdf-usd-converter==0.3.4', |
| 'postprocessing': 'Flatten rigid bodies, preserve world transforms and joint relationships, explicitly author source centers of mass (including zero offsets), remove synthetic world fixation for mobile robots. No controller gain tuning.', |
| 'limitations_document': 'KNOWN_LIMITATIONS.md', |
| 'simulation_validation': {'isaac_sim_runtime_tested': False, 'closed_loop_mjcf_constraints_translated': False, 'physx_mimic_joints_authored': False}, |
| 'models': results}, indent=2) + '\n') |
| print('Converted', sum(x['status']=='converted' for x in results), 'of', len(results), flush=True) |
|
|
