Struct RrtxGraph 

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

Implementations

impl<X, T, const N: usize> RrtxGraph<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> RrtxGraph<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 neighbor_set( &self, a: NodeIndex, set: NeighborSet, ) -> NeighborSetIter<'_, X, T, N>

Returns an iterator over the neighbors to a in the described set

pub fn neighbor_set_walker( &self, node: NodeIndex, set: NeighborSet, ) -> NeighborSetWalker

Returns an walker over the neighbors to a in the described set

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

Returns the NodeIndex of the parent of a in the optimal subtree if exists Returns None for the root node

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) -> Childern<'_, X, T, N>

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) -> ChildernWalker

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 Returns None if they aren’t connected

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 add_node(&mut self, node: Node<X, N>) -> NodeIndex

Adds a node to the graph and returns it’s index

pub fn add_edge( &mut self, a: NodeIndex, b: NodeIndex, outgoing_neighbor_type: NeighborType, incoming_neighbor_type: NeighborType, is_parent: bool, trajectory: T, ) -> EdgeIndex

Adds a edge to the graph from a -> b with the associated data

pub fn change_parent( &mut self, node: NodeIndex, new_parent: NodeIndex, ) -> Result<Option<NodeIndex>, Option<NodeIndex>>

Switches the unique parent edge from node to the new_parent Still keeps a connection to the old parent Returns Ok if the new_parent was set correctly, otherwise Err Either way, returns the old_parent if was found

pub fn remove_parent(&mut self, node_idx: NodeIndex) -> Option<NodeIndex>

Blindly sets edge connected to parent node as not a parent Return Some parent index if found

pub fn remove_running_neighbor( &mut self, node: NodeIndex, neighbor: NodeIndex, ) -> Option<()>

Removes any outgoing or incoming running neighbor connection on the edge from node -> neighbor Returns None if the edge wasn’t found

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 check_node(&self, idx: NodeIndex) -> bool

Checks if the specified node exists

pub fn delete_node(&mut self, idx: NodeIndex)

Irreversibly delete the specified node

panics if idx is invalid

pub fn get_edge(&self, idx: EdgeIndex) -> &Edge<X, T, N>

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

panics if idx is invalid

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

Returns the trajectory stored at the specified edge if exists

panics if idx is invalid

pub fn update_trajectory(&mut self, idx: EdgeIndex, new_trajectory: T)

Updates the trajectory along the specified edge

panics if idx is invalid

pub fn set_infinite_edge_cost(&mut self, idx: EdgeIndex)

Sets the cost of the given edge to infinity

panics if idx is invalid

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

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

pub fn get_trajectory_cost(&self, idx: EdgeIndex) -> X

Trait Implementations

impl<X: Clone + Scalar, T: Clone + Trajectory<X, N>, const N: usize> Clone for RrtxGraph<X, T, N>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Debug + Scalar, T: Debug + Trajectory<X, N>, const N: usize> Debug for RrtxGraph<X, T, N>

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

Formats the value using the given formatter.

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

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

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 RrtxGraph<X, T, N>

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.