Struct PRM 

pub struct PRM<S: State, SP: StateSpace<StateType = S>, G: Goal<S>> {
    pub timeout: f64,
    pub connection_radius: f64,
    /* private fields */
}

An implementation of the Probabilistic Roadmap (PRM) algorithm.

PRM is a multi-query, sampling-based algorithm that is particularly effective in static environments. It works by first constructing a “roadmap” graph of valid states and then querying this graph to find paths.

Algorithm Overview

1. Construction Phase: a. Sample a number of states randomly from the state space. b. For each valid sample, find all nearby nodes already in the roadmap. c. If a valid, collision-free motion exists between the new sample and a neighbor, add an edge connecting them in the roadmap.
2. Query Phase: a. Connect the start and goal states to the roadmap. b. Use a graph search algorithm (in this case, Breadth-First Search) to find a path on the roadmap from the start to the goal.

Fields

timeout: f64

The time allocated for roadmap construction, in seconds.

connection_radius: f64

The radius within which to search for neighbors to connect to a new sample.

Implementations

impl<S, SP, G> PRM<S, SP, G>

where S: State + Clone, SP: StateSpace<StateType = S>, G: Goal<S>,

pub fn new(timeout: f64, connection_radius: f64, config: &PlannerConfig) -> Self

Creates a new PRM planner with the specified parameters.

Parameters

• timeout - The time in seconds to spend building the roadmap.
• connection_radius - The radius for connecting new nodes to the roadmap.
• config - The planner configuration, for planner-specific parameters.

pub fn get_roadmap(&self) -> Vec<Node<S>>

Get private variable roadmap as a clone. TODO: Determine if this needs to be obtainable.

pub fn set_problem_definition(&mut self, pd: Arc<ProblemDefinition<S, SP, G>>)

Update ProblemDefinition. This is so that you can use an already sampled roadmap but just change the start and goal states.

pub fn construct_roadmap(&mut self) -> Result<(), PlanningError>

Constructs the probabilistic roadmap.

This method populates the roadmap by sampling states and connecting them until the specified timeout is reached.

Trait Implementations

impl<S, SP, G> Planner<S, SP, G> for PRM<S, SP, G>

where S: State + Clone, SP: StateSpace<StateType = S>, G: Goal<S> + GoalSampleableRegion<S>,

fn setup( &mut self, problem_def: Arc<ProblemDefinition<S, SP, G>>, validity_checker: Arc<dyn StateValidityChecker<S>>, )

Configures the planner for a specific motion planning problem.

fn solve(&mut self, timeout: Duration) -> Result<Path<S>, PlanningError>

Attempt to find a solution to the planning problem.