Struct RrtStarTree 

pub struct RrtStarTree<X, T, const N: usize>
where
    X: Scalar,
    T: Trajectory<X, N>,
{ /* private fields */ }

Tree structure for holding the optimal tree

Implementations

impl<X, T, const N: usize> RrtStarTree<X, T, N>

where X: Scalar + Zero, T: Trajectory<X, N>,

pub fn new(goal: SVector<X, N>) -> Self

Creates new graph with goal as the root node with cost zero

impl<X, T, const N: usize> RrtStarTree<X, T, N>

where X: Scalar, T: Trajectory<X, N>,

pub fn node_count(&self) -> usize

Returns the number of nodes in the graph

pub fn get_goal_idx(&self) -> NodeIndex

Returns the index of the goal node

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

Returns reference to the goal node

pub fn all_nodes(&self) -> NodeIter<'_, X, N>

Returns iterator over all nodes in the graph

pub fn all_edges(&self) -> EdgeIter<'_, X, T, N>

Returns iterator over all edges in the graph

pub fn parent(&self, node: NodeIndex) -> Option<NodeIndex>

Returns the NodeIndex of the parent of a in the optimal subtree if exists Returns None if no parent edge

pub fn is_parent(&self, node: NodeIndex, parent: NodeIndex) -> bool

Looks up edge from node -> parent to see if parent is the parent of node

pub fn children(&self, node: NodeIndex) -> Neighbors<'_, T, DefaultIx>

Returns iterator over all children of a in the optimal subtree. Iterator will be empty for leaf nodes

pub fn children_walker(&self, node: NodeIndex) -> WalkNeighbors<DefaultIx>

Returns walker over all children of a in the optimal subtree. Iterator will be empty for leaf nodes

pub fn is_child(&self, node: NodeIndex, child: NodeIndex) -> bool

Looks up edge from child -> node to see if node is the parent of child

pub fn add_orphan(&mut self, node: NodeIndex)

Add node and children of node to the internal set of orphans

This garentees that the children of any orphan node are also marked as orphans as soon as they are added

pub fn remove_orphan(&mut self, node: NodeIndex)

Remove node from the internal list of orphans, doesn’t modifiy the graph

pub fn is_orphan(&self, node: NodeIndex) -> bool

Checks if node is in the internal set of orphans

pub fn orphans(&self) -> impl Iterator<Item = NodeIndex> + '_

Get iterator over all orphans

pub fn clear_orphans(&mut self)

Remove all orphan nodes from the graph and the orphan set

pub fn add_node( &mut self, node: Node<X, N>, parent: NodeIndex, trajectory: T, ) -> (NodeIndex, EdgeIndex)

Adds a node to the graph and returns it’s index in addition fo the edge index to the parent

pub fn update_edge( &mut self, node: NodeIndex, new_parent: NodeIndex, new_trajectory: T, ) -> EdgeIndex

Sets the new parent and removes any existing parent

pub fn get_optimal_path( &self, node: NodeIndex, ) -> Option<OptimalPathIter<'_, X, T, N>>

Returns an iterator of edges over the optimal path to the goal node Returns None if no such path exists

pub fn get_node(&self, idx: NodeIndex) -> &Node<X, N>

Returns a refernce the specified node

panics if idx is invalid

pub fn get_node_mut(&mut self, idx: NodeIndex) -> &mut Node<X, N>

Returns a mutable refernce the specified node

panics if idx is invalid

pub fn get_edge(&self, idx: EdgeIndex) -> &T

Returns a refernce the specified edge

panics if idx is invalid

pub fn get_endpoints(&self, idx: EdgeIndex) -> (NodeIndex, NodeIndex)

Returns source and target endpoints of an edge

pub fn get_trajectory(&self, idx: EdgeIndex) -> FullTrajRefOwned<'_, X, T, N>

Returns the trajectory stored at the specified edge

panics if idx is invalid

Trait Implementations

impl<X, T, const N: usize> Clone for RrtStarTree<X, T, N>

where X: Scalar + Clone, T: Trajectory<X, N> + Clone,

fn clone(&self) -> RrtStarTree<X, T, N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<X, T, const N: usize> Debug for RrtStarTree<X, T, N>

where X: Scalar + Debug, T: Trajectory<X, N> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, X, T, const N: usize> Deserialize<'de> for RrtStarTree<X, T, N>

where X: Scalar + DeserializeOwned, T: Trajectory<X, N> + DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X, T, const N: usize> Serialize for RrtStarTree<X, T, N>

where X: Scalar + Serialize, T: Trajectory<X, N> + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.