Enum CoonsRefusal 

pub enum CoonsRefusal {
    DegenerateBoundary {
        boundary: usize,
        extent: f64,
        band: f64,
    },
    CornerGap {
        corner: usize,
        gap: f64,
        band: f64,
    },
    CornerWeightClosure {
        ratio: f64,
        band: f64,
    },
    NonPositiveWeight {
        row: usize,
        column: usize,
        weight: f64,
    },
    Incompatible {
        direction: char,
        detail: String,
    },
    RationalRibbon {
        boundary: usize,
        weight_spread: f64,
    },
    RibbonCornerTangent {
        corner: usize,
        gap: f64,
        band: f64,
    },
    RibbonPairing {
        direction: char,
        prescribed: usize,
    },
    Geometry(String),
}

A Coons constructor’s refusal, with the measurement that caused it.

Following the kernel’s fail-safe contract: where the construction cannot be certified it refuses, and the refusal carries the number a caller (or a test, or a user) needs in order to act — never a bare “failed”.

Variants

DegenerateBoundary

Boundary boundary has no extent: it is a point, not a curve.

Fields

boundary: usize

extent: f64

band: f64

CornerGap

Boundary corner’s end does not meet boundary (corner + 1) % 4’s start. gap is the measured distance between them.

Fields

corner: usize

gap: f64

band: f64

CornerWeightClosure

The four boundaries are rational and their corner weights cannot all be matched by re-scaling: going once round the loop multiplies the weights by ratio instead of 1. A Moebius re-parameterisation of one boundary would fix it, at the cost of that boundary’s parameterisation — which this constructor will not change behind the caller’s back.

Fields

ratio: f64

band: f64

NonPositiveWeight

The blend put a control point at or beyond infinity: the rational net weight at (row, column) is not positive. Two opposite boundaries whose rational shoulder weights are small enough (arcs approaching a half turn) cancel the corner bilinear’s weight entirely.

Fields

row: usize

column: usize

weight: f64

Incompatible

Degree/knot compatibility could not be reached exactly in the named direction.

Fields

direction: char

detail: String

RationalRibbon

The ribbon constructor was handed rational geometry. A prescribed 3D cross-derivative does not determine a homogeneous ribbon, so this is refused rather than approximated. weight_spread is the measured max |w - 1| over the offending curve’s control points.

Fields

boundary: usize

weight_spread: f64

RibbonCornerTangent

A ribbon disagrees with the boundary tangent it starts or ends on, so no patch can carry both. gap is the measured vector difference.

Fields

corner: usize

gap: f64

band: f64

RibbonPairing

Ribbons were prescribed on one boundary of a direction but not its opposite. A direction is blended cubically or linearly as a whole, so half a pair has no meaning; give both or neither.

Fields

direction: char

prescribed: usize

Geometry(String)

An underlying kernel geometry error, verbatim.

Trait Implementations

impl Clone for CoonsRefusal

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CoonsRefusal

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

Formats the value using the given formatter.

impl Display for CoonsRefusal

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

Formats the value using the given formatter.

impl From<CoonsRefusal> for String

The lossy exit for stringly callers, exactly like crate::KernelRefusal’s.

fn from(refusal: CoonsRefusal) -> Self

Converts to this type from the input type.

impl PartialEq for CoonsRefusal

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CoonsRefusal