Struct gear::JointPathPlannerWithIK

pub struct JointPathPlannerWithIK<T, I> where
    I: InverseKinematicsSolver<T>,
    T: RealField + 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 planner = gear::JointPathPlannerBuilder::from_urdf_file("sample.urdf")
    .unwrap()
    .collision_check_margin(0.01)
    .finalize();
// Create inverse kinematics solver
let solver = gear::JacobianIKSolver::default();
// Create path planner with IK solver
let _planner = gear::JointPathPlannerWithIK::new(planner, solver);

pub fn urdf_robot(&self) -> &Option<Robot>

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

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<(), Error>

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>>, Error>

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>>, Error>

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

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

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