Struct EdgeData 

pub struct EdgeData {
    pub tolerance: Tolerance,
    pub representations: SmallVec<[EdgeRepr; 3]>,
    pub degenerate: bool,
    /* private fields */
}

An edge: a tolerance, a set of representations, and the flags that say whether they agree.

Fields

tolerance: Tolerance

The radius within which the edge lies.

representations: SmallVec<[EdgeRepr; 3]>

Every way this edge is described. See the module documentation.

degenerate: bool

Whether the edge has no length: a cone’s apex, a sphere’s pole.

A degenerate edge still bounds a face in parameter space even though it covers no distance in space, which is why it exists rather than being dropped.

Implementations

impl EdgeData

pub fn new() -> Self

An edge with no representations yet.

pub fn on_curve(curve: CurveId, location: Location, range: (f64, f64)) -> Self

An edge on a curve in space.

pub fn add(&mut self, repr: EdgeRepr)

Add a representation.

Adding one invalidates the EdgeData::same_parameter claim: the new representation has not been shown to agree with the others. Re-establish it deliberately, with EdgeData::assert_same_parameter.

pub const fn same_parameter(&self) -> bool

Whether every representation agrees on parameterization.

The claim is that curve3d(t) and surface(pcurve(t)) are the same point, within the edge’s tolerance, for the same t. It matters because nearly every algorithm evaluates whichever representation is convenient and assumes the answer is interchangeable.

It can be false (an imported edge whose pcurve was fitted independently of its 3D curve routinely is), which is why it is a flag to be checked rather than an invariant to be assumed.

pub const fn assert_same_parameter(&mut self, agrees: bool)

Record that the representations have been checked and agree.

Only for a caller that has actually verified it: evaluate each representation at the same parameters and confirm they land within the edge’s tolerance of one another. Setting it without checking is how an edge ends up with a pcurve that does not follow its own curve, and nothing downstream will notice until a face fails to close.

pub fn curve3d(&self) -> Option<&EdgeRepr>

The representation on a given curve in space, if any.

pub fn pcurve_on(&self, surface: SurfaceId) -> Option<&EdgeRepr>

The representation in surface’s parameter space, if any.

pub fn pcurve_for( &self, surface: SurfaceId, location: &Location, ) -> Option<&EdgeRepr>

The representation in surface’s parameter space for an occurrence at location.

One edge node can bound one face at more than one placement (the top and bottom of a prism are the same edge, moved), and those two occurrences run along different lines of the same parameter space. Asked by surface alone, the lookup returns whichever was attached first and both ends of the prism collapse onto one.

Falls back to a representation attached without a placement, which is what every unplaced edge has and what keeps the simple case simple.

pub fn parametric_surfaces(&self) -> Vec<SurfaceId>

Every surface this edge has a pcurve on.

pub fn widen(&mut self, to: Tolerance)

Widen this edge’s tolerance.

Trait Implementations

impl Clone for EdgeData

fn clone(&self) -> EdgeData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeData

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

Formats the value using the given formatter.

impl Default for EdgeData

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for EdgeData

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