Struct Dcel 

pub struct Dcel<VW, HEW = (), FW = (), VC = Vec<Vertex<VW>>, HEC = Vec<HalfEdge<HEW>>, FC = Vec<Face<FW>>> { /* private fields */ }

Implementations

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertexes(&self) -> &VC

pub fn half_edges(&self) -> &HEC

pub fn faces(&self) -> &FC

pub fn dissolve(self) -> (VC, HEC, FC)

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn outgoing_next_half_edge(&self, vertex: VertexId) -> HalfEdgeId

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn incoming_next_half_edge(&self, vertex: VertexId) -> HalfEdgeId

pub fn vertex_next_edge(&self, vertex: VertexId) -> EdgeId

pub fn incoming_prev_half_edge(&self, vertex: VertexId) -> HalfEdgeId

pub fn outgoing_prev_half_edge(&self, vertex: VertexId) -> HalfEdgeId

pub fn vertex_prev_edge(&self, vertex: VertexId) -> EdgeId

pub fn vertex_inner_outgoing_half_edge( &self, vertex: VertexId, face: FaceId, ) -> HalfEdgeId

pub fn vertex_inner_incoming_half_edge( &self, vertex: VertexId, face: FaceId, ) -> HalfEdgeId

pub fn is_boundary_vertex(&self, vertex: VertexId) -> bool

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_weight(&self, vertex: VertexId) -> &VW

impl<VW, HEW, FW, VC, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn origin(&self, half_edge: HalfEdgeId) -> VertexId

pub fn endpoints(&self, edge: EdgeId) -> (VertexId, VertexId)

pub fn twin(&self, half_edge: HalfEdgeId) -> HalfEdgeId

pub fn full_edge(&self, half_edge: HalfEdgeId) -> EdgeId

pub fn reverse_edge(&self, edge: EdgeId) -> EdgeId

pub fn face_in_front(&self, half_edge: HalfEdgeId) -> FaceId

pub fn face_behind(&self, half_edge: HalfEdgeId) -> FaceId

pub fn edge_faces(&self, edge: EdgeId) -> (FaceId, FaceId)

pub fn prev_half_edge(&self, half_edge: HalfEdgeId) -> HalfEdgeId

pub fn next_half_edge(&self, half_edge: HalfEdgeId) -> HalfEdgeId

pub fn prev_edge(&self, edge: EdgeId) -> EdgeId

pub fn next_edge(&self, edge: EdgeId) -> EdgeId

pub fn turn_half_edge(&self, half_edge: HalfEdgeId) -> HalfEdgeId

pub fn turn_back_half_edge(&self, half_edge: HalfEdgeId) -> HalfEdgeId

pub fn turn_edge(&self, edge: EdgeId) -> EdgeId

pub fn turn_back_edge(&self, edge: EdgeId) -> EdgeId

pub fn half_edge_weight(&self, half_edge: HalfEdgeId) -> &HEW

pub fn edge_weights(&self, edge: EdgeId) -> (&HEW, &HEW)

impl<VW, HEW, FW, VC, HEC, FC: Get<usize, Value = Face<FW>>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn incident_half_edge(&self, face: FaceId) -> Option<HalfEdgeId>

pub fn face_weight(&self, face: FaceId) -> &FW

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn unbounded_face(&self) -> FaceId

Returns the id of the unbounded face.

The unbounded face is always the first element of the face list.

impl<VW: Clone + Eq + Hash, HEW: Clone + Default, FW: Clone + Default, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn insert_mesh( &mut self, face_polygons: impl IntoIterator<Item = impl IntoIterator<Item = VW>>, ) -> Vec<FaceId>

pub fn insert_mesh_in_face( &mut self, face_polygons: impl IntoIterator<Item = impl IntoIterator<Item = VW>>, ) -> Vec<FaceId>

impl<VW: Clone, HEW: Clone + Default, FW: Clone + Default, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn insert_polygon( &mut self, vertex_weights: impl IntoIterator<Item = VW>, ) -> FaceId

pub fn insert_polygon_in_face( &mut self, outer_face: FaceId, vertex_weights: impl IntoIterator<Item = VW>, ) -> FaceId

impl<VW: Clone, HEW: Clone, FW: Clone, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn insert_polygon_with_all_weights( &mut self, vertex_weights: impl IntoIterator<Item = VW>, edge_weights: impl IntoIterator<Item = (HEW, HEW)>, face_weight: FW, ) -> FaceId

pub fn insert_polygon_in_face_with_all_weights( &mut self, outer_face: FaceId, vertex_weights: impl IntoIterator<Item = VW>, edge_weights: impl IntoIterator<Item = (HEW, HEW)>, face_weight: FW, ) -> FaceId

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_rim_vertexes( &self, vertex: VertexId, ) -> CirculateVertexesWithExcludesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn vertex_rim_vertexes_reverse( &self, vertex: VertexId, ) -> CirculateVertexesWithExcludesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_half_spokes( &self, vertex: VertexId, ) -> HalfSpokesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn vertex_half_spokes_reverse( &self, vertex: VertexId, ) -> HalfSpokesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_rim_half_edges( &self, vertex: VertexId, ) -> CirculateHalfEdgesWithExcludesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn vertex_rim_half_edges_reverse( &self, vertex: VertexId, ) -> CirculateHalfEdgesWithExcludesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn half_spokes( &self, initial_half_edge: HalfEdgeId, ) -> HalfSpokesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn half_spokes_reverse( &self, initial_half_edge: HalfEdgeId, ) -> HalfSpokesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_spokes( &self, vertex: VertexId, ) -> SpokesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn vertex_spokes_reverse( &self, vertex: VertexId, ) -> SpokesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_rim_edges( &self, vertex: VertexId, ) -> CirculateEdgesWithExcludesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn vertex_rim_edges_reverse( &self, vertex: VertexId, ) -> CirculateEdgesWithExcludesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn vertex_interspokes( &self, vertex: VertexId, ) -> InterspokesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn vertex_interspokes_reverse( &self, vertex: VertexId, ) -> InterspokesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn spokes( &self, initial_edge: EdgeId, ) -> SpokesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn spokes_reverse( &self, initial_edge: EdgeId, ) -> SpokesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn interspokes( &self, initial_half_edge: HalfEdgeId, ) -> InterspokesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn interspokes_reverse( &self, initial_half_edge: HalfEdgeId, ) -> InterspokesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC, HEC: Get<usize, Value = HalfEdge<HEW>>, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn circulate_vertexes_with_excludes( &self, initial_edge: EdgeId, excluded_edges: impl IntoIterator<Item = EdgeId>, ) -> CirculateVertexesWithExcludesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn circulate_vertexes_with_excludes_reverse( &self, initial_edge: EdgeId, excluded_edges: impl IntoIterator<Item = EdgeId>, ) -> CirculateVertexesWithExcludesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn circulate_half_edges_with_excludes( &self, initial_half_edge: HalfEdgeId, excluded_half_edges: impl IntoIterator<Item = HalfEdgeId>, ) -> CirculateHalfEdgesWithExcludesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn circulate_half_edges_with_excludes_reverse( &self, initial_half_edge: HalfEdgeId, excluded_half_edges: impl IntoIterator<Item = HalfEdgeId>, ) -> CirculateHalfEdgesWithExcludesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn circulate_edges_with_excludes( &self, initial_edge: EdgeId, excluded_edges: impl IntoIterator<Item = EdgeId>, ) -> CirculateEdgesWithExcludesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn circulate_edges_with_excludes_reverse( &self, initial_edge: EdgeId, excluded_edges: impl IntoIterator<Item = EdgeId>, ) -> CirculateEdgesWithExcludesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC: Get<usize, Value = Vertex<VW>>, HEC: Get<usize, Value = HalfEdge<HEW>>, FC: Get<usize, Value = Face<FW>>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn face_vertexes( &self, face: FaceId, ) -> FaceVertexesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn face_vertexes_reverse( &self, face: FaceId, ) -> FaceVertexesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC, HEC, FC: Get<usize, Value = Face<FW>>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn face_half_edges( &self, face: FaceId, ) -> FaceHalfEdgesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn face_half_edges_reverse( &self, face: FaceId, ) -> FaceHalfEdgesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW, HEW, FW, VC, HEC: Get<usize, Value = HalfEdge<HEW>>, FC: Get<usize, Value = Face<FW>>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn face_edges( &self, face: FaceId, ) -> FaceEdgesIter<'_, VW, HEW, FW, VC, HEC, FC>

pub fn face_edges_reverse( &self, face: FaceId, ) -> FaceEdgesReverseIter<'_, VW, HEW, FW, VC, HEC, FC>

impl<VW: Clone, HEW: Clone, FW: Clone, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + StableRemove<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + StableRemove<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + StableRemove<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn merge_faces_around_vertex(&mut self, inner_vertex: VertexId)

pub fn absorb_faces_around_vertex( &mut self, absorbing_face: FaceId, inner_vertex: VertexId, )

pub fn merge_faces_over_edges_and_vertexes( &mut self, faces: impl IntoIterator<Item = FaceId>, edges: impl IntoIterator<Item = EdgeId>, vertexes: impl IntoIterator<Item = VertexId>, )

pub fn absorb_faces_over_edges_and_vertexes( &mut self, absorbing_face: FaceId, faces: impl IntoIterator<Item = FaceId>, edges: impl IntoIterator<Item = EdgeId>, vertexes: impl IntoIterator<Item = VertexId>, )

pub fn merge_faces(&mut self, faces: impl IntoIterator<Item = FaceId>)

pub fn absorb_faces( &mut self, absorbing_face: FaceId, faces: impl IntoIterator<Item = FaceId>, )

impl<VW: Clone, HEW: Clone + Default, FW: Clone + Default, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn split_face_by_edge( &mut self, from: VertexId, to: VertexId, face_to_split: FaceId, ) -> FaceId

pub fn split_face_by_edge_chain( &mut self, from: VertexId, to: VertexId, vertex_weights: impl IntoIterator<Item = VW>, face_to_split: FaceId, ) -> FaceId

impl<VW: Clone, HEW: Clone, FW: Clone, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn split_face_by_edge_chain_with_all_weights( &mut self, from: VertexId, to: VertexId, vertex_weights: impl IntoIterator<Item = VW>, edge_weights: impl IntoIterator<Item = (HEW, HEW)>, face_to_split: FaceId, new_face_weight: FW, ) -> FaceId

impl<VW: Clone, HEW: Clone + Default, FW: Clone + Default, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn triangulate_around_vertex( &mut self, perimeter_face: FaceId, inner_vertex_weight: VW, ) -> (Vec<FaceId>, Vec<EdgeId>)

Partition a face into triangles by inserting a vertex inside and then adding edges between it and the original face’s vertexes.

The original face is reused for the first triangle. New faces are created for all the other triangles.

Returns the new vertex id together with the face ids of all the new triangles.

pub fn fan_triangulate( &mut self, perimeter_face: FaceId, apex: VertexId, ) -> (Vec<FaceId>, Vec<EdgeId>)

impl<VW: Clone, HEW: Clone, FW: Clone, VC: Get<usize, Value = Vertex<VW>> + Insert<usize> + Push<usize>, HEC: Get<usize, Value = HalfEdge<HEW>> + Insert<usize> + Push<usize>, FC: Get<usize, Value = Face<FW>> + Insert<usize> + Push<usize>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn triangulate_around_vertex_with_all_weights( &mut self, perimeter_face: FaceId, inner_vertex_weight: VW, inner_edge_weights: impl IntoIterator<Item = (HEW, HEW)>, triangle_face_weights: impl IntoIterator<Item = FW>, ) -> (Vec<FaceId>, Vec<EdgeId>)

pub fn fan_triangulate_with_all_weights( &mut self, perimeter_face: FaceId, apex: VertexId, inner_edge_weights: impl IntoIterator<Item = (HEW, HEW)>, triangle_face_weights: impl IntoIterator<Item = FW>, ) -> (Vec<FaceId>, Vec<EdgeId>)

impl<VW, HEW, FW: Default, VC: Default, HEC: Default, FC: Default + Push<usize, Value = Face<FW>>> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn new() -> Self

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

pub fn from_collections(vertexes: VC, half_edges: HEC, faces: FC) -> Self

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

where for<'a> &'a VC: IntoIterator<Item = &'a usize>,

pub fn vertex_ids(&self) -> impl Iterator<Item = VertexId>

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

where for<'a> &'a HEC: IntoIterator<Item = &'a usize>,

pub fn half_edge_ids(&self) -> impl Iterator<Item = HalfEdgeId>

impl<VW, HEW, FW, VC, HEC, FC> Dcel<VW, HEW, FW, VC, HEC, FC>

where for<'a> &'a FC: IntoIterator<Item = &'a usize>,

pub fn face_ids(&self) -> impl Iterator<Item = FaceId>

Trait Implementations

impl<VW: Clone, HEW: Clone, FW: Clone, VC: Clone, HEC: Clone, FC: Clone> Clone for Dcel<VW, HEW, FW, VC, HEC, FC>

fn clone(&self) -> Dcel<VW, HEW, FW, VC, HEC, FC>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<VW: Debug, HEW: Debug, FW: Debug, VC: Debug, HEC: Debug, FC: Debug> Debug for Dcel<VW, HEW, FW, VC, HEC, FC>

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

Formats the value using the given formatter.

impl<VW, HEW, FW: Default, VC: Default, HEC: Default, FC: Default + Push<usize, Value = Face<FW>>> Default for Dcel<VW, HEW, FW, VC, HEC, FC>

fn default() -> Self

Returns the “default value” for a type.