Public API for module isaacsim.robot_motion.motion_generation:#
Classes#
class WorldInterface
def init(self)
def update_world(self, updated_obstacles: Optional[List] = None)
def add_obstacle(self, obstacle: isaacsim.core.api.objects, static: Optional[bool] = False) -> bool
def add_cuboid(self, cuboid: Union[cuboid.DynamicCuboid, cuboid.FixedCuboid, cuboid.VisualCuboid], static: bool = False) -> bool
def add_sphere(self, sphere: Union[sphere.DynamicSphere, sphere.VisualSphere], static: bool = False) -> bool
def add_capsule(self, capsule: Union[capsule.DynamicCapsule, capsule.VisualCapsule], static: bool = False) -> bool
def add_cylinder(self, cylinder: Union[cylinder.DynamicCylinder, cylinder.VisualCylinder], static: bool = False) -> bool
def add_cone(self, cone: Union[cone.DynamicCone, cone.VisualCone], static: bool = False) -> bool
def add_ground_plane(self, ground_plane: ground_plane.GroundPlane) -> bool
def disable_obstacle(self, obstacle: isaacsim.core.api.objects) -> bool
def enable_obstacle(self, obstacle: isaacsim.core.api.objects) -> bool
def remove_obstacle(self, obstacle: isaacsim.core.api.objects) -> bool
def reset(self)
class MotionPolicy(WorldInterface)
def init(self)
def set_robot_base_pose(self, robot_translation: np.array, robot_orientation: np.array)
def compute_joint_targets(self, active_joint_positions: np.array, active_joint_velocities: np.array, watched_joint_positions: np.array, watched_joint_velocities: np.array, frame_duration: float) -> Tuple[np.array, np.array]
def get_active_joints(self) -> List[str]
def get_watched_joints(self) -> List[str]
def set_cspace_target(self, active_joint_targets: np.array)
def set_end_effector_target(self, target_translation = None, target_orientation = None)
class RmpFlow(LulaInterfaceHelper, MotionPolicy)
def init(self, robot_description_path: str, urdf_path: str, rmpflow_config_path: str, end_effector_frame_name: str, maximum_substep_size: float, ignore_robot_state_updates = False)
def set_ignore_state_updates(self, ignore_robot_state_updates)
def set_cspace_target(self, active_joint_targets)
def update_world(self, updated_obstacles: List = None)
def compute_joint_targets(self, active_joint_positions: np.array, active_joint_velocities: np.array, watched_joint_positions: np.array, watched_joint_velocities: np.array, frame_duration: float) -> Tuple[np.array, np.array]
def visualize_collision_spheres(self)
def visualize_end_effector_position(self)
def stop_visualizing_collision_spheres(self)
def stop_visualizing_end_effector(self)
def get_collision_spheres_as_prims(self) -> List
def get_end_effector_as_prim(self) -> objects.cuboid.VisualCuboid
def delete_collision_sphere_prims(self)
def delete_end_effector_prim(self)
def reset(self)
def set_internal_robot_joint_states(self, active_joint_positions: np.array, active_joint_velocities: np.array, watched_joint_positions: np.array, watched_joint_velocities: np.array)
def get_internal_robot_joint_states(self) -> Tuple[np.array, np.array, np.array, np.array]
def get_default_cspace_position_target(self) -> np.array
def get_active_joints(self) -> List[str]
def get_watched_joints(self) -> List[str]
def get_end_effector_pose(self, active_joint_positions: np.array) -> Tuple[np.array, np.array]
def get_kinematics_solver(self) -> LulaKinematicsSolver
def set_end_effector_target(self, target_position = None, target_orientation = None)
def set_robot_base_pose(self, robot_position: np.array, robot_orientation: np.array)
def add_obstacle(self, obstacle: objects, static: bool = False) -> bool
def add_cuboid(self, cuboid: Union[objects.cuboid.DynamicCuboid, objects.cuboid.FixedCuboid, objects.cuboid.VisualCuboid], static: bool = False) -> bool
def add_sphere(self, sphere: Union[objects.sphere.DynamicSphere, objects.sphere.VisualSphere], static: bool = False) -> bool
def add_capsule(self, capsule: Union[objects.capsule.DynamicCapsule, objects.capsule.VisualCapsule], static: bool = False) -> bool
def add_ground_plane(self, ground_plane: objects.ground_plane.GroundPlane) -> bool
def disable_obstacle(self, obstacle: objects) -> bool
def enable_obstacle(self, obstacle: objects) -> bool
def remove_obstacle(self, obstacle: objects) -> bool
class ArticulationMotionPolicy
def init(self, robot_articulation: SingleArticulation, motion_policy: MotionPolicy, default_physics_dt: float = 1 / 60.0)
def move(self, physics_dt: float = None)
def get_next_articulation_action(self, physics_dt: float = None) -> ArticulationAction
def get_active_joints_subset(self) -> ArticulationSubset
def get_watched_joints_subset(self) -> ArticulationSubset
def get_robot_articulation(self) -> SingleArticulation
def get_motion_policy(self) -> MotionPolicy
def get_default_physics_dt(self) -> float
def set_default_physics_dt(self, physics_dt: float)
class KinematicsSolver(WorldInterface)
def init(self)
def set_robot_base_pose(self, robot_positions: np.array, robot_orientation: np.array)
def get_joint_names(self) -> List[str]
def get_all_frame_names(self) -> List[str]
def compute_forward_kinematics(self, frame_name: str, joint_positions: np.array, position_only: Optional[bool] = False) -> Tuple[np.array, np.array]
def compute_inverse_kinematics(self, frame_name: str, target_positions: np.array, target_orientation: Optional[np.array] = None, warm_start: Optional[np.array] = None, position_tolerance: Optional[float] = None, orientation_tolerance: Optional[float] = None) -> Tuple[np.array, bool]
def supports_collision_avoidance(self) -> bool
class LulaKinematicsSolver(KinematicsSolver)
def init(self, robot_description_path: str, urdf_path: str, robot_description: Optional[lula.RobotDescription] = None)
[property] def bfgs_cspace_limit_biasing(self) -> bool
[bfgs_cspace_limit_biasing.setter] def bfgs_cspace_limit_biasing(self, value)
[property] def bfgs_cspace_limit_biasing_weight(self) -> float
[bfgs_cspace_limit_biasing_weight.setter] def bfgs_cspace_limit_biasing_weight(self, value)
[property] def bfgs_cspace_limit_penalty_region(self) -> float
[bfgs_cspace_limit_penalty_region.setter] def bfgs_cspace_limit_penalty_region(self, value)
[property] def bfgs_gradient_norm_termination(self) -> float
[bfgs_gradient_norm_termination.setter] def bfgs_gradient_norm_termination(self, value)
[property] def bfgs_gradient_norm_termination_coarse_scale_factor(self) -> float
[bfgs_gradient_norm_termination_coarse_scale_factor.setter] def bfgs_gradient_norm_termination_coarse_scale_factor(self, value)
[property] def bfgs_max_iterations(self) -> int
[bfgs_max_iterations.setter] def bfgs_max_iterations(self, value)
[property] def bfgs_orientation_weight(self) -> float
[bfgs_orientation_weight.setter] def bfgs_orientation_weight(self, value)
[property] def bfgs_position_weight(self) -> float
[bfgs_position_weight.setter] def bfgs_position_weight(self, value)
[property] def ccd_bracket_search_num_uniform_samples(self) -> int
[ccd_bracket_search_num_uniform_samples.setter] def ccd_bracket_search_num_uniform_samples(self, value)
[property] def ccd_descent_termination_delta(self) -> float
[ccd_descent_termination_delta.setter] def ccd_descent_termination_delta(self, value)
[property] def ccd_max_iterations(self) -> int
[ccd_max_iterations.setter] def ccd_max_iterations(self, value)
[property] def ccd_orientation_weight(self) -> float
[ccd_orientation_weight.setter] def ccd_orientation_weight(self, value)
[property] def ccd_position_weight(self) -> float
[ccd_position_weight.setter] def ccd_position_weight(self, value)
[property] def irwin_hall_sampling_order(self) -> int
[irwin_hall_sampling_order.setter] def irwin_hall_sampling_order(self, value)
[property] def max_num_descents(self) -> int
[max_num_descents.setter] def max_num_descents(self, value)
[property] def sampling_seed(self) -> int
[sampling_seed.setter] def sampling_seed(self, value)
def set_robot_base_pose(self, robot_position: np.array, robot_orientation: np.array)
def get_joint_names(self) -> List[str]
def get_all_frame_names(self) -> List[str]
def compute_forward_kinematics(self, frame_name: str, joint_positions: np.array, position_only: Optional[bool] = False) -> Tuple[np.array, np.array]
def compute_inverse_kinematics(self, frame_name: str, target_position: np.array, target_orientation: np.array = None, warm_start: np.array = None, position_tolerance: float = None, orientation_tolerance: float = None) -> Tuple[np.array, bool]
def supports_collision_avoidance(self) -> bool
def set_default_orientation_tolerance(self, tolerance: float)
def set_default_position_tolerance(self, tolerance: float)
def set_default_cspace_seeds(self, seeds: np.array)
def get_default_orientation_tolerance(self) -> float
def get_default_position_tolerance(self) -> float
def get_default_cspace_seeds(self) -> List[np.array]
def get_cspace_position_limits(self) -> Tuple[np.array, np.array]
def get_cspace_velocity_limits(self) -> np.array
def get_cspace_acceleration_limits(self) -> np.array
def get_cspace_jerk_limits(self) -> np.array
class ArticulationKinematicsSolver
def init(self, robot_articulation: SingleArticulation, kinematics_solver: KinematicsSolver, end_effector_frame_name: str)
def compute_end_effector_pose(self, position_only: bool = False) -> Tuple[np.array, np.array]
def compute_inverse_kinematics(self, target_position: np.array, target_orientation: Optional[np.array] = None, position_tolerance: Optional[float] = None, orientation_tolerance: Optional[float] = None) -> Tuple[ArticulationAction, bool]
def set_end_effector_frame(self, end_effector_frame_name: str)
def get_end_effector_frame(self) -> str
def get_joints_subset(self) -> ArticulationSubset
def get_kinematics_solver(self) -> KinematicsSolver
class PathPlanner(WorldInterface)
def init(self)
def set_robot_base_pose(self, robot_translation: np.array, robot_orientation: np.array)
def compute_path(self, active_joint_positions: np.array, watched_joint_positions: np.array) -> np.array
def get_active_joints(self) -> List[str]
def get_watched_joints(self) -> List[str]
def set_cspace_target(self, active_joint_targets: np.array)
def set_end_effector_target(self, target_translation, target_orientation = None)
class Trajectory
def init(self)
[property] def start_time(self) -> float
[property] def end_time(self) -> float
def get_active_joints(self) -> List[str]
def get_joint_targets(self, time: float) -> Tuple[np.array, np.array]
class LulaCSpaceTrajectoryGenerator
def init(self, robot_description_path: str, urdf_path: str)
def compute_c_space_trajectory(self, waypoint_positions: np.array) -> LulaTrajectory
def compute_timestamped_c_space_trajectory(self, waypoint_positions: np.array, timestamps: np.array, interpolation_mode: str = ‘cubic_spline’) -> LulaTrajectory
def get_active_joints(self) -> List[str]
def get_c_space_position_limits(self) -> np.array
def get_c_space_velocity_limits(self) -> np.array
def get_c_space_acceleration_limits(self) -> np.array
def get_c_space_jerk_limits(self) -> np.array
def set_c_space_position_limits(self, lower_position_limits: np.array, upper_position_limits: np.array)
def set_c_space_velocity_limits(self, velocity_limits: np.array)
def set_c_space_acceleration_limits(self, acceleration_limits: np.array)
def set_c_space_jerk_limits(self, jerk_limits: np.array)
def set_solver_param(self, param_name: str, param_val: Union[int, float, str])
class LulaTaskSpaceTrajectoryGenerator
get_active_joints: Unknown
get_c_space_position_limits: Unknown
get_c_space_velocity_limits: Unknown
get_c_space_acceleration_limits: Unknown
get_c_space_jerk_limits: Unknown
set_c_space_position_limits: Unknown
set_c_space_velocity_limits: Unknown
set_c_space_acceleration_limits: Unknown
set_c_space_jerk_limits: Unknown
set_c_space_trajectory_generator_solver_param: Unknown
def init(self, robot_description_path: str, urdf_path: str)
def get_all_frame_names(self) -> List[str]
def compute_task_space_trajectory_from_points(self, positions: np.array, orientations: np.array, frame_name: str) -> LulaTrajectory
def compute_task_space_trajectory_from_path_spec(self, path_spec: Union[lula.CompositePathSpec, lula.TaskSpacePathSpec], frame_name: str) -> LulaTrajectory
def get_path_conversion_config(self) -> lula.TaskSpacePathConversionConfig
class ArticulationTrajectory
def init(self, robot_articulation: SingleArticulation, trajectory: Trajectory, physics_dt: float)
def get_action_at_time(self, time: float) -> ArticulationAction
def get_action_sequence(self, timestep: float = None) -> List[ArticulationAction]
def get_trajectory_duration(self) -> float
def get_active_joints_subset(self) -> ArticulationSubset
def get_robot_articulation(self) -> SingleArticulation
def get_trajectory(self) -> Trajectory
class MotionPolicyController(BaseController)
def init(self, name: str, articulation_motion_policy: ArticulationMotionPolicy)
def forward(self, target_end_effector_position: np.ndarray, target_end_effector_orientation: Optional[np.ndarray] = None) -> ArticulationAction
def add_obstacle(self, obstacle: isaacsim.core.api.objects, static: bool = False)
def remove_obstacle(self, obstacle: isaacsim.core.api.objects)
def reset(self)
def get_articulation_motion_policy(self) -> ArticulationMotionPolicy
def get_motion_policy(self) -> MotionPolicy