Struct 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(surface: Handle<Surface>, region: Handle<Region>) -> Self

Construct an instance of Face

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

Access the surface of the face

pub fn region(&self) -> &Handle<Region>

Access the region of the face

pub fn coord_handedness(&self, geometry: &Geometry) -> 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 AllHalfEdgesWithSurface for Face

fn all_half_edges_with_surface( &self, result: &mut Vec<(Handle<HalfEdge>, Handle<Surface>)>, )

Access all half-edges of the object, and the surface they’re on

impl Approx for &Face

type Approximation = FaceApprox

The approximation of the object

type Cache = HalfEdgeApproxCache

The cache used to cache approximation results

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

Approximate the object, using the provided cache

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

Approximate the object

impl BoundingVerticesOfHalfEdge for Face

fn bounding_vertices_of_half_edge( &self, half_edge: &Handle<HalfEdge>, ) -> Option<CurveBoundary<Vertex>>

Determine the bounding vertices of a half-edge

impl BoundingVolume<3> for Face

fn aabb(&self, geometry: &Geometry) -> Option<Aabb<3>>

Compute an axis-aligned bounding box (AABB)

impl BuildFace for Face

fn unbound(surface: Handle<Surface>, core: &mut Core) -> Face

Build a face with an empty exterior, no interiors, and no color

fn circle( surface: Handle<Surface>, center: impl Into<Point<2>>, radius: impl Into<Scalar>, core: &mut Core, ) -> Face

Build a circle

fn triangle(points: [impl Into<Point<3>>; 3], core: &mut Core) -> Polygon<3>

Build a triangle

fn polygon<P, Ps>(surface: Handle<Surface>, points: Ps, core: &mut Core) -> Face

where P: Into<Point<2>>, Ps: IntoIterator<Item = P>, Ps::IntoIter: Clone + ExactSizeIterator,

Build a polygon

impl Clone for Face

fn clone(&self) -> Face

Returns a duplicate 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 AnyObject<Bare>

fn from(object: Face) -> Self

Converts to this type from the input type.

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

type Inserted = Handle<Face>

The type of Self, once it has been inserted

fn insert(self, core: &mut Core) -> Self::Inserted

Insert the object into its respective store

impl IsObject for Face

type BareObject = Face

The type of the bare object

impl Ord for Face

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

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

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 ReplaceCurve for Face

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceHalfEdge for Face

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceVertex for Face

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl Reverse for Face

fn reverse(&self, core: &mut Core) -> Self

Reverse the direction/orientation of the object

impl ReverseCurveCoordinateSystems for Face

fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self

Reverse the direction of the curve coordinate systems within an object

impl TransformObject for Face

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

Transform the object using the provided cache

fn transform(&self, transform: &Transform, core: &mut Core) -> Self

Transform the object

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

Translate the object

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

Rotate the object

impl UpdateFace for Face

fn update_region<T>( &self, update: impl FnOnce(&Handle<Region>, &mut Core) -> T, core: &mut Core, ) -> Self

where T: Insert<Inserted = Handle<Region>>,

Update the region of the face

impl Validate for Face

fn validate( &self, config: &ValidationConfig, errors: &mut Vec<ValidationError>, geometry: &Geometry, )

Validate the object

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

Validate the object using default config and return on first error

impl ValidationCheck<Face> for FaceHasNoBoundary

fn check( object: &Face, _: &Geometry, _: &ValidationConfig, ) -> impl Iterator<Item = Self>

Run the validation check on the implementing object

fn check_and_return_first_error( object: &T, geometry: &Geometry, ) -> Result<(), Self>

Convenience method to run the check return the first error

fn check_and_expect_one_error(object: &T, geometry: &Geometry) -> Self

where Self: Display,

Convenience method to run the check and expect one error

impl Eq for Face

impl StructuralPartialEq for Face