Trait PathPlanner 

pub trait PathPlanner<X, CS, OS, const N: usize>: Sized
where
    X: Scalar,
    CS: CSpace<X, N>,
    OS: ObstacleSpace<X, CS, N>,
{
    type Params: Clone;
    type State: Clone;

    // Required methods
    fn new(
        init: SVector<X, N>,
        goal: SVector<X, N>,
        robot_specs: RobotSpecs<X>,
        cspace: CS,
        obs_space: OS,
        params: Self::Params,
    ) -> Result<Self>;
    fn create_node(&mut self) -> &Self::State;
    fn sample_node(&mut self) -> Option<&Self::State>;
    fn check_sensors(&mut self);
    fn get_obs_space(&self) -> &OS;
    fn get_obs_space_mut(&mut self) -> &mut OS;
    fn get_cspace(&self) -> &CS;
    fn get_cspace_mut(&mut self) -> &mut CS;
    fn check_nodes(&mut self, obs_space: bool, cspace: bool);
    fn update_pose(
        &mut self,
        pose: SVector<X, N>,
        nearest: bool,
    ) -> Option<MoveGoal<X, N>>;
    fn get_tree(&self) -> Vec<FullTrajRefOwned<'_, X, CS::Traj, N>> ;
    fn get_current_path(&self) -> Option<FullTrajOwned<X, CS::Traj, N>>;
    fn get_path_to_goal(&self) -> Option<Vec<SVector<X, N>>>;
    fn get_last_pose(&self) -> &SVector<X, N>;
    fn get_state(&self) -> &Self::State;
    fn get_goal(&self) -> &SVector<X, N>;
    fn count(&self) -> usize;

    // Provided methods
    fn get_cost_to_goal(&self) -> Option<X> { ... }
    fn get_cost_to_move_goal(&self) -> Option<X> { ... }
}

A sampling-based path path_planner

Required Associated Types

type Params: Clone

type State: Clone

Required Methods

fn new( init: SVector<X, N>, goal: SVector<X, N>, robot_specs: RobotSpecs<X>, cspace: CS, obs_space: OS, params: Self::Params, ) -> Result<Self>

Define a new Path Planner with an initial set of obstacles in the space.

init: The inital pose, must be in free space.

goal: The goal pose, must be in free space, the root of the search tree.

robot_specs: Information about the robot sizing.

cspace: Describes the constant configuration space to plan within.

obs_space: The obstacle space to plan around.

params: Algorithm specific parameters.

fn create_node(&mut self) -> &Self::State

Samples nodes until one is added to the search graph.

Returns updated state reference once node is successfully added to the graph

fn sample_node(&mut self) -> Option<&Self::State>

Sample once to add a node to the graph

Optionally returns updated state if node was successfully added

fn check_sensors(&mut self)

Checks the sensor on the robot for obstacles updates within robot_specs.sensor_range

fn get_obs_space(&self) -> &OS

Returns reference to the currently used obstacle space

fn get_obs_space_mut(&mut self) -> &mut OS

Returns mutable reference to the currently used obstacle space

Make sure to call Self::check_nodes with obs_space = true if the modifications might make some nodes invalid

fn get_cspace(&self) -> &CS

Returns reference to the currently used cspace

fn get_cspace_mut(&mut self) -> &mut CS

Returns mutable reference to the currently used cspace

Make sure to call Self::check_nodes with cspace = true if the modifications might make some nodes invalid

fn check_nodes(&mut self, obs_space: bool, cspace: bool)

Checks the spaces specified that all nodes are still valid in that space

Make sure to call after modifying the obs_space or cspace such that some nodes might be invalid

fn update_pose( &mut self, pose: SVector<X, N>, nearest: bool, ) -> Option<MoveGoal<X, N>>

Updates the pose of the system, possibly changing the move goal

Returns Some coordinates the next move goal if the global goal is reachable

if nearest is true, will select a move goal that is the closest to the given pose

Specifies wether the returned move goal is new or the same as before

fn get_tree(&self) -> Vec<FullTrajRefOwned<'_, X, CS::Traj, N>>

Get the search tree as a list of edges

fn get_current_path(&self) -> Option<FullTrajOwned<X, CS::Traj, N>>

Returns Some trajectory the next move goal if the global goal is reachable

fn get_path_to_goal(&self) -> Option<Vec<SVector<X, N>>>

Returns Some path to the goal if the global goal is reachable

fn get_last_pose(&self) -> &SVector<X, N>

Get the last known pose of the system

fn get_state(&self) -> &Self::State

Get a reference to the current serializable state information

fn get_goal(&self) -> &SVector<X, N>

Returns the coordinates of the goal node

fn count(&self) -> usize

Returns the number of nodes in the graph plus the initial node (which is technically never added to the graph)

Provided Methods

fn get_cost_to_goal(&self) -> Option<X>

Returns the total cost to reach the goal from the most recent pose given in update_pose

fn get_cost_to_move_goal(&self) -> Option<X>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<X, CS, OS, const N: usize> PathPlanner<X, CS, OS, N> for Rrt<X, CS, OS, N>

where X: Scalar, CS: CSpace<X, N> + Send + Sync, CS::Traj: Send + Sync, OS: ObstacleSpace<X, CS, N> + Send + Sync, OS::Obs: Send + Sync,

type Params = RrtParams<X>

type State = RrtState<X, CS, OS, N>

impl<X, CS, OS, const N: usize> PathPlanner<X, CS, OS, N> for RrtStar<X, CS, OS, N>

where X: Scalar, CS: CSpace<X, N> + Send + Sync, CS::Traj: Send + Sync, OS: ObstacleSpace<X, CS, N> + Send + Sync, OS::Obs: Send + Sync,

type Params = RrtStarParams<X>

type State = RrtStarState<X, CS, OS, N>

impl<X, CS, OS, const N: usize> PathPlanner<X, CS, OS, N> for Rrtx<X, CS, OS, N>

where X: Scalar, CS: CSpace<X, N> + Send + Sync, CS::Traj: Send + Sync, OS: ObstacleSpace<X, CS, N> + Send + Sync, OS::Obs: Send + Sync,

type Params = RrtxParams<X>

type State = RrtxState<X, CS, OS, N>