# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # The import below fails when Isaac Sim is not installed or the search paths have # not been patched with `AppLauncher`. Wrap it so that utilities that do *not* # require the simulator (e.g. reading static information from a USD file) can # still be used in a plain Python environment. from pxr import Gf, Usd, UsdGeom, UsdPhysics, UsdShade try: import isaacsim.core.utils.stage as stage_utils # type: ignore except ImportError: # pragma: no cover -- running outside Isaac-Sim stage_utils = None # noqa: N816 – keep original style for clarity import copy import os from functools import lru_cache from pathlib import Path from typing import Any, Dict, List, Optional, Sequence, Tuple import numpy as np def create_str_attribute_to_prim(prim, attribute_name: str): """Creates attribute for a prim that holds a string. See: https://openusd.org/release/api/class_usd_prim.html See: https://docs.omniverse.nvidia.com/kit/docs/omni.usd/latest/omni.usd.commands/omni.usd.commands.CreateUsdAttributeCommand.html Args: prim (Usd.Prim): A Prim for holding the attribute. attribute_name (str): The name of the attribute to create. Returns: Usd.Attribute: An attribute created at specific prim. """ import omni from pxr import Sdf, Usd omni.kit.commands.execute( "CreateUsdAttributeCommand", prim=prim, attr_name=attribute_name, attr_type=Sdf.ValueTypeNames.String, ) attr: Usd.Attribute = prim.GetAttribute(attribute_name) return attr def set_str_attribute_to_prim(prim, name: str, value: str): attribute = create_str_attribute_to_prim(prim, attribute_name=name) attribute.Set(value) def get_root_prim_path(root_prim_path=None): """ Gets the root prim path. If root_prim_path is provided, use that; otherwise use the default prim. Args: root_prim_path (str, optional): Specific prim path to use. Defaults to None. Raises: ValueError: If neither root_prim_path nor default prim are available. ValueError: If the specified root_prim_path is not found. Returns: tuple: (root_prim, root_prim_path) - The prim object and its path """ import omni.usd stage = omni.usd.get_context().get_stage() root_prim = None if root_prim_path is not None: # Use provided root_prim_path root_prim = stage.GetPrimAtPath(root_prim_path) if not root_prim: raise ValueError(f"Root prim path {root_prim_path} not found.") print(f"Using provided prim path: {root_prim_path}") else: # Fall back to default prim root_prim = stage.GetDefaultPrim() if not root_prim: raise ValueError("No default prim found and no root_prim_path provided.") root_prim_path = str(root_prim.GetPath()) print(f"Using default prim: {root_prim_path}") return root_prim, root_prim_path def rename_prim(stage, old_path_str, new_path_str): from pxr import Sdf, Usd old_path = Sdf.Path(old_path_str) new_path = Sdf.Path(new_path_str) stage.GetEditTarget().GetLayer().ExportToString() # force sync if needed # Define the new prim at the new path old_prim = stage.GetPrimAtPath(old_path) if not old_prim.IsValid(): raise RuntimeError(f"Prim at {old_path} is not valid") # Use Sdf to copy prim spec (correct module and function) root_layer = stage.GetRootLayer() Sdf.CopySpec(root_layer, old_path, root_layer, new_path) # Remove the old prim stage.RemovePrim(old_path) print(f"Renamed prim from {old_path} to {new_path}") return stage.GetPrimAtPath(new_path) def rename_root_prim(new_path_str): """ Renames the root default prim. This function does not save the stage. Args: new_path_str (_type_): _description_ """ import omni.usd stage = omni.usd.get_context().get_stage() old_path_str = str(stage.GetDefaultPrim().GetPath()) rename_prim(stage, old_path_str, new_path_str) default_prim = stage.GetPrimAtPath(new_path_str) stage.SetDefaultPrim(default_prim) stage.GetRootLayer().Save() def get_attribute_by_name(prim: Usd.Prim, name: str) -> str: """Extract the first authored attribute found in the USD file.""" # Search default prim and its direct children for description in attributes search_prims = [prim] + list(prim.GetChildren()) for prim in search_prims: # 1) Attribute named "description" for attr in prim.GetAttributes(): if attr.GetName() == name: val = attr.Get() if val: return val # 2) Prim metadata "documentation" doc = prim.GetMetadata("description") if doc: return doc # 3) assetInfo[name] try: asset_desc = prim.GetAssetInfoByKey(name) except Exception: asset_desc = None if asset_desc: return asset_desc # 4) customData[name] try: custom_desc = prim.GetCustomDataByKey(name) except Exception: custom_desc = None if custom_desc: return custom_desc return "" def get_usd_rigid_body_info(usd_path: str) -> dict: """ Analyze a USD file containing a single object and extract rigid body information. Args: usd_path: Path to the USD file Returns: Dictionary containing rigid body and physics properties """ from robolab.core.utils.physics_utils import get_friction stage = Usd.Stage.Open(str(usd_path)) if not stage: raise ValueError(f"Failed to open stage: {usd_path}") default_prim = stage.GetDefaultPrim() if not default_prim: raise ValueError(f"No default prim found in: {usd_path}") # Size lower, upper = get_aabb(default_prim) dims = upper - lower size = [float(dims[i]) for i in range(3)] # Get description # attributes = default_prim.GetAttributes() # description = "" # if attributes: # for attr in attributes: # # Get the attribute name and its value at the default time # attribute_name = attr.GetName() # attribute_value = attr.Get() # if attribute_name == 'description': # description = attribute_value # break description = get_attribute_by_name(default_prim, "description") class_name = get_attribute_by_name(default_prim, "class") # Check if it's a rigid body rigid_body_api = UsdPhysics.RigidBodyAPI(default_prim) rigid_body = True if (rigid_body_api and rigid_body_api.GetRigidBodyEnabledAttr().Get()) else str(rigid_body_api) # Extract mass and density using MassAPI mass = None density = None mass_api = UsdPhysics.MassAPI(default_prim) if mass_api: mass_attr = mass_api.GetMassAttr() if mass_attr and mass_attr.IsValid(): mass = mass_attr.Get() density_attr = mass_api.GetDensityAttr() if density_attr and density_attr.IsValid(): density = density_attr.Get() # Extract friction and restitution using MaterialAPI friction_info = get_friction(default_prim, stage) dynamic_friction = friction_info['dynamic_friction'] if friction_info else None static_friction = friction_info['static_friction'] if friction_info else None restitution = friction_info['restitution'] if friction_info else None if density is None or density == 0: density = friction_info['density'] if friction_info else None # Get the world transformation matrix xform_cache = UsdGeom.XformCache(Usd.TimeCode.Default()) world_xform = xform_cache.GetLocalToWorldTransform(default_prim) # Extract translation (position) pos = world_xform.ExtractTranslation() # Extract rotation as a quaternion rot = world_xform.ExtractRotation().GetQuat() rot_quat = (rot.GetReal(), rot.GetImaginary()[0], rot.GetImaginary()[1], rot.GetImaginary()[2]) object_info = { 'name': default_prim.GetName(), 'usd_path': str(usd_path), 'prim_path': str(default_prim.GetPath()), 'position': (pos[0], pos[1], pos[2]), 'quat_wxyz': rot_quat, 'payload': get_prim_payload(default_prim, as_string=True), 'rigid_body': rigid_body, 'static_body': not rigid_body, 'class': class_name, 'description': description, 'dims': size, 'mass': mass, 'density': density, 'dynamic_friction': dynamic_friction, 'static_friction': static_friction, 'restitution': restitution, } return object_info @lru_cache(maxsize=256) def _get_usd_objects_info_cached(usd_path: str) -> tuple: """ Cached internal function to analyze a USD file and extract rigid bodies and static bodies. Returns a tuple of tuples (immutable) for caching compatibility. Args: usd_path: Path to the USD file Returns: Tuple of object info tuples (frozen for cache compatibility) """ from robolab.core.utils.usd_utils import get_prim_payload stage = Usd.Stage.Open(str(usd_path)) if not stage: raise ValueError(f"Failed to open stage: {usd_path}") default_prim = stage.GetDefaultPrim() if not default_prim: raise ValueError(f"No default prim found in: {usd_path}") scene_objects = [] # Get all children of the default prim children = default_prim.GetChildren() for child in children: name = child.GetName() attributes = child.GetAttributes() description = "" if attributes: for attr in attributes: # Get the attribute name and its value at the default time attribute_name = attr.GetName() attribute_value = attr.Get() if attribute_name == 'description': description = attribute_value break # Check if it's a rigid body rigid_body_api = UsdPhysics.RigidBodyAPI(child) rigid_body = rigid_body_api and rigid_body_api.GetRigidBodyEnabledAttr().Get() # Check if kinematic is_kinematic = False if rigid_body: kinematic_attr = child.GetAttribute('physics:kinematicEnabled') if kinematic_attr and kinematic_attr.Get(): is_kinematic = True # Get the world transformation matrix xform_cache = UsdGeom.XformCache(Usd.TimeCode.Default()) world_xform = xform_cache.GetLocalToWorldTransform(child) # Extract translation (position) pos = world_xform.ExtractTranslation() # Extract rotation as a quaternion. # ExtractRotation() assumes orthonormal columns and produces wrong # results when the matrix contains scale (e.g. scale=0.4). We strip # scale by normalizing the 3x3 column vectors first. rot_mat = world_xform.ExtractRotationMatrix() col0 = Gf.Vec3d(rot_mat[0][0], rot_mat[1][0], rot_mat[2][0]) col1 = Gf.Vec3d(rot_mat[0][1], rot_mat[1][1], rot_mat[2][1]) col2 = Gf.Vec3d(rot_mat[0][2], rot_mat[1][2], rot_mat[2][2]) sx, sy, sz = col0.GetLength(), col1.GetLength(), col2.GetLength() if sx > 1e-9 and sy > 1e-9 and sz > 1e-9: norm_mat = Gf.Matrix3d( col0[0]/sx, col1[0]/sy, col2[0]/sz, col0[1]/sx, col1[1]/sy, col2[1]/sz, col0[2]/sx, col1[2]/sy, col2[2]/sz, ) rot = norm_mat.ExtractRotation().GetQuat() else: rot = Gf.Quatd(1, 0, 0, 0) rot_quat = (rot.GetReal(), rot.GetImaginary()[0], rot.GetImaginary()[1], rot.GetImaginary()[2]) object_info = { 'name': name, 'prim_path': str(child.GetPath()), 'position': (pos[0], pos[1], pos[2]), 'rotation': rot_quat, 'payload': get_prim_payload(child, as_string=True), 'rigid_body': rigid_body, 'kinematic': is_kinematic, 'static_body': not rigid_body, "description": description, } scene_objects.append(object_info) # Convert to tuple of frozen dicts for cache compatibility return tuple(tuple(sorted(obj.items())) for obj in scene_objects) def get_usd_objects_info(usd_path: str) -> list: """ Analyze a USD file and extract rigid bodies and static bodies. Results are cached internally to avoid re-parsing the same USD file. Args: usd_path: Path to the USD file Returns: List of dictionaries containing rigid bodies and static bodies with their properties """ # Get cached result (tuple of tuples) and convert back to list of dicts cached_result = _get_usd_objects_info_cached(usd_path) return [dict(obj_tuple) for obj_tuple in cached_result] def clear_usd_cache(): """Clear the USD objects info cache. Call this if USD files have been modified.""" _get_usd_objects_info_cached.cache_clear() def np_to_gf_vec3d(pos: np.ndarray | list) -> Gf.Vec3d: return Gf.Vec3d(float(pos[0]), float(pos[1]), float(pos[2])) def np_to_gf_quatf(quat: np.ndarray | list, scalar_first=False) -> Gf.Quatf: # Gf.Quatf expects (real, imag) if scalar_first: return Gf.Quatf(float(quat[0]), Gf.Vec3f(float(quat[1]), float(quat[2]), float(quat[3]))) else: return Gf.Quatf(float(quat[3]), Gf.Vec3f(float(quat[0]), float(quat[1]), float(quat[2]))) def translation_only_matrix(matrix: Gf.Matrix4d) -> Gf.Matrix4d: # Extract translation translation = matrix.ExtractTranslation() # Create identity matrix no_rot_matrix = Gf.Matrix4d(1.0) # Set translation no_rot_matrix.SetTranslate(translation) return no_rot_matrix def get_prim_at_path(prim_path: str) -> Usd.Prim: # noqa: N802 – keep API unchanged """Return the *Usd.Prim* located at *prim_path* on the current Isaac stage. This helper needs Isaac-Sim (``stage_utils``). If the simulator has not been started yet, a helpful *ImportError* is raised instead of letting a bare ``AttributeError`` escape. """ if stage_utils is None: raise ImportError( "get_prim_at_path requires Isaac-Sim; start it with AppLauncher or " "ensure isaacsim python paths are on PYTHONPATH before calling this " "function." ) stage = stage_utils.get_current_stage() prim = stage.GetPrimAtPath(prim_path) if not prim.IsValid(): raise ValueError(f"Prim at path '{prim_path}' is not valid.") def get_attribute_names(prim: Usd.Prim) -> List[str]: """Get the attribute names for a prim.""" return [attribute.GetName() for attribute in prim.GetAttributes()] def get_attribute(prim: Usd.Prim, attribute_name: str) -> Optional[Usd.Attribute]: """Get an attribute if it exists.""" attribute = prim.GetAttribute(attribute_name) if not attribute.IsValid(): return None return attribute def get_scale(prim: Usd.Prim) -> Gf.Vec3d: """ Get the scale parameter applied to a Usd.Prim. This function tries multiple approaches to get the scale: 1. Directly from the 'xformOp:scale' attribute if it exists 2. From the transform matrix using ExtractScale() method 3. Returns (1, 1, 1) as default if no scale is found Args: prim: The Usd.Prim to get scale from Returns: Gf.Vec3d: The scale vector (x, y, z) """ # First try to get scale directly from xformOp:scale attribute scale_attr = get_attribute(prim, "xformOp:scale") if scale_attr and scale_attr.IsValid(): scale_value = scale_attr.Get() if scale_value is not None: # Convert to Gf.Vec3d if it's not already if isinstance(scale_value, (list, tuple)): return Gf.Vec3d(*scale_value) elif hasattr(scale_value, '__len__') and len(scale_value) == 3: return Gf.Vec3d(scale_value[0], scale_value[1], scale_value[2]) else: return Gf.Vec3d(scale_value, scale_value, scale_value) # Default scale if nothing else works return Gf.Vec3d(1.0, 1.0, 1.0) def get_descendant_prims(prim: Usd.Prim): """Get the descendants of a prim using a preorder traversal.""" yield from prim.GetChildren() for child_prim in prim.GetChildren(): yield from get_descendant_prims(child_prim) def get_dimensions(body_prim: Usd.Prim) -> np.ndarray: """ Calculate the dimensions (width, height, depth) of a USD prim's bounding box. This function computes the size of the axis-aligned bounding box that encompasses all geometry within the prim and its descendants. Args: body_prim (Usd.Prim): The USD prim to analyze Returns: np.ndarray: The dimensions [width, height, depth] corresponding to [x_size, y_size, z_size], shape (3,) Example: >>> prim = stage.GetPrimAtPath("/World/Cube") >>> dims = get_dimensions(prim) >>> print(f"Dimensions: {dims}") # e.g., [2.0, 2.0, 2.0] for 2x2x2 cube """ # prim_helper.export_geometry_as_obj_file time_code = Usd.TimeCode.Default() bbox_cache = UsdGeom.BBoxCache(time_code, includedPurposes=[UsdGeom.Tokens.default_]) bbox_cache.Clear() body_range = Gf.Range3d() for prim in get_descendant_prims(body_prim): # prim_bbox = bbox_cache.ComputeUntransformedBound(body_prim) # ComputeLocalBound prim_bbox = bbox_cache.ComputeRelativeBound(prim, body_prim) prim_range = prim_bbox.ComputeAlignedRange() body_range.UnionWith(prim_range) return np.array(body_range.GetSize()) def get_bbox(body_prim: Usd.Prim, pos=None, quat=None, scalar_first=False): """ Compute the oriented bounding box (OBB) for a USD prim with optional transform. This function calculates the 8 corner points of the bounding box around the prim's geometry, applies scaling and transformations, and optionally applies an additional user-specified transform (useful for placing the bbox at a specific pose). Computation steps: 1. Compute the local bounding box via UsdGeom.BBoxCache 2. Extract the 8 corners from the bounding range + local matrix 3. Compute the centroid via ComputeCentroid() 4. Transform corners and centroid to origin (inverse world transform) 5. Apply prim scale to both corners and centroid 6. Optionally apply a user-supplied rotation + translation Args: body_prim (Usd.Prim): The USD prim to compute bounding box for pos (array-like, optional): Additional translation [x, y, z] to apply. Can be np.ndarray, list, or None. quat (array-like, optional): Additional rotation quaternion to apply. Can be np.ndarray, list, or None. scalar_first (bool): If True, quaternion is in [w, x, y, z] format. If False, quaternion is in [x, y, z, w] format. Returns: tuple[list, Gf.Vec3d]: A tuple containing: - corners (list): List of 8 Gf.Vec3d points representing the bounding box corners. The corners are ordered as: [0-3]: bottom face corners, [4-7]: top face corners - centroid (Gf.Vec3d): The center point of the bounding box Example: >>> prim = stage.GetPrimAtPath("/World/Cube") >>> corners, centroid = get_bbox(prim) >>> print(f"8 corners: {len(corners)}") >>> print(f"Centroid: [{centroid[0]:.2f}, {centroid[1]:.2f}, {centroid[2]:.2f}]") >>> >>> # With additional transform >>> pos = [1.0, 2.0, 3.0] >>> quat = [0.0, 0.0, 0.0, 1.0] # no rotation >>> corners, centroid = get_bbox(prim, pos, quat, scalar_first=False) """ time_code = Usd.TimeCode.Default() bbox_cache = UsdGeom.BBoxCache(time_code, includedPurposes=[UsdGeom.Tokens.default_]) bbox_cache.Clear() # Use ComputeWorldBound so corners/centroid are in world space. # Applying world_xform.GetInverse() to world-space data correctly yields # prim-local coordinates. ComputeLocalBound returns parent-frame data, which # produces wrong results in multi-env where env_origins != (0,0,0). prim_bbox = bbox_cache.ComputeWorldBound(body_prim) # Get corners and centroid (now in world space) range3d = prim_bbox.GetRange() matrix = prim_bbox.GetMatrix() corners = [matrix.Transform(range3d.GetCorner(i)) for i in range(8)] centroid = prim_bbox.ComputeCentroid() # GfVec3d [1][2] # Transform to prim-local frame using the inverse of the prim's world transform xform_cache = UsdGeom.XformCache(time_code) world_xform = xform_cache.GetLocalToWorldTransform(body_prim) # Gf.Matrix4d[2][3] transform = world_xform.GetInverse() transformed_corners = [transform.Transform(corner) for corner in corners] transformed_centroid = transform.Transform(centroid) scale = get_scale(body_prim) if scale is not Gf.Vec3d(1.0, 1.0, 1.0): # Scale corners directly scaled_corners = [] for corner in transformed_corners: # Scale each corner directly scaled_corner = Gf.Vec3d( corner[0] * scale[0], corner[1] * scale[1], corner[2] * scale[2] ) scaled_corners.append(scaled_corner) transformed_corners = scaled_corners # Scale centroid to match corners. The centroid from ComputeCentroid() # is in the prim's local space, and after inverse-world-transform it # still carries the original mesh magnitude. For non-unit-scale prims # (e.g., apple_01 at scale=0.01), the centroid must be multiplied by # the same scale factors applied to the corners, otherwise spatial # predicates (inside, above_top, center_of, etc.) receive a centroid # that is orders of magnitude off from the actual scaled geometry. transformed_centroid = Gf.Vec3d( transformed_centroid[0] * scale[0], transformed_centroid[1] * scale[1], transformed_centroid[2] * scale[2], ) # User-supplied transform, if any if quat is not None and pos is not None: if isinstance(pos, np.ndarray) or isinstance(pos, list): pos = np_to_gf_vec3d(pos) if isinstance(quat, np.ndarray) or isinstance(quat, list): quat = np_to_gf_quatf(quat, scalar_first) additional_transform = Gf.Matrix4d().SetRotateOnly(quat) additional_transform.SetTranslateOnly(pos) else: # No additional transform return transformed_corners, transformed_centroid # Apply additional transform new_corners = [additional_transform.Transform(corner) for corner in transformed_corners] new_centroid = additional_transform.Transform(transformed_centroid) return new_corners, new_centroid # return transformed_corners, transformed_centroid def get_aabb(body_prim: Usd.Prim) -> Tuple[np.ndarray, np.ndarray]: """ Compute the Axis-Aligned Bounding Box (AABB) for a USD prim in local coordinates. The AABB is the smallest box aligned with the coordinate axes that completely contains the prim's geometry. This function returns the minimum and maximum corner coordinates of this box. Args: body_prim (Usd.Prim): The USD prim to compute AABB for Returns: Tuple[np.ndarray, np.ndarray]: A tuple containing: - lower (np.ndarray): Minimum corner coordinates [x_min, y_min, z_min], shape (3,) - upper (np.ndarray): Maximum corner coordinates [x_max, y_max, z_max], shape (3,) Example: >>> prim = stage.GetPrimAtPath("/World/Cube") >>> lower, upper = get_aabb(prim) >>> print(f"Lower corner: {lower}") # e.g., [-1.0, -1.0, -1.0] >>> print(f"Upper corner: {upper}") # e.g., [1.0, 1.0, 1.0] >>> size = upper - lower # [2.0, 2.0, 2.0] for 2x2x2 cube >>> center = (lower + upper) / 2 # [0.0, 0.0, 0.0] geometric center Note: This computes the bounding box in the prim's local coordinate system, not in world coordinates. For world-coordinate bounding boxes, use get_bbox() with appropriate transforms. """ time_code = Usd.TimeCode.Default() bbox_cache = UsdGeom.BBoxCache(time_code, includedPurposes=[UsdGeom.Tokens.default_]) bbox_cache.Clear() prim_bbox = bbox_cache.ComputeLocalBound(body_prim) prim_range = prim_bbox.ComputeAlignedRange() lower = np.array(prim_range.GetMin()) upper = np.array(prim_range.GetMax()) aabb = (lower, upper) return aabb def get_scene_payloads(usd_path: str) -> dict[str, list[str]]: """ Generate a dc Args: usd_path (str): _description_ Raises: ValueError: _description_ Returns: dict[str, list[str]]: _description_ """ stage = Usd.Stage.Open(str(usd_path)) if not stage: raise ValueError(f"Failed to open stage: {usd_path}") # Get the root prim (e.g., '/World') root = stage.GetDefaultPrim() if not root: root = stage.GetPseudoRoot() payload_dict = {} # Iterate over first-level children for child in root.GetChildren(): # Check if this is an Xform prim if child.GetTypeName() == "Xform": prim_path = str(child.GetPath()) payload_list = get_prim_payload(child, as_string=True) payload_dict[prim_path] = payload_list return payload_dict def get_prim_payload(prim: Usd.Prim, as_string=True) -> list: """Get the payload of a prim.""" payload_list = [] # Get payloads by inspecting the prim stack for primSpec in prim.GetPrimStack(): payloads = primSpec.payloadList.prependedItems if as_string: payload_list.extend([payload.assetPath for payload in payloads]) else: payload_list.extend(payloads) return payload_list