Struct HalfEdge 

pub struct HalfEdge { /* private fields */ }

A directed edge, defined in a surface’s 2D space

The concept of an “edge” in Fornjot is represented by two structs, HalfEdge and GlobalEdge. HalfEdge has two attributes that make it distinct from GlobalEdge:

• HalfEdge is directed, meaning it has a defined start and end vertex.
• HalfEdge is defined in the 2-dimensional space of a surface.

When multiple faces, which are bound by edges, are combined to form a solid, the HalfEdges that bound the face on the surface are then coincident with the HalfEdges of other faces, where those faces touch. Those coincident HalfEdges are different representations of the same edge. This edge is represented by an instance of GlobalEdge.

There are some requirements that a HalfEdge needs to uphold to be valid:

1. Coincident HalfEdges must refer to the same GlobalEdge.
2. HalfEdges that are coincident, i.e. located in the same space, must always be congruent. This means they must coincide exactly. The overlap must be complete. None of the coincident HalfEdges must overlap with just a section of another.

That second requirement means that a HalfEdge might need to be split into multiple smaller HalfEdges that are each coincident with a HalfEdge in another face.

Implementation Note

There is no validation code that verifies whether coincident HalfEdges refer to the same GlobalEdge or not: https://github.com/hannobraun/Fornjot/issues/1594

Conversely, there is no validation code to verify that coincident HalfEdges are congruent: https://github.com/hannobraun/Fornjot/issues/1608

Implementations

impl HalfEdge

pub fn new( curve: Curve, boundary: [Point<1>; 2], start_vertex: Handle<Vertex>, global_form: Handle<GlobalEdge>, ) -> Self

Create an instance of HalfEdge

pub fn curve(&self) -> Curve

Access the curve that defines the half-edge’s geometry

pub fn boundary(&self) -> [Point<1>; 2]

Access the boundary points of the half-edge on the curve

pub fn start_position(&self) -> Point<2>

Compute the surface position where the half-edge starts

pub fn start_vertex(&self) -> &Handle<Vertex>

Access the vertex from where this half-edge starts

pub fn global_form(&self) -> &Handle<GlobalEdge>

Access the global form of the half-edge

Trait Implementations

impl BuildHalfEdge for HalfEdge

fn unjoined( curve: Curve, boundary: [Point<1>; 2], services: &mut Services, ) -> HalfEdge

Create a half-edge that is not joined to another

fn arc( start: impl Into<Point<2>>, end: impl Into<Point<2>>, angle_rad: impl Into<Scalar>, services: &mut Services, ) -> HalfEdge

Create an arc

fn circle(radius: impl Into<Scalar>, services: &mut Services) -> HalfEdge

Create a circle

fn line_segment( points_surface: [impl Into<Point<2>>; 2], boundary: Option<[Point<1>; 2]>, services: &mut Services, ) -> HalfEdge

Create a line segment

fn line_segment_from_global_points( points_global: [impl Into<Point<3>>; 2], surface: &Surface, boundary: Option<[Point<1>; 2]>, services: &mut Services, ) -> HalfEdge

Create a line segment from global points

impl Clone for HalfEdge

fn clone(&self) -> HalfEdge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HalfEdge

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

Formats the value using the given formatter.

impl From<HalfEdge> for Object<Bare>

fn from(object: HalfEdge) -> Self

Converts to this type from the input type.

impl Hash for HalfEdge

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Insert for HalfEdge

type Inserted = Handle<HalfEdge>

The type of Self, once it has been inserted

fn insert(self, services: &mut Services) -> Self::Inserted

Insert the object into its respective store

impl Ord for HalfEdge

fn cmp(&self, other: &HalfEdge) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for HalfEdge

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for HalfEdge

fn partial_cmp(&self, other: &HalfEdge) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TransformObject for HalfEdge

fn transform_with_cache( self, transform: &Transform, services: &mut Services, cache: &mut TransformCache, ) -> Self

Transform the object using the provided cache

fn transform(self, transform: &Transform, services: &mut Services) -> Self

Transform the object

fn translate( self, offset: impl Into<Vector<3>>, services: &mut Services, ) -> Self

Translate the object

fn rotate( self, axis_angle: impl Into<Vector<3>>, services: &mut Services, ) -> Self

Rotate the object

impl UpdateHalfEdge for HalfEdge

fn replace_start_vertex(&self, start_vertex: Handle<Vertex>) -> HalfEdge

Update the start vertex of the half-edge

fn replace_global_form(&self, global_form: Handle<GlobalEdge>) -> HalfEdge

Update the global form of the half-edge

impl Validate for HalfEdge

fn validate_with_config( &self, config: &ValidationConfig, errors: &mut Vec<ValidationError>, )

Validate the object

fn validate_and_return_first_error(&self) -> Result<(), ValidationError>

Validate the object using default config and return on first error

fn validate(&self, errors: &mut Vec<ValidationError>)

Validate the object using default configuration

impl Eq for HalfEdge

impl StructuralPartialEq for HalfEdge