Struct BSpline

pub struct BSpline {
    pub degree: usize,
    pub knots: Vec<f64>,
    pub control_points: Vec<Vec<f64>>,
}

B-Spline

Description

: B-Spline is a generalization of Bezier curve.

Caution

• Let K = the number of knots, C = the number of control points
• For open, K = C + degree + 1 (C = K - degree - 1)
• For clamped, K + 2 * degree = C + degree + 1 (C = K + degree - 1)

Example

use peroxide::fuga::*;
use anyhow::Result;

fn main() -> Result<()> {
    let degree = 3;
    let knots = vec![0f64, 0.5, 1f64];
    let control_points = vec![
        vec![0f64, 0f64],
        vec![0.3, 0.5],
        vec![0.5, 0.7],
        vec![0.7, 0.3],
        vec![1f64, 1f64],
    ];
    let spline = BSpline::clamped(degree, knots, control_points)?;
     
    let t = linspace(0f64, 1f64, 100);
    let (x, y): (Vec<f64>, Vec<f64>) = spline.eval_vec(&t).into_iter().unzip();
    assert_eq!(x.len(), 100);
    assert_eq!(y.len(), 100);

    Ok(())
}

Fields

degree: usize

knots: Vec<f64>

control_points: Vec<Vec<f64>>

Implementations

impl BSpline

pub fn open( degree: usize, knots: Vec<f64>, control_points: Vec<Vec<f64>>, ) -> Result<Self>

Create new open B-Spline

Arguments

• degree - Degree of B-Spline
• knots - Knots (length = K)
• control_points - Control points (length = C)

Caution

• K = C + degree + 1 (C = K - degree - 1)

pub fn clamped( degree: usize, knots: Vec<f64>, control_points: Vec<Vec<f64>>, ) -> Result<Self>

Create new clamped B-Spline

Arguments

• degree - Degree of B-Spline
• knots - Knots (length = K)
• control_points - Control points (length = C)

Caution

• K + 2 * degree = C + degree + 1 (C = K + degree - 1)

pub fn cox_de_boor(&self, t: f64, i: usize) -> f64

Obtain basis function via Cox-de Boor algorithm

Trait Implementations

impl Archive for BSpline

where usize: Archive, Vec<f64>: Archive, Vec<Vec<f64>>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedBSpline

The archived representation of this type.

type Resolver = BSplineResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for BSpline

fn clone(&self) -> BSpline

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BSpline

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

Formats the value using the given formatter.

impl Default for BSpline

fn default() -> BSpline

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BSpline

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<BSpline, __D> for Archived<BSpline>

where usize: Archive, <usize as Archive>::Archived: Deserialize<usize, __D>, Vec<f64>: Archive, <Vec<f64> as Archive>::Archived: Deserialize<Vec<f64>, __D>, Vec<Vec<f64>>: Archive, <Vec<Vec<f64>> as Archive>::Archived: Deserialize<Vec<Vec<f64>>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<BSpline, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for BSpline

where usize: Serialize<__S>, Vec<f64>: Serialize<__S>, Vec<Vec<f64>>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for BSpline

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Spline<(f64, f64)> for BSpline

fn eval(&self, t: f64) -> (f64, f64)

fn eval_vec(&self, v: &[f64]) -> Vec<T>

fn eval_with_cond<F: Fn(T) -> T>(&self, t: f64, cond: F) -> T

fn eval_vec_with_cond<F: Fn(T) -> T + Copy>(&self, t: &[f64], cond: F) -> Vec<T>