Struct RrtStarPlanner 

pub struct RrtStarPlanner { /* private fields */ }

An RRT* planner as an anytime task.

base() runs the first block of iterations and publishes the first path it finds; each refine() runs one more block and republishes only when the path got shorter. How many blocks run is the policy’s call, not the task’s.

Randomness comes from a cu_rng::CuRngBundle resource: job N’s stream is a pure function of the resource seed and N, so the same seed replays the same trees.

Trait Implementations

impl CuAnytimeTask for RrtStarPlanner

type Input<'m> = CuStampedData<PlanRequest, CuMsgMetadata>

type Output<'m> = CuStampedData<PlanPath, CuMsgMetadata>

type Resources<'r> = Resources

Resources required by the task.

type Quality = Ratio

Measure reported through AnytimeStatus: Quality for tasks that can score their result, () for tasks that cannot. A quality target can only be configured for tasks whose Quality is comparable to it, so a target on a () task is rejected at compile time.

fn register_debug_state_types(registry: &mut TypeRegistry)

Registers the reflected type used as this task’s debug-state contract.

fn debug_state_type_path() -> &'static str

Returns the reflected type path used as this task’s debug-state schema.

fn with_debug_state<R>(&self, f: impl FnOnce(&dyn Reflect) -> R) -> R

Borrows this task’s current debug-state view.

fn new( config: Option<&ComponentConfig>, resources: Self::Resources<'_>, ) -> CuResult<Self>

Here you need to initialize everything your task will need for the duration of its lifetime. The config allows you to access the configuration of the task.

fn base( &mut self, _ctx: &CuContext, input: &Self::Input<'_>, output: &mut Self::Output<'_>, ) -> CuResult<AnytimeStatus<Quality>>

Starts a new job and writes its minimum valid result into output.

fn refine( &mut self, _ctx: &CuContext, output: &mut Self::Output<'_>, ) -> CuResult<AnytimeStatus<Quality>>

Performs exactly one bounded refinement quantum.

fn start(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Start is called between the creation of the task and the first call to pre/base.

fn preprocess(&mut self, _ctx: &CuContext) -> Result<(), CuError>

This is a method called by the runtime before “base”. This is a kind of best effort, as soon as possible call to give a chance for the task to do some work before to prepare to make “base” as short as possible.

fn postprocess(&mut self, _ctx: &CuContext) -> Result<(), CuError>

This is a method called by the runtime after the job’s refinement window has closed. It is best effort a chance for the task to update some state out of the critical path, for example to release scratch memory or maintain statistics that are not time-critical for the robot.

fn stop(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Called to stop the task. It signals that base/refine won’t be called until start is called again.

impl Freezable for RrtStarPlanner

fn freeze<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>

This method is called by the framework when it wants to save the task state. The default implementation is to encode nothing (stateless). If you have a state, you need to implement this method.

fn thaw<D: Decoder>(&mut self, decoder: &mut D) -> Result<(), DecodeError>

This method is called by the framework when it wants to restore the task to a specific state. Here it is similar to Decode but the framework will give you a new instance of the task (the new method will be called)

impl TypePath for RrtStarPlanner

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>