Struct fj_kernel::objects::Face

pub struct Face { /* private fields */ }

A face of a shape

A Face is a bounded area of a Surface, the Surface itself being an infinite 2-dimensional object in 3D space. Faces are bound by one exterior cycle, which defines the outer boundary, and an arbitrary number of interior cycles (i.e. holes).

Face has a defined orientation, a front and a back side. When faces are combined into Shells, the face orientation defines what is inside and outside of the shell. This stands in contrast to Surface, which has no defined orientation.

You can look at a Face from two directions: front and back. The winding of the exterior cycle will be clockwise or counter-clockwise, depending on your perspective. The front side of the face, is the side where from which the exterior cycle appear counter-clockwise.

Interior cycles must have the opposite winding of the exterior cycle, meaning on the front side of the face, they must appear clockwise. This means that all HalfEdges that bound a Face have the interior of the face on their left side (on the face’s front side).

Implementations

impl Face

pub fn new(
    exterior: Handle<Cycle>,
    interiors: impl IntoIterator<Item = Handle<Cycle>>,
    color: Color
) -> Self

Construct a new instance of Face

pub fn surface(&self) -> &Handle<Surface>

Access this face’s surface

pub fn exterior(&self) -> &Handle<Cycle>

Access the cycle that bounds the face on the outside

pub fn interiors(&self) -> impl Iterator<Item = &Handle<Cycle>> + '_

Access the cycles that bound the face on the inside

Each of these cycles defines a hole in the face.

pub fn all_cycles(&self) -> impl Iterator<Item = &Handle<Cycle>> + '_

Access all cycles of this face

pub fn color(&self) -> Color

Access the color of the face

pub fn coord_handedness(&self) -> Handedness

Determine handed-ness of the face’s front-side coordinate system

A face is defined on a surface, which has a coordinate system. Since surfaces aren’t considered to have an orientation, their coordinate system can be considered to be left-handed or right-handed, depending on which side of the surface you’re looking at.

Faces do have an orientation, meaning they have definite front and back sides. The front side is the side, where the face’s exterior cycle is wound counter-clockwise.

Trait Implementations

impl Approx for &Face

type Approximation = FaceApprox

The approximation of the object

type Cache = CurveCache

The cache used to cache approximation results

fn approx_with_cache(
    self,
    tolerance: impl Into<Tolerance>,
    cache: &mut Self::Cache
) -> Self::Approximation

Approximate the object, using the provided cache

fn approx(self, tolerance: impl Into<Tolerance>) -> Self::Approximation

Approximate the object

impl Clone for Face

fn clone(&self) -> Face

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Face

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

Formats the value using the given formatter.

impl From<&Face> for PartialFace

fn from(face: &Face) -> Self

Converts to this type from the input type.

impl HasPartial for Face

type Partial = PartialFace

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 Face

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 Face

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

Insert the object into its respective store

impl Ord for Face

fn cmp(&self, other: &Face) -> 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<Face> for Face

fn eq(&self, other: &Face) -> 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<Face> for Face

fn partial_cmp(&self, other: &Face) -> 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 Face

type Error = FaceValidationError

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 Face

impl StructuralEq for Face

impl StructuralPartialEq for Face