Struct fj_kernel::objects::GlobalEdge

pub struct GlobalEdge { /* private fields */ }

An edge, defined in global (3D) coordinates

In contract to HalfEdge, GlobalEdge is undirected, meaning it has no defined direction, and its vertices have no defined order. This means it can be used to determine whether two HalfEdges map to the same GlobalEdge, regardless of their direction.

Implementations

impl GlobalEdge

pub fn new(
    curve: impl Into<HandleWrapper<GlobalCurve>>,
    vertices: [Handle<GlobalVertex>; 2]
) -> Self

Create a new instance

The order of vertices is irrelevant. Two GlobalEdges with the same curve and vertices will end up being equal, regardless of the order of vertices here.

pub fn curve(&self) -> &Handle<GlobalCurve>

Access the curve that defines the edge’s geometry

The edge can be a segment of the curve that is bounded by two vertices, or if the curve is continuous (i.e. connects to itself), the edge could be defined by the whole curve, and have no bounding vertices.

pub fn vertices(&self) -> &VerticesInNormalizedOrder

Access the vertices that bound the edge on the curve

As the name indicates, the order of the returned vertices is normalized and might not match the order of the vertices that were passed to GlobalEdge::new. You must not rely on the vertices being in any specific order.

Trait Implementations

impl Clone for GlobalEdge

fn clone(&self) -> GlobalEdge

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalEdge

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

Formats the value using the given formatter.

impl From<&GlobalEdge> for PartialGlobalEdge

fn from(global_edge: &GlobalEdge) -> Self

Converts to this type from the input type.

impl Get<GlobalCurve> for GlobalEdge

fn get(&self) -> Handle<GlobalCurve>

Access the referenced object

impl Get<GlobalEdge> for HalfEdge

fn get(&self) -> Handle<GlobalEdge>

Access the referenced object

impl HasPartial for GlobalEdge

type Partial = PartialGlobalEdge

The type representing the partial variant of this object

fn partial() -> Self::Partial

Create an empty partial variant of this object

fn to_partial(&self) -> Self::Partial

Convert this object into its partial variant

impl Hash for GlobalEdge

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 GlobalEdge

fn insert(
    self,
    objects: &Objects
) -> Result<Handle<Self>, <Self as Validate>::Error>

Insert the object into its respective store

impl Ord for GlobalEdge

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<GlobalEdge> for GlobalEdge

fn eq(&self, other: &GlobalEdge) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<GlobalEdge> for GlobalEdge

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Validate for GlobalEdge

type Error = Infallible

The error that validation of the implementing type can result in

fn validate_with_config(&self, _: &ValidationConfig) -> Result<(), Self::Error>

Validate the object

fn validate(&self) -> Result<(), Self::Error>

Validate the object using default configuration

impl Eq for GlobalEdge

impl StructuralEq for GlobalEdge

impl StructuralPartialEq for GlobalEdge