Reference/API

Robot

class[source]
robokit.robo.Robot(
spec: RobotSpec
)

Robot model backed by Warp.

Examples

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> q = wp.from_numpy(np.array([0.0, -1.2, 0.0, -2.0, 0.0, 1.0, 0.0, 0.0]), dtype=wp.float32)
>>> state = robot.state(q=q)
>>> state = robot.forward_kinematics(state)
>>> hand_idx = robot.spec.link_names.index("panda_hand")
>>> link_pose = state.T_world_link[:, hand_idx]
>>> expected = np.array([6.0860e-02, -4.7547e-12, 7.6373e-01, 0.0382, 0.9193, 0.3808, 0.0922], dtype=np.float32)
>>> expected = wp.from_numpy(expected, dtype=wp_vec7)
>>> np.allclose(se3_to_matrix(link_pose).numpy(), se3_to_matrix(expected).numpy(), atol=1e-4)
True
Parameters
specRobotSpecrequired
Members
attribute[source]
Robot.spec: RobotSpec
method[source]
Robot.load(
robot_description_or_path: Union[str, Path, yourdfpy.URDF],
load_meshes: bool = False,
mesh_dir: Optional[Union[str, Path]] = None,
load_collision_spheres: bool = False,
collision_spheres_path: Optional[Union[str, Path]] = None,
base_link_name: Optional[str] = None,
ee_link_names: Optional[Union[Sequence[str], str]] = None,
self_collision_ignore_path: Optional[Union[str, Path]] = None
) -> Robot

Load a robot model from a URDF/MJCF path, description string, or parsed yourdfpy.URDF.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> robot.spec.num_actuated_joints
8
Parameters
robot_description_or_pathUnion[str, Path, yourdfpy.URDF]required

URDF/MJCF file path, description string, or already-parsed yourdfpy.URDF.

load_meshesbool= False

Load link visual/collision meshes.

mesh_dirOptional[Union[str, Path]]= None

Directory to resolve mesh files against.

load_collision_spheresbool= False

Load collision spheres from collision_spheres_path.

collision_spheres_pathOptional[Union[str, Path]]= None

YAML file with per-link collision spheres and optional self_collision_link_buffers.

base_link_nameOptional[str]= None

Base link; defaults to the URDF root.

ee_link_namesOptional[Union[Sequence[str], str]]= None

End-effector link name(s).

self_collision_ignore_pathOptional[Union[str, Path]]= None

YAML file with link pairs self-collision terms skip.

Returns
Robot

The loaded robot model.

method[source]
Robot.state(
q: Optional[Union[wp.array, np.ndarray]] = None,
T_world_base: Optional[wp.array] = None
) -> RobotState

Build a robot state for the given joint positions (defaults to zero_q).

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> robot.state().q.shape
(1, 8)
Parameters
qOptional[Union[wp.array, np.ndarray]]= None
T_world_baseOptional[wp.array]= None
Returns
RobotState
method[source]
Robot.forward_kinematics(
state: RobotState,
use_sequential: Optional[bool] = None
) -> RobotState

Compute forward kinematics for given joint positions; returns a state with all link transforms.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> q = wp.from_numpy(np.array([0.0, -1.2, 0.0, -2.0, 0.0, 1.0, 0.0, 0.0]), dtype=wp.float32)
>>> state = robot.state(q=q)
>>> state = robot.forward_kinematics(state)
>>> hand_idx = robot.spec.link_names.index("panda_hand")
>>> link_pose = state.T_world_link[:, hand_idx]
>>> expected = np.array([6.0860e-02, -4.7547e-12, 7.6373e-01, 0.0382, 0.9193, 0.3808, 0.0922], dtype=np.float32)
>>> expected = wp.from_numpy(expected, dtype=wp_vec7)
>>> np.allclose(se3_to_matrix(link_pose).numpy(), se3_to_matrix(expected).numpy(), atol=1e-4)
True
>>> T_world_base = wp.from_numpy(np.array([1.0, 2.0, 3.0, 0.7071, 0.0, 0.7071, 0.0]), dtype=wp_vec7)
>>> state = robot.state(q=q, T_world_base=T_world_base)
>>> state = robot.forward_kinematics(state)
>>> link_pose = state.T_world_link[:, hand_idx]
>>> expected = np.array([1.76371783, 2.0, 2.93915576, -0.24222432, 0.71524162, 0.29626278, -0.58478125], dtype=np.float32)
>>> expected = wp.from_numpy(expected, dtype=wp_vec7)
>>> np.allclose(se3_to_matrix(link_pose).numpy(), se3_to_matrix(expected).numpy(), atol=1e-4)
True
Parameters
stateRobotStaterequired
use_sequentialOptional[bool]= None
Returns
RobotState
method[source]
Robot.forward_kinematics_via_matrix_numpy(
q: Float[np.ndarray, '... num_dofs'],
T_world_base: Optional[Float[np.ndarray, '... 4 4']] = None,
device: Optional[str] = None
) -> Float[np.ndarray, '... num_links 4 4']

Compute forward kinematics as 4x4 matrices for NumPy arrays, without an autograd round trip.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> q = np.zeros((1, robot.spec.num_actuated_joints), dtype=np.float32)
>>> robot.forward_kinematics_via_matrix_numpy(q).shape
(1, 13, 4, 4)
Parameters
qFloat[np.ndarray, '... num_dofs']required
T_world_baseOptional[Float[np.ndarray, '... 4 4']]= None
deviceOptional[str]= None
Returns
Float[np.ndarray, '... num_links 4 4']
method[source]
Robot.forward_kinematics_numpy(
q: Float[np.ndarray, '... num_dofs'],
T_world_base: Optional[Float[np.ndarray, '... 7']] = None,
device: Optional[str] = None
) -> Float[np.ndarray, '... num_links 7']

Compute world link poses as translation-first 7D poses for NumPy arrays.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> q = np.zeros((1, robot.spec.num_actuated_joints), dtype=np.float32)
>>> robot.forward_kinematics_numpy(q).shape
(1, 13, 7)
Parameters
qFloat[np.ndarray, '... num_dofs']required
T_world_baseOptional[Float[np.ndarray, '... 7']]= None
deviceOptional[str]= None
Returns
Float[np.ndarray, '... num_links 7']
method[source]
Robot.compute_center_of_mass_numpy(
q: Float[np.ndarray, '... num_dofs'],
T_world_base: Optional[Float[np.ndarray, '... 7']] = None,
device: Optional[str] = None
) -> Float[np.ndarray, '... 3']

Compute the whole-body center of mass in world frame for NumPy arrays.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> q = np.zeros((1, robot.spec.num_actuated_joints), dtype=np.float32)
>>> np.allclose(robot.compute_center_of_mass_numpy(q)[0], [0.0232, 0.0061, 0.6062], atol=1e-4)
True
Parameters
qFloat[np.ndarray, '... num_dofs']required
T_world_baseOptional[Float[np.ndarray, '... 7']]= None
deviceOptional[str]= None
Returns
Float[np.ndarray, '... 3']
method[source]
Robot.compute_motion_subspace(
state: RobotState
) -> RobotState

Store robot joint Jacobians in state for state.get_link_jacobian().

Base layouts:

  • Fixed base: joint columns only.
  • Floating base: prepend J_base, giving shape [batch, 6, 6 + num_dofs].

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> T_world_base = wp.from_numpy(np.array([1.0, 2.0, 3.0, 0.7071, 0.0, 0.7071, 0.0]), dtype=wp_vec7)
>>> q = wp.from_numpy(np.array([0.0, -1.2, 0.0, -2.0, 0.0, 1.0, 0.0, 0.0]), dtype=wp.float32)
>>> state = robot.state(q=q, T_world_base=T_world_base)
>>> state = robot.compute_motion_subspace(state)
>>> J = state.get_link_jacobian(robot.spec.link_names.index("panda_hand"), "body")
>>> np.allclose(J.numpy()[0, 0, :6], np.array([0.693, 0.7071, 0.1405, -0.54, 0.5207, 0.043], dtype=np.float32), atol=1e-4)
True
>>> J = state.get_link_jacobian(robot.spec.link_names.index("panda_hand"), "spatial")
>>> np.allclose(J.numpy()[0, 0, 6:], np.array([0.0001, -3., 1.8641, 3.2647, -1.4346, 3.0467, -0.3974, 0.], dtype=np.float32), atol=1e-3)
True
>>> np.allclose(J.numpy()[0, 0, :6], np.array([0.0001, 0., 1., -2., -3., 0.0001], dtype=np.float32), atol=1e-3)
True
Parameters
stateRobotStaterequired
Returns
RobotState
method[source]
Robot.compute_center_of_mass(
state: RobotState
) -> RobotState

Compute the whole-body center of mass in world frame into state.com_world.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> state = robot.compute_center_of_mass(robot.state())
>>> np.allclose(state.com_world.numpy()[0], [0.0232, 0.0061, 0.6062], atol=1e-4)
True
Parameters
stateRobotStaterequired
Returns
RobotState
method[source]
Robot.transform_collision_spheres(
state: RobotState
) -> RobotState

Compute the collision sphere centers in world frame.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> state = robot.state()
>>> robot.transform_collision_spheres(state) is state  # no collision spheres loaded
True
Parameters
stateRobotStaterequired

The robot state.

Returns
RobotState

The robot state with updated collision sphere centers.

method[source]
Robot.transform_collision_capsules(
state: RobotState
) -> RobotState

Compute the per-link capsule segment endpoints (a, b) in world frame.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> state = robot.state()
>>> robot.transform_collision_capsules(state) is state  # no link capsules loaded
True
Parameters
stateRobotStaterequired
Returns
RobotState
method[source]
Robot.forward_kinematics_via_matrix_torch(
q: Float[torch.Tensor, '... num_dofs'],
T_world_base: Optional[Float[torch.Tensor, '... 4 4']] = None,
analytical_backward: bool = True,
record_cmd: bool = False
) -> Float[torch.Tensor, '... num_links 4 4']

Compute differentiable forward kinematics as 4x4 matrices for torch tensors.

Example

python
>>> import torch
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> T_world_link = robot.forward_kinematics_via_matrix_torch(torch.zeros(robot.spec.num_actuated_joints))
>>> T_world_link.shape
torch.Size([13, 4, 4])
Parameters
qFloat[torch.Tensor, '... num_dofs']required
T_world_baseOptional[Float[torch.Tensor, '... 4 4']]= None
analytical_backwardbool= True
record_cmdbool= False
Returns
Float[torch.Tensor, '... num_links 4 4']
method[source]
Robot.transform_link_points_torch(
T_world_link: Float[torch.Tensor, '... num_links 4 4'],
local_points: Float[torch.Tensor, 'num_points 3'],
point_link_indices: Float[torch.Tensor, 'num_points']
) -> Float[torch.Tensor, '... num_points 3']

Transform local points attached to links to world frame.

Example

python
>>> import torch
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> T_world_link = robot.forward_kinematics_via_matrix_torch(torch.zeros(robot.spec.num_actuated_joints))
>>> points = robot.transform_link_points_torch(T_world_link, torch.zeros(2, 3), torch.tensor([0, 1]))
>>> points.shape
torch.Size([2, 3])
Parameters
T_world_linkFloat[torch.Tensor, '... num_links 4 4']required

Link transforms in world frame [..., num_links, 4, 4]

local_pointsFloat[torch.Tensor, 'num_points 3']required

Local points in link frames [num_points, 3]

point_link_indicesFloat[torch.Tensor, 'num_points']required

Link index for each point [num_points]

Returns
Float[torch.Tensor, '... num_points 3']

World-frame points [..., num_points, 3]

method[source]
Robot.map_to_full_joint_values_torch(
actuated_values: Float[torch.Tensor, '... num_actuated_joints']
) -> Float[torch.Tensor, '... num_joints']

Expand actuated joint values to all joints (mimic joints follow their controlling joint).

Example

python
>>> import torch
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> robot.map_to_full_joint_values_torch(torch.zeros(robot.spec.num_actuated_joints)).shape
torch.Size([12])
Parameters
actuated_valuesFloat[torch.Tensor, '... num_actuated_joints']required
Returns
Float[torch.Tensor, '... num_joints']
property[source]
Robot.zero_q: wp.array
property[source]
Robot.midrange_q: wp.array
property[source]
Robot.num_actuated_joints: int
property[source]
Robot.link_names: List[str]
method[source]
Robot.sample_q(
num_samples: int = 1,
rng: Optional[np.random.Generator] = None,
device: wp_device_type = None
) -> wp.array

Sample joint positions uniformly within the actuated joint limits.

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> robot = Robot.load(load_robot_description("panda_description"))
>>> robot.sample_q(num_samples=3, rng=np.random.default_rng(0)).shape
(3, 8)
Parameters
num_samplesint= 1
rngOptional[np.random.Generator]= None
devicewp_device_type= None
Returns
wp.array
class[source]
robokit.robo.RobotSpec(
name: str,
robot_description: str,
format: Literal['urdf', 'mjcf'],
joint_names: List[str],
nonfixed_joint_names: List[str],
actuated_joint_names: List[str],
joint_types: Int[np.ndarray, num_joints],
joint_axes: Float[np.ndarray, 'num_joints 3'],
joint_twists: Float[np.ndarray, 'num_joints 6'],
actuated_joint_indices: Int[np.ndarray, num_joints],
parent_joint_indices: Int[np.ndarray, num_joints],
parent_joint_transforms: Float[np.ndarray, 'num_joints 7'],
mimic_actuated_joint_indices: Int[np.ndarray, num_joints],
mimic_multipliers: Float[np.ndarray, num_joints],
mimic_offsets: Float[np.ndarray, num_joints],
joint_limits: Float[np.ndarray, 'num_joints 2'],
joint_velocity_limits: Float[np.ndarray, num_joints],
actuated_joint_limits: Float[np.ndarray, 'num_actuated_joints 2'],
actuated_joint_velocity_limits: Float[np.ndarray, num_actuated_joints],
link_names: List[str],
link_parent_joint_indices: Int[np.ndarray, num_links],
base_link_name: str,
ee_link_names: List[str],
link_visual_geometries: Dict[str, trimesh.Scene],
link_collision_geometries: Dict[str, trimesh.Scene],
local_collision_sphere_centers: Float[np.ndarray, 'num_collision_spheres 3'],
collision_sphere_radii: Float[np.ndarray, num_collision_spheres],
collision_spheres_link_indices: Int[np.ndarray, num_collision_spheres],
self_collision_ignored_pairs: Int[np.ndarray, 'num_ignored_pairs 2'],
link_masses: Float[np.ndarray, num_links],
link_local_com_positions: Float[np.ndarray, 'num_links 3'],
loaded_link_capsule_endpoints: Optional[Float[np.ndarray, 'num_links 2 3']] = None,
loaded_link_capsule_radii: Optional[Float[np.ndarray, num_links]] = None,
self_collision_link_buffers: Dict[str, float] = dict()
)

Robot specification.

Examples

python
>>> spec = RobotSpec.parse("tests/fixtures/wx250s.urdf")
>>> spec.num_actuated_joints
8
>>> spec.num_links
14
Parameters
namestrrequired
robot_descriptionstrrequired
formatLiteral['urdf', 'mjcf']required
joint_namesList[str]required
nonfixed_joint_namesList[str]required
actuated_joint_namesList[str]required
joint_typesInt[np.ndarray, num_joints]required
joint_axesFloat[np.ndarray, 'num_joints 3']required
joint_twistsFloat[np.ndarray, 'num_joints 6']required
actuated_joint_indicesInt[np.ndarray, num_joints]required
parent_joint_indicesInt[np.ndarray, num_joints]required
parent_joint_transformsFloat[np.ndarray, 'num_joints 7']required
mimic_actuated_joint_indicesInt[np.ndarray, num_joints]required
mimic_multipliersFloat[np.ndarray, num_joints]required
mimic_offsetsFloat[np.ndarray, num_joints]required
joint_limitsFloat[np.ndarray, 'num_joints 2']required
joint_velocity_limitsFloat[np.ndarray, num_joints]required
actuated_joint_limitsFloat[np.ndarray, 'num_actuated_joints 2']required
actuated_joint_velocity_limitsFloat[np.ndarray, num_actuated_joints]required
link_namesList[str]required
link_parent_joint_indicesInt[np.ndarray, num_links]required
base_link_namestrrequired
ee_link_namesList[str]required
link_visual_geometriesDict[str, trimesh.Scene]required
link_collision_geometriesDict[str, trimesh.Scene]required
local_collision_sphere_centersFloat[np.ndarray, 'num_collision_spheres 3']required
collision_sphere_radiiFloat[np.ndarray, num_collision_spheres]required
collision_spheres_link_indicesInt[np.ndarray, num_collision_spheres]required
self_collision_ignored_pairsInt[np.ndarray, 'num_ignored_pairs 2']required
link_massesFloat[np.ndarray, num_links]required
link_local_com_positionsFloat[np.ndarray, 'num_links 3']required
loaded_link_capsule_endpointsOptional[Float[np.ndarray, 'num_links 2 3']]= None
loaded_link_capsule_radiiOptional[Float[np.ndarray, num_links]]= None
self_collision_link_buffersDict[str, float]= dict()
Members
attribute[source]
RobotSpec.name: str

Name of the robot.

attribute[source]
RobotSpec.robot_description: str

Robot description

attribute[source]
RobotSpec.format: Literal['urdf', 'mjcf']

Format of the robot description.

attribute[source]
RobotSpec.joint_names: List[str]

Names of all joints, including actuated, mimic and fixed joints.

attribute[source]
RobotSpec.nonfixed_joint_names: List[str]

Names of non-fixed joints, including actuated and mimic joints.

attribute[source]
RobotSpec.actuated_joint_names: List[str]

Names of actuated joints.

attribute[source]
RobotSpec.joint_types: Int[np.ndarray, num_joints]

Types of all joints, see JointType.

attribute[source]
RobotSpec.joint_axes: Float[np.ndarray, 'num_joints 3']

Axes of all joints, [x, y, z].

attribute[source]
RobotSpec.joint_twists: Float[np.ndarray, 'num_joints 6']

Twists of all joints, [linear (x, y, z), angular (x, y, z)].

attribute[source]
RobotSpec.actuated_joint_indices: Int[np.ndarray, num_joints]

Indices of actuated joints, -1 for mimic and non-actuated joints.

attribute[source]
RobotSpec.parent_joint_indices: Int[np.ndarray, num_joints]

Indices of parent joints, -1 for joints attached to the base link.

attribute[source]
RobotSpec.parent_joint_transforms: Float[np.ndarray, 'num_joints 7']

Transforms of parent joints, [pos (x, y, z), quat (w, x, y, z)].

attribute[source]
RobotSpec.mimic_actuated_joint_indices: Int[np.ndarray, num_joints]

Indices of mimicked actuated joints, -1 for non-mimic joints.

attribute[source]
RobotSpec.mimic_multipliers: Float[np.ndarray, num_joints]

Multipliers of mimicked actuated joints, 1.0 for non-mimic joints.

attribute[source]
RobotSpec.mimic_offsets: Float[np.ndarray, num_joints]

Offsets of mimicked actuated joints, 0.0 for non-mimic joints.

attribute[source]
RobotSpec.joint_limits: Float[np.ndarray, 'num_joints 2']

Limits of all joints, [lower, upper].

attribute[source]
RobotSpec.joint_velocity_limits: Float[np.ndarray, num_joints]

Velocity limits of all joints.

attribute[source]
RobotSpec.actuated_joint_limits: Float[np.ndarray, 'num_actuated_joints 2']

Limits of actuated joints, [lower, upper].

attribute[source]
RobotSpec.actuated_joint_velocity_limits: Float[np.ndarray, num_actuated_joints]

Velocity limits of actuated joints.

attribute[source]
RobotSpec.link_names: List[str]

Names of all links.

attribute[source]
RobotSpec.link_parent_joint_indices: Int[np.ndarray, num_links]

Indices of parent joints of all links, -1 for the base link.

attribute[source]
RobotSpec.base_link_name: str

Base link name (root of the parsed kinematic tree).

attribute[source]
RobotSpec.ee_link_names: List[str]

End-effector (leaf) link names of the parsed kinematic tree.

attribute[source]
RobotSpec.link_visual_geometries: Dict[str, trimesh.Scene]

Visual geometries of all links.

attribute[source]
RobotSpec.link_collision_geometries: Dict[str, trimesh.Scene]

Collision geometries of all links.

attribute[source]
RobotSpec.local_collision_sphere_centers: Float[np.ndarray, 'num_collision_spheres 3']

Collision sphere centers in link-local coordinates.

attribute[source]
RobotSpec.collision_sphere_radii: Float[np.ndarray, num_collision_spheres]

Collision sphere radii.

attribute[source]
RobotSpec.collision_spheres_link_indices: Int[np.ndarray, num_collision_spheres]

Link indices (in link_names) for each collision sphere.

attribute[source]
RobotSpec.self_collision_ignored_pairs: Int[np.ndarray, 'num_ignored_pairs 2']

Load ignored self-collision link pairs verbatim from self_collision_ignore_path, or return none.

attribute[source]
RobotSpec.link_masses: Float[np.ndarray, num_links]

Mass of each link (0.0 if no inertial data).

attribute[source]
RobotSpec.link_local_com_positions: Float[np.ndarray, 'num_links 3']

Center of mass position in link-local frame.

attribute[source]
RobotSpec.loaded_link_capsule_endpoints: Optional[Float[np.ndarray, 'num_links 2 3']] = None

Baked capsule endpoints from link_capsules_path; unset means fit them from the collision meshes.

attribute[source]
RobotSpec.loaded_link_capsule_radii: Optional[Float[np.ndarray, num_links]] = None

Baked capsule radii from link_capsules_path.

attribute[source]
RobotSpec.self_collision_link_buffers: Dict[str, float] = field(default_factory=dict)

Per-link self-collision radius inflation from the collision-sphere YAML; world radii stay unchanged.

method[source]
RobotSpec.parse(
robot_description_or_path: Union[str, Path, yourdfpy.URDF],
load_meshes: bool = False,
mesh_dir: Optional[Union[str, Path]] = None,
load_collision_spheres: bool = False,
collision_spheres_path: Optional[Union[str, Path]] = None,
load_link_capsules: bool = False,
link_capsules_path: Optional[Union[str, Path]] = None,
self_collision_ignore_path: Optional[Union[str, Path]] = None,
base_link_name: Optional[str] = None,
ee_link_names: Optional[Union[Sequence[str], str]] = None,
keep_mjcf_world_link: bool = False
) -> RobotSpec
Parameters
robot_description_or_pathUnion[str, Path, yourdfpy.URDF]required
load_meshesbool= False
mesh_dirOptional[Union[str, Path]]= None
load_collision_spheresbool= False
collision_spheres_pathOptional[Union[str, Path]]= None
load_link_capsulesbool= False
link_capsules_pathOptional[Union[str, Path]]= None
self_collision_ignore_pathOptional[Union[str, Path]]= None
base_link_nameOptional[str]= None
ee_link_namesOptional[Union[Sequence[str], str]]= None
keep_mjcf_world_linkbool= False
Returns
RobotSpec
method[source]
RobotSpec.parse_urdf(
robot_description_or_path: Union[str, Path, yourdfpy.URDF],
load_meshes: bool = False,
mesh_dir: Optional[Union[str, Path]] = None,
load_collision_spheres: bool = False,
collision_spheres_path: Optional[Union[str, Path]] = None,
load_link_capsules: bool = False,
link_capsules_path: Optional[Union[str, Path]] = None,
base_link_name: Optional[str] = None,
ee_link_names: Optional[Union[Sequence[str], str]] = None
) -> RobotSpec
Parameters
robot_description_or_pathUnion[str, Path, yourdfpy.URDF]required
load_meshesbool= False
mesh_dirOptional[Union[str, Path]]= None
load_collision_spheresbool= False
collision_spheres_pathOptional[Union[str, Path]]= None
load_link_capsulesbool= False
link_capsules_pathOptional[Union[str, Path]]= None
base_link_nameOptional[str]= None
ee_link_namesOptional[Union[Sequence[str], str]]= None
Returns
RobotSpec
method[source]
RobotSpec.parse_mjcf(
robot_description_or_path: Union[str, Path],
load_meshes: bool = False,
load_collision_spheres: bool = False,
collision_spheres_path: Optional[Union[str, Path]] = None,
load_link_capsules: bool = False,
link_capsules_path: Optional[Union[str, Path]] = None,
base_link_name: Optional[str] = None,
ee_link_names: Optional[Union[Sequence[str], str]] = None,
keep_world_link: bool = False
) -> RobotSpec

Parse an MJCF robot: hinge/slide joints, equality mimics; the world body stays if kept or a root has joints. A hinge with an anchor (jnt_pos) turns at a synthetic <body>_anchor link, then a fixed joint shifts back.

Parameters
robot_description_or_pathUnion[str, Path]required
load_meshesbool= False
load_collision_spheresbool= False
collision_spheres_pathOptional[Union[str, Path]]= None
load_link_capsulesbool= False
link_capsules_pathOptional[Union[str, Path]]= None
base_link_nameOptional[str]= None
ee_link_namesOptional[Union[Sequence[str], str]]= None
keep_world_linkbool= False
Returns
RobotSpec
property[source]
RobotSpec.num_joints: int
property[source]
RobotSpec.num_actuated_joints: int
property[source]
RobotSpec.num_nonfixed_joints: int
property[source]
RobotSpec.num_links: int
property[source]
RobotSpec.zero_q: Float[np.ndarray, num_actuated_joints]
property[source]
RobotSpec.midrange_q: Float[np.ndarray, num_actuated_joints]
property[source]
RobotSpec.parent_joint_transforms_matrix: Float[np.ndarray, 'num_joints 4 4']

Transforms of parent joints as 4x4 matrices.

property[source]
RobotSpec.has_mimic_joints: bool
property[source]
RobotSpec.mimic_joint_names: List[str]

Names of mimic joints.

property[source]
RobotSpec.total_mass: float
property[source]
RobotSpec.has_collision_spheres: bool
property[source]
RobotSpec.local_collision_sphere_radii: Float[np.ndarray, num_collision_spheres]
property[source]
RobotSpec.local_link_bounding_sphere_centers: Float[np.ndarray, 'num_links 3']

Per-link bounding sphere centers in link-local coordinates (broad-phase filter).

property[source]
RobotSpec.link_bounding_sphere_radii: Float[np.ndarray, num_links]

Per-link bounding sphere radii (broad-phase filter).

property[source]
RobotSpec.local_link_capsule_endpoints: Float[np.ndarray, 'num_links 2 3']

Per-link capsule segment endpoints (a, b) in link-local coordinates; zeros for links without a capsule.

property[source]
RobotSpec.link_capsule_radii: Float[np.ndarray, num_links]

Per-link capsule radii; 0.0 for links without a capsule.

property[source]
RobotSpec.has_link_capsules: bool
property[source]
RobotSpec.topological_order_joint_indices: Int[np.ndarray, num_joints]
property[source]
RobotSpec.kinematic_tree_str: str
property[source]
RobotSpec.joints_to_actuated_mapping: Float[np.ndarray, 'num_joints num_actuated_joints']

Mapping from all joints to actuated joints.

property[source]
RobotSpec.link_ancestor_joints_mask: Bool[np.ndarray, 'num_links num_joints']

Boolean mask for ancestor joints of links.

property[source]
RobotSpec.link_ancestor_links_mask: Bool[np.ndarray, 'num_links num_links']

Boolean mask for ancestor links of links.

method[source]
RobotSpec.get_link_mesh(
link_name: str,
mode: Literal['visual', 'collision'] = 'collision',
return_mesh: bool = True
) -> Union[trimesh.Scene, trimesh.Trimesh]

Link geometry: a single concatenated mesh, or the raw trimesh.Scene when return_mesh=False.

Parameters
link_namestrrequired
modeLiteral['visual', 'collision']= 'collision'
return_meshbool= True
Returns
Union[trimesh.Scene, trimesh.Trimesh]
method[source]
RobotSpec.get_link_meshes(
mode: Literal['visual', 'collision'] = 'collision',
return_mesh: bool = True
) -> Dict[str, Union[trimesh.Scene, trimesh.Trimesh]]

Per-link geometry: concatenated meshes or trimesh.Scenes when return_mesh=False (needs load_meshes=True).

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> spec = RobotSpec.parse(load_robot_description("panda_description"), load_meshes=True)
>>> "panda_hand" in spec.get_link_meshes()
True
Parameters
modeLiteral['visual', 'collision']= 'collision'
return_meshbool= True
Returns
Dict[str, Union[trimesh.Scene, trimesh.Trimesh]]
method[source]
RobotSpec.get_tensors(
device: Optional[str] = None
) -> RobotSpecTensors

Cached Warp spec tensors for device (build on miss).

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> spec = RobotSpec.parse(load_robot_description("panda_description"))
>>> spec.get_tensors() is spec.get_tensors()
True
Parameters
deviceOptional[str]= None
Returns
RobotSpecTensors
method[source]
RobotSpec.get_tensors_torch(
device: Optional[Union[str, torch.device]] = None
) -> TorchRobotSpecTensors

Cached torch spec tensors for device (build on miss).

Example

python
>>> from robot_descriptions.loaders.yourdfpy import load_robot_description
>>> spec = RobotSpec.parse(load_robot_description("panda_description"))
>>> spec.get_tensors_torch() is spec.get_tensors_torch()
True
Parameters
deviceOptional[Union[str, torch.device]]= None
Returns
TorchRobotSpecTensors
class[source]
robokit.robo.RobotState(
robot: Robot,
q: wp.array,
T_world_base: Optional[wp.array] = None
)
Bases: Var
Parameters
robotRobotrequired
qwp.arrayrequired
T_world_baseOptional[wp.array]= None
Members
methodinherited from Var[source]
RobotState.difference(
other: Self,
out: Optional[ArrayLike] = None
) -> ArrayLike

(batch, tangent_dim) velocities that integrate moves each element by to reach other's.

Parameters
otherSelfrequired
outOptional[ArrayLike]= None
Returns
ArrayLike
attribute[source]
RobotState.spec: RobotSpec
attribute[source]
RobotState.q: wp.array
attribute[source]
RobotState.T_world_base: wp.array
attribute[source]
RobotState.has_floating_base: bool
attribute[source]
RobotState.is_fk_computed: bool
attribute[source]
RobotState.is_motion_subspace_computed: bool
attribute[source]
RobotState.is_collision_spheres_computed: bool
attribute[source]
RobotState.is_capsules_computed: bool
attribute[source]
RobotState.is_com_computed: bool
property[source]
RobotState.T_world_joint: wp.array
property[source]
RobotState.T_world_link: wp.array
property[source]
RobotState.X_local: wp.array
property[source]
RobotState.S_world: wp.array
property[source]
RobotState.com_world: wp.array
property[source]
RobotState.collision_sphere_centers_world: wp.array
property[source]
RobotState.link_bounding_sphere_centers_world: wp.array
property[source]
RobotState.link_capsule_endpoint_a_world: wp.array
property[source]
RobotState.link_capsule_endpoint_b_world: wp.array
property[source]
RobotState.is_trajectory: bool
property[source]
RobotState.shape: Tuple[int, ...]
property[source]
RobotState.batch_size: int
property[source]
RobotState.num_elements: int
property[source]
RobotState.device: wp_device_type
property[source]
RobotState.tangent_dim: int
method[source]
RobotState.get_T_world_link(
link_index: int
) -> wp.array
Parameters
link_indexintrequired
Returns
wp.array
method[source]
RobotState.get_link_jacobian(
link_index: int,
reference_frame: Literal['body', 'spatial'] = 'body'
) -> wp.array
Parameters
link_indexintrequired
reference_frameLiteral['body', 'spatial']= 'body'
Returns
wp.array
method[source]
RobotState.invalidate()
method[source]
RobotState.precompute()
method[source]
RobotState.integrate(
velocity: ArrayLike,
out: Optional[RobotState] = None,
tangent_mask: Optional[wp.array] = None,
weight_decay: float = 0.0,
out_velocity: Optional[ArrayLike] = None
) -> RobotState

Integrate the state by a tangent-space velocity, optionally reporting the move the limits let through.

Parameters
velocityArrayLikerequired
outOptional[RobotState]= None
tangent_maskOptional[wp.array]= None
weight_decayfloat= 0.0
out_velocityOptional[ArrayLike]= None
Returns
RobotState
method[source]
RobotState.clamp_q(
tangent_mask: Optional[wp.array] = None,
record_tape: bool = True
) -> RobotState

Clamp joints while preserving masked coordinates; record_tape=False excludes projection from tape.

Parameters
tangent_maskOptional[wp.array]= None
record_tapebool= True
Returns
RobotState
method[source]
RobotState.clone() -> RobotState
Returns
RobotState
method[source]
RobotState.view(
batch_size: int,
offset: int = 0
) -> RobotState

Elements offset to offset + batch_size of every buffer, sharing storage.

Parameters
batch_sizeintrequired
offsetint= 0
Returns
RobotState
method[source]
RobotState.flatten() -> RobotState

Zero-copy view folding the frame axis into the batch axis so per-pose kernels run unchanged.

Returns
RobotState
method[source]
RobotState.gather(
indices: ArrayLike,
out: Optional[RobotState] = None,
q_only: bool = True
) -> RobotState
Parameters
indicesArrayLikerequired
outOptional[RobotState]= None
q_onlybool= True
Returns
RobotState
method[source]
RobotState.accept(
accept_mask: ArrayLike,
proposed: RobotState
) -> RobotState

Optimized accept: copies q, and the forward kinematics this state already had (1 kernel).

Parameters
accept_maskArrayLikerequired
proposedRobotStaterequired
Returns
RobotState