Struct BSplineCurve 

pub struct BSplineCurve { /* private fields */ }

A B-spline curve, polynomial or rational.

Implementations

impl BSplineCurve

pub fn restricted_to_degree( &self, max_degree: usize, tolerance: f64, tol: Tolerances, ) -> OgeomResult<Fitted<Self>>

This curve at a degree no higher than max_degree, to a stated tolerance: itself where it already is, and otherwise a fit at its own parameters: what an exchange format with a degree limit needs written. Same-parameter with the original, error measured.

Errors

OgeomError::Construction if max_degree is zero, the curve is periodic (a ring has no ends to fit between), or the tolerance is not a distance.

impl BSplineCurve

pub fn new( knots: KnotVector, control: Vec<Point>, tol: Tolerances, ) -> OgeomResult<Self>

A polynomial B-spline from a knot vector and control points.

Errors

OgeomError::Dimension if the control point count disagrees with the knot vector.

pub fn rational( knots: KnotVector, control: Vec<Weighted<Point>>, ) -> OgeomResult<Self>

A rational B-spline from a knot vector and weighted control points.

Errors

OgeomError::Dimension if the control point count disagrees with the knot vector.

pub fn periodic( control: &[Point], degree: usize, tol: Tolerances, ) -> OgeomResult<Self>

A smoothly periodic B-spline through a ring of control points.

The ring is wrapped: the first degree controls repeat past the end over a uniform knot vector, and evaluation wraps its parameter, so the loop closes with degree - 1 continuous derivatives and no clamped seam. The domain runs one knot step per ring point.

Errors

OgeomError::Construction if the ring has no more points than the degree, or the degree is zero.

pub fn periodic_from_parts( knots: KnotVector, control: Vec<Weighted<Point>>, tol: Tolerances, ) -> OgeomResult<Self>

The exact periodic representation, as a reader restores it: wrapped knots and control, with the wrap verified rather than assumed.

Errors

As BSplineCurve::rational, and additionally if the trailing degree controls do not repeat the leading ones; an unwrapped ring evaluated periodically would tear at the seam.

pub const fn knots(&self) -> &KnotVector

The knot vector.

pub fn control_points(&self) -> &[Weighted<Point>]

The weighted control points.

pub const fn is_rational(&self) -> bool

Whether the weights differ, so the curve is genuinely rational.

pub const fn degree(&self) -> usize

The degree.

pub fn with_knot_inserted( &self, u: f64, count: usize, tol: Tolerances, ) -> OgeomResult<Self>

Insert a knot without moving the curve.

Errors

As [bspline::insert_knot].

pub fn elevated(&self, tol: Tolerances) -> OgeomResult<Self>

Raise the degree without moving the curve.

Errors

As [bspline::elevate_degree].

pub fn reseamed_at(&self, u: f64, tol: Tolerances) -> OgeomResult<Self>

The same closed curve with its seam moved to u: what was the stretch from u to the end now comes first, and the stretch from the start to u follows it, joined where the old seam was. The domain keeps its length and begins at u.

Errors

OgeomError::Construction if the curve is periodic (its seam is nowhere) or does not close, its two ends apart by more than a thousand confusions; as [bspline::split] if u is an end of the domain.

pub fn extended( &self, at_end: bool, length: f64, continuity: usize, tol: Tolerances, ) -> OgeomResult<Self>

This curve continued past one end by length in space: the polynomial continuation of its own end derivatives to the order continuity, joined on. A polynomial run of degree at most that order continues as itself, and so does a rational arc’s homogeneous polynomial: a circle arc continued at order two stays on its circle.

The continuation’s parameter span is solved until its arc length is length. Extended at the start, the original run keeps its parameters and the domain grows downward.

Errors

OgeomError::Construction if the curve is periodic (it has no end to continue from) or stands still at that end; as [bspline::extend].

pub fn extended_to( &self, at_end: bool, target: Point, continuity: usize, tol: Tolerances, ) -> OgeomResult<Self>

This curve continued past one end to target: a piece carrying the curve’s end derivatives to the order continuity and ending at the point, joined on. Extended at the start, the original run keeps its parameters and the domain grows downward.

Errors

OgeomError::Construction if the curve is periodic, stands still at that end, or already ends at target; as [bspline::extend_to].

pub fn segment(&self, range: (f64, f64), tol: Tolerances) -> OgeomResult<Self>

The piece of this curve over range, exactly and keeping its parameters: the piece at t is this curve at t.

Errors

OgeomError::Domain if range is empty or leaves the domain.

pub fn split_at(&self, u: f64, tol: Tolerances) -> OgeomResult<(Self, Self)>

Split into two curves meeting at u.

Errors

As [bspline::split].

Trait Implementations

impl Clone for BSplineCurve

fn clone(&self) -> BSplineCurve

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Curve3d for BSplineCurve

fn continuity(&self) -> Continuity

Continuity across the whole curve.

A degree-p B-spline is C^(p - m) at an interior knot of multiplicity m, and the worst interior knot governs the curve. With no interior knots at all the curve is a single polynomial piece and so genuinely smooth to every order.

Higher orders than C2 report as C2, which is the highest Continuity names short of CInfinity. Reporting CInfinity for a merely-C3 curve would be a claim that is false, and the distinction above C2 is not one any algorithm here asks about.

fn domain(&self) -> (f64, f64)

The parameter interval over which the curve is defined.

fn point_at(&self, u: f64, tol: Tolerances) -> OgeomResult<Point>

The point at u.

fn d1_at(&self, u: f64, tol: Tolerances) -> OgeomResult<Vector>

The first derivative at u.

fn derivatives_at( &self, u: f64, n: usize, tol: Tolerances, ) -> OgeomResult<Vec<Vector>>

Derivatives up to order n, with result[0] the point itself.

fn kind(&self) -> CurveKind

What kind of curve this is.

fn is_closed(&self, tol: Tolerances) -> bool

Whether the curve’s ends meet.

fn is_periodic(&self) -> bool

Whether the curve continues past its domain by repeating.

fn tangent_at(&self, u: f64, tol: Tolerances) -> OgeomResult<Direction>

The unit tangent at u.

fn curvature_at(&self, u: f64, tol: Tolerances) -> OgeomResult<f64>

The curvature at u.

fn start(&self, tol: Tolerances) -> OgeomResult<Point>

The start point.

fn end(&self, tol: Tolerances) -> OgeomResult<Point>

The end point.

fn normalize_parameter(&self, u: f64, tol: Tolerances) -> OgeomResult<f64>

Bring u into the domain, wrapping if the curve is periodic.

impl Debug for BSplineCurve

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

Formats the value using the given formatter.

impl From<BSplineCurve> for Curve

fn from(c: BSplineCurve) -> Self

Converts to this type from the input type.

impl PartialEq for BSplineCurve

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