Struct Cartesian 

pub struct Cartesian<'a> {
    pub robot: &'a KinematicsWithShape,
    pub check_step_m: f64,
    pub check_step_rad: f64,
    pub max_transition_cost: f64,
    pub transition_coefficients: Joints,
    pub linear_recursion_depth: usize,
    pub rrt: RRTPlanner,
    pub include_linear_interpolation: bool,
    pub debug: bool,
}

Class doing Cartesian planning

Fields

robot: &'a KinematicsWithShape

check_step_m: f64

Check step size in meters. Objects and features of the robotic cell smaller than this may not be noticed during collision checks.

check_step_rad: f64

Check step size in radians. Objects and features of the robotic cell smaller than this may not be noticed during collision checks.

max_transition_cost: f64

Maximum allowed transition cost between Joints

transition_coefficients: Joints

Transition cost coefficients (smaller joints are allowed to rotate more)

linear_recursion_depth: usize

If movement between adjacent poses results transition costs over this threshold, the Cartesian segment is divided by half, checking boths side separatedly while collision checking also the middle segment.

rrt: RRTPlanner

RRT planner that plans the onboarding part, and may potentially plan other parts that involve collision free relocation of the robot, but without Cartesian (linear) movement.

include_linear_interpolation: bool

If set, linear interpolated poses are included in the output. Otherwise, they are discarded, many robots can do Cartesian stroke much better on they own

debug: bool

Debug mode for logging

Implementations

impl Cartesian<'_>

pub fn plan( &self, from: &Joints, land: &Pose, steps: Vec<Pose>, park: &Pose, ) -> Result<Vec<AnnotatedJoints>, String>

Path plan for the given vector of poses. The returned path must be transitionable and collision free.