Struct h3ron_graph::graph::h3edge::H3EdgeGraph

pub struct H3EdgeGraph<W> {
    pub edges: H3EdgeMap<W>,
    pub h3_resolution: u8,
}

Fields

edges: H3EdgeMap<W>

h3_resolution: u8

Implementations

impl<W> H3EdgeGraph<W>where
    W: PartialOrd + PartialEq + Add + Copy,

pub fn new(h3_resolution: u8) -> Self

pub fn num_nodes(&self) -> Result<usize, Error>

This has to generate the node list first, so its rather expensive to call.

pub fn num_edges(&self) -> usize

pub fn edge_weight(&self, edge: &H3DirectedEdge) -> Option<&W>

pub fn edges_from_cell(
    &self,
    cell: &H3Cell
) -> Result<Vec<(&H3DirectedEdge, &W)>, Error>

get all edges in the graph leading from this edge to neighbors

pub fn edges_to_cell(
    &self,
    cell: &H3Cell
) -> Result<Vec<(&H3DirectedEdge, &W)>, Error>

get all edges in the graph leading to this cell from its neighbors

pub fn add_edge_using_cells(
    &mut self,
    cell_from: H3Cell,
    cell_to: H3Cell,
    weight: W
) -> Result<(), Error>

pub fn add_edge_using_cells_bidirectional(
    &mut self,
    cell_from: H3Cell,
    cell_to: H3Cell,
    weight: W
) -> Result<(), Error>

pub fn add_edge(&mut self, edge: H3DirectedEdge, weight: W) -> Result<(), Error>

pub fn try_add(&mut self, other: Self) -> Result<(), Error>

pub fn nodes(&self) -> Result<H3CellMap<NodeType>, Error>

cells which are valid targets to route to

This is a rather expensive operation as nodes are not stored anywhere and need to be extracted from the edges.

pub fn iter_edges(&self) -> impl Iterator<Item = (H3DirectedEdge, &W)>

Trait Implementations

impl<W: Clone> Clone for H3EdgeGraph<W>

fn clone(&self) -> H3EdgeGraph<W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<W> CoveredArea for H3EdgeGraph<W>where
    W: PartialOrd + PartialEq + Add + Copy,

type Error = Error

fn covered_area(
    &self,
    reduce_resolution_by: u8
) -> Result<MultiPolygon<f64>, Self::Error>

calculates a MultiPolygon of the area covered by a graph

impl<'de, W> Deserialize<'de> for H3EdgeGraph<W>where
    W: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<W> From<PreparedH3EdgeGraph<W>> for H3EdgeGraph<W>where
    W: PartialOrd + PartialEq + Add + Copy + Ord + Zero,

fn from(prepared_graph: PreparedH3EdgeGraph<W>) -> Self

Converts to this type from the input type.

impl<W> GetEdge for H3EdgeGraph<W>where
    W: Copy,

type EdgeWeightType = W

fn get_edge(
    &self,
    edge: &H3DirectedEdge
) -> Result<Option<EdgeWeight<'_, Self::EdgeWeightType>>, Error>

impl<W> GetStats for H3EdgeGraph<W>where
    W: PartialEq + PartialOrd + Add + Copy,

fn get_stats(&self) -> Result<GraphStats, Error>

impl<W> HasH3Resolution for H3EdgeGraph<W>

fn h3_resolution(&self) -> u8

Gets the index resolution (0-15)

impl<T> OgrWrite for H3EdgeGraph<T>where
    T: WeightFeatureField + Send + Sync,

fn ogr_write<S: AsRef<str>>(
    &self,
    driver_name: S,
    output_name: S,
    layer_name: S
) -> Result<(), Error>

impl<W> Serialize for H3EdgeGraph<W>where
    W: Serialize,

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

Serialize this value into the given Serde serializer.

impl<W> TryFrom<H3EdgeGraph<W>> for PreparedH3EdgeGraph<W>where
    W: PartialOrd + PartialEq + Add + Copy + Ord + Zero + Send + Sync,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(graph: H3EdgeGraph<W>) -> Result<Self, Self::Error>

Performs the conversion.