Struct openrr_planner::JointPathPlannerWithIk

pub struct JointPathPlannerWithIk<T, I>
where
    I: InverseKinematicsSolver<T>,
    T: RealField + Copy + SubsetOf<f64>,
{
    pub path_planner: JointPathPlanner<T>,
    pub ik_solver: I,
}

Joint path planner which supports inverse kinematics

Fields

path_planner: JointPathPlanner<T>

Joint Path Planner to be used to find collision free path

Currently, JointPathPlanner<N, k::Chain<N>> is used.

ik_solver: I

Inverse kinematics solver to find the goal joint angles

Implementations

impl<T, I> JointPathPlannerWithIk<T, I>

where T: RealField + SubsetOf<f64> + Float, I: InverseKinematicsSolver<T>,

pub fn new(path_planner: JointPathPlanner<T>, ik_solver: I) -> Self

Create instance from JointPathPlannerBuilder and InverseKinematicsSolver

Example

// Create path planner with loading urdf file and set end link name
let robot = k::Chain::from_urdf_file("sample.urdf").unwrap();
let planner = openrr_planner::JointPathPlannerBuilder::from_urdf_file("sample.urdf")
    .unwrap()
    .collision_check_margin(0.01)
    .reference_robot(std::sync::Arc::new(robot))
    .finalize()
    .unwrap();
// Create inverse kinematics solver
let solver = openrr_planner::JacobianIkSolver::default();
// Create path planner with IK solver
let _planner = openrr_planner::JointPathPlannerWithIk::new(planner, solver);

pub fn solve_ik( &mut self, arm: &SerialChain<T>, target_pose: &Isometry3<T>, ) -> Result<()>

Just solve IK and do not plan

pub fn solve_ik_with_constraints( &mut self, arm: &SerialChain<T>, target_pose: &Isometry3<T>, c: &Constraints, ) -> Result<()>

Just solve IK with constraints and do not plan

pub fn colliding_link_names(&self, objects: &Compound<T>) -> Vec<String>

pub fn plan_with_ik( &mut self, target_name: &str, target_pose: &Isometry3<T>, objects: &Compound<T>, ) -> Result<Vec<Vec<T>>>

Solve IK and get the path to the final joint positions

pub fn plan_with_ik_with_constraints( &mut self, target_name: &str, target_pose: &Isometry3<T>, objects: &Compound<T>, constraints: &Constraints, ) -> Result<Vec<Vec<T>>>

Solve IK with constraints and get the path to the final joint positions

pub fn plan_joints<K>( &mut self, using_joint_names: &[String], start_angles: &[T], goal_angles: &[T], objects: &Compound<T>, ) -> Result<Vec<Vec<T>>>

Do not solve IK but get the path to the target joint positions

pub fn update_transforms(&self) -> Vec<Isometry3<T>>

Calculate the transforms of all of the links

pub fn joint_names(&self) -> Vec<String>

Get the names of the links