Struct SurfaceSides

pub struct SurfaceSides { /* private fields */ }

Which parametric side of a surface curve a p-curve belongs to.

A surface curve is the intersection of two surfaces, so each side owns one surface and the p-curve that is that curve’s image in the surface’s own parameter domain. Pairing them here is what stops a consumer from having to guess which p-curve to trim with – a guess that would otherwise require re-inverting the surface, the exact operation the p-curve exists to avoid.

A single side is legitimate: not every edge has two parametric images.

Implementations

impl SurfaceSides

pub const fn one(surface: NodeId, pcurve: NodeId) -> Self

One parametric side: a surface and this curve’s image in it.

pub const fn two( first_surface: NodeId, first_pcurve: NodeId, second_surface: NodeId, second_pcurve: NodeId, ) -> Self

Both parametric sides, in the order the authoring format states them.

The order is load-bearing: it is what ParameterCurveS1 and ParameterCurveS2 name.

pub const fn first(&self) -> (NodeId, NodeId)

The first side as (surface, pcurve).

pub const fn second(&self) -> Option<(NodeId, NodeId)>

The second side as (surface, pcurve), if this curve has one.

pub const fn is_two_sided(&self) -> bool

Whether both parametric sides are present.

pub fn references(&self) -> Vec<NodeId>

Every node this pairing references, surfaces and p-curves alike.

Trait Implementations

impl Clone for SurfaceSides

fn clone(&self) -> SurfaceSides

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SurfaceSides

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

Formats the value using the given formatter.

impl Hash for SurfaceSides

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 PartialEq for SurfaceSides

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

impl StructuralPartialEq for SurfaceSides