Struct half_edge_mesh::edge::Edge

pub struct Edge {
    pub next: EdgePtr,
    pub pair: EdgePtr,
    pub origin: VertPtr,
    pub face: FacePtr,
    pub id: u32,
}

Fields

next: EdgePtr

pair: EdgePtr

origin: VertPtr

face: FacePtr

id: u32

Methods

impl Edge

pub fn empty(id: u32) -> Edge

pub fn with_origin(id: u32, origin: VertPtr) -> Edge

pub fn take_next(&mut self, next: EdgePtr)

pub fn set_next(&mut self, next: &EdgePtr)

pub fn set_next_rc(&mut self, next: &EdgeRc)

pub fn take_pair(&mut self, pair: EdgePtr)

pub fn set_pair(&mut self, pair: &EdgePtr)

pub fn set_pair_rc(&mut self, pair: &EdgeRc)

pub fn take_origin(&mut self, origin: VertPtr)

pub fn set_origin(&mut self, origin: &VertPtr)

pub fn set_origin_rc(&mut self, origin: &VertRc)

pub fn set_face(&mut self, face: &FacePtr)

pub fn take_face(&mut self, face: FacePtr)

pub fn set_face_rc(&mut self, face: &FaceRc)

pub fn is_valid(&self) -> bool

pub fn get_next(&self) -> Option<EdgeRc>

pub fn get_pair(&self) -> Option<EdgeRc>

pub fn get_origin(&self) -> Option<VertRc>

pub fn get_face(&self) -> Option<FaceRc>

pub fn get_next_next(&self) -> Option<EdgeRc>

pub fn get_next_pair(&self) -> Option<EdgeRc>

pub fn get_target(&self) -> Option<VertRc>

pub fn get_pair_face(&self) -> Option<FaceRc>

Important traits for EdgeAdjacentVertIterator<'a>

impl<'a> Iterator for EdgeAdjacentVertIterator<'a> type Item = VertPtr;

pub fn adjacent_verts(&self) -> EdgeAdjacentVertIterator

Yields edge.origin, then edge.next.origin Gives you first the source of the half-edge, and then its target

Important traits for EdgeAdjacentEdgeIterator

impl Iterator for EdgeAdjacentEdgeIterator type Item = EdgePtr;

pub fn adjacent_edges(&self) -> EdgeAdjacentEdgeIterator

Gives you the edges connected to the source of the half-edge first (in clockwise order) and then the edges connected to the target of the half-edge (also clockwise order)

Important traits for EdgeAdjacentFaceIterator<'a>

impl<'a> Iterator for EdgeAdjacentFaceIterator<'a> type Item = FacePtr;

pub fn adjacent_faces(&self) -> EdgeAdjacentFaceIterator

Yields edge.face, then edge.pair.face Gives you the "left" face to the half edge, and then the "right" face Note that the "right" face is not connected to this edge, but to its pair

Trait Implementations

impl Debug for Edge

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

Formats the value using the given formatter.

impl PartialEq<Edge> for Edge

fn eq(&self, other: &Edge) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for Edge

impl Hash for Edge

fn hash<H>(&self, state: &mut H) where     H: Hasher,

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].