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

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 Object<Bare>

fn from(object: GlobalEdge) -> Self

Converts to this type from the input type.

impl HasPartial for GlobalEdge

type Partial = PartialGlobalEdge

The type representing the partial variant of this object

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: &mut Service<Objects>) -> Handle<Self>

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 TransformObject for GlobalEdge

fn transform_with_cache(
    self,
    transform: &Transform,
    objects: &mut Service<Objects>,
    cache: &mut TransformCache
) -> Self

Transform the object using the provided cache

fn transform(self, transform: &Transform, objects: &mut Service<Objects>) -> Self

Transform the object

fn translate(
    self,
    offset: impl Into<Vector<3>>,
    objects: &mut Service<Objects>
) -> Self

Translate the object

fn rotate(
    self,
    axis_angle: impl Into<Vector<3>>,
    objects: &mut Service<Objects>
) -> Self

Rotate the object

impl Validate for GlobalEdge

fn validate_with_config(&self, _: &ValidationConfig, _: &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 GlobalEdge

impl StructuralEq for GlobalEdge

impl StructuralPartialEq for GlobalEdge