Struct truck_geometry::nurbs::BSplineSurface

pub struct BSplineSurface<V> { /* fields omitted */ }

B-spline surface

Examples

use truck_geometry::*;
const N : usize = 100; // sample size in test

// the knot vectors
let knot_vec0 = KnotVec::bezier_knot(3);
let knot_vec1 = KnotVec::from(
    vec![0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0]
);
let knot_vecs = (knot_vec0, knot_vec1);

// the control points
let mut v = vec![vec![Vector4::zero(); 7]; 4];
v[0][0] = Vector4::new(0.0, 0.0, 1.0, 1.0);
v[0][1] = &v[0][0] / 3.0;
v[0][2] = v[0][1].clone();
v[0][3] = v[0][0].clone();
v[0][4] = v[0][1].clone();
v[0][5] = v[0][1].clone();
v[0][6] = v[0][0].clone();
v[1][0] = Vector4::new(2.0, 0.0, 1.0, 1.0) / 3.0;
v[1][1] = Vector4::new(2.0, 4.0, 1.0, 1.0) / 9.0;
v[1][2] = Vector4::new(-2.0, 4.0, 1.0, 1.0) / 9.0;
v[1][3] = Vector4::new(-2.0, 0.0, 1.0, 1.0) / 3.0;
v[1][4] = Vector4::new(-2.0, -4.0, 1.0, 1.0) / 9.0;
v[1][5] = Vector4::new(2.0, -4.0, 1.0, 1.0) / 9.0;
v[1][6] = Vector4::new(2.0, 0.0, 1.0, 1.0) / 3.0;
v[2][0] = Vector4::new(2.0, 0.0, -1.0, 1.0) / 3.0;
v[2][1] = Vector4::new(2.0, 4.0, -1.0, 1.0) / 9.0;
v[2][2] = Vector4::new(-2.0, 4.0, -1.0, 1.0) / 9.0;
v[2][3] = Vector4::new(-2.0, 0.0, -1.0, 1.0) / 3.0;
v[2][4] = Vector4::new(-2.0, -4.0, -1.0, 1.0) / 9.0;
v[2][5] = Vector4::new(2.0, -4.0, -1.0, 1.0) / 9.0;
v[2][6] = Vector4::new(2.0, 0.0, -1.0, 1.0) / 3.0;
v[3][0] = Vector4::new(0.0, 0.0, -1.0, 1.0);
v[3][1] = &v[3][0] / 3.0;
v[3][2] = v[3][1].clone();
v[3][3] = v[3][0].clone();
v[3][4] = v[3][1].clone();
v[3][5] = v[3][1].clone();
v[3][6] = v[3][0].clone();

// cunstruct the B-spline curve
let bspline = BSplineSurface::new(knot_vecs, v);

// This B-spline curve is a nurbs representation of the unit sphere.
for i in 0..N {
    for j in 0..N {
        let u = 1.0 / (N as f64) * (i as f64);
        let v = 1.0 / (N as f64) * (j as f64);
        let v = bspline.subs(u, v); // We can use the instances as a function.
        let c = (v[0] / v[3]).powi(2) + (v[1] / v[3]).powi(2) + (v[2] / v[3]).powi(2);
        assert_near2!(c, 1.0);
    }
}

Implementations

impl<P> BSplineSurface<P>

pub fn new(
    knot_vecs: (KnotVec, KnotVec),
    control_points: Vec<Vec<P>>
) -> BSplineSurface<P>

constructor.

Arguments

• knot_vecs - the knot vectors
• control_points - the vector of the control points

Panics

There are 3 rules for construct B-spline curve.

• The number of knots is more than the one of control points.
• There exist at least two different knots.
• There are at least one control point.

pub fn try_new(
    knot_vecs: (KnotVec, KnotVec),
    control_points: Vec<Vec<P>>
) -> Result<BSplineSurface<P>>

constructor.

Arguments

• knot_vecs - the knot vectors
• control_points - the vector of the control points

Failures

There are 3 rules for construct B-spline curve.

• The number of knots is more than the one of control points.
• There exist at least two different knots.
• There are at least one control point.

pub const fn new_unchecked(
    knot_vecs: (KnotVec, KnotVec),
    control_points: Vec<Vec<P>>
) -> BSplineSurface<P>

constructor.

Arguments

• knot_vecs - the knot vectors
• control_points - the vector of the control points

Failures

This method is prepared only for performance-critical development and is not recommended.
This method does NOT check the 3 rules for constructing B-spline surface.
The programmer must guarantee these conditions before using this method.

pub fn debug_new(
    knot_vecs: (KnotVec, KnotVec),
    control_points: Vec<Vec<P>>
) -> BSplineSurface<P>

constructor.

Arguments

• knot_vecs - the knot vectors
• control_points - the vector of the control points

Failures

This method checks the 3 rules for constructing B-spline surface in the debug mode.
The programmer must guarantee these conditions before using this method.

pub fn knot_vecs(&self) -> &(KnotVec, KnotVec)

Returns the reference of the knot vectors

pub fn uknot_vec(&self) -> &KnotVec

Returns the u knot vector.

pub fn vknot_vec(&self) -> &KnotVec

Returns the v knot vector.

pub fn uknot(&self, idx: usize) -> f64

Returns the idxth u knot.

pub fn vknot(&self, idx: usize) -> f64

returns the idxth v knot.

pub fn control_points(&self) -> &Vec<Vec<P>>

Returns the reference of the vector of the control points

pub fn control_point(&self, idx0: usize, idx1: usize) -> &P

Returns the reference of the control point corresponding to the index (idx0, idx1).

pub fn transform_control_points<F: FnMut(&mut P)>(&mut self, f: F)

Apply the given transformation to all control points.

pub fn ctrl_pts_row_iter(
    &self,
    column_idx: usize
) -> impl ExactSizeIterator<Item = &P> + FusedIterator<Item = &P>

Returns the iterator over the control points in the column_idxth row.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let mut iter = bspsurface.ctrl_pts_row_iter(1);
assert_eq!(iter.next(), Some(&Vector3::new(1.0, 0.0, 1.0)));
assert_eq!(iter.next(), Some(&Vector3::new(1.0, 1.0, 1.0)));
assert_eq!(iter.next(), None);

pub fn ctrl_pts_column_iter(&self, row_idx: usize) -> Iter<'_, P>

Returns the iterator over the control points in the row_idxth row.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let mut iter = bspsurface.ctrl_pts_column_iter(1);
assert_eq!(iter.next(), Some(&Vector3::new(0.0, 1.0, 0.0)));
assert_eq!(iter.next(), Some(&Vector3::new(1.0, 1.0, 1.0)));
assert_eq!(iter.next(), Some(&Vector3::new(2.0, 1.0, 2.0)));
assert_eq!(iter.next(), None);

pub fn control_point_mut(&mut self, idx0: usize, idx1: usize) -> &mut P

Returns the mutable reference of the control point corresponding to index (idx0, idx1).

pub fn control_points_mut(&mut self) -> impl Iterator<Item = &mut P>

Returns the iterator on all control points

pub fn udegree(&self) -> usize

Returns the degrees of B-spline surface

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);
let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
assert_eq!(bspsurface.udegree(), 1);

pub fn vdegree(&self) -> usize

Returns the degrees of B-spline surface

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);
let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
assert_eq!(bspsurface.vdegree(), 2);

pub fn degrees(&self) -> (usize, usize)

Returns the degrees of B-spline surface

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::from(vec![0.0, 0.0, 1.0, 1.0]);
let vknot_vec = KnotVec::from(vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
assert_eq!(bspsurface.degrees(), (1, 2));

pub fn is_clamped(&self) -> bool

Returns whether the knot vectors are clamped or not.

pub fn swap_axes(&mut self) -> &mut Self where
    P: Clone, 

Swaps two parameters.

Examples

use truck_geometry::*;
let knot_vecs0 = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts0 = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let mut bspsurface0 = BSplineSurface::new(knot_vecs0, ctrl_pts0);

let knot_vecs1 = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(1));
let ctrl_pts1 = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 1.0)],
    vec![Vector2::new(0.5, -1.0), Vector2::new(0.5, 2.0)],
    vec![Vector2::new(1.0, 0.0), Vector2::new(1.0, 1.0)],
];
let mut bspsurface1 = BSplineSurface::new(knot_vecs1, ctrl_pts1);
assert_eq!(bspsurface0.swap_axes(), &bspsurface1);

pub fn parameter_range(&self) -> ((f64, f64), (f64, f64))

The range of the parameter of the surface.

pub fn column_curve(&self, row_idx: usize) -> BSplineCurve<P> where
    P: Clone, 

Creates the curve whose control points are the idxth column control points of self.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let bspcurve = bspsurface.column_curve(1);

assert_eq!(bspcurve.knot_vec(), &KnotVec::bezier_knot(2));
assert_eq!(
    bspcurve.control_points(),
    &vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
);

pub fn row_curve(&self, column_idx: usize) -> BSplineCurve<P> where
    P: Clone, 

Creates the column sectional curve.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let bspcurve = bspsurface.row_curve(1);

assert_eq!(bspcurve.knot_vec(), &KnotVec::bezier_knot(1));
assert_eq!(
    bspcurve.control_points(),
    &vec![Vector3::new(1.0, 0.0, 1.0), Vector3::new(1.0, 1.0, 1.0)],
);

impl<P: ControlPoint<f64>> BSplineSurface<P>

pub fn get_closure(&self) -> impl Fn(f64, f64) -> P + '_

Returns the closure of substitution.

pub fn uderivation(&self) -> BSplineSurface<P::Diff>

Calculate derived B-spline surface by the first parameter u.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let uderivation = bspsurface.uderivation();

// bspsurface: (v, 2v(1 - v)(2u - 1) + u), uderivation: (0.0, 4v(1 - v) + 1)
const N: usize = 100; // sample size
for i in 1..N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            uderivation.subs(u, v),
            Vector2::new(0.0, 4.0 * v * (1.0 - v) + 1.0),
        );
    }
}

pub fn vderivation(&self) -> BSplineSurface<P::Diff>

Calculate derived B-spline surface by the second parameter v.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let vderivation = bspsurface.vderivation();

// bspsurface: (v, 2v(1 - v)(2u - 1) + u), vderivation: (1, -2(2u - 1)(2v - 1))
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            vderivation.subs(u, v),
            Vector2::new(1.0, -2.0 * (2.0 * u - 1.0) * (2.0 * v - 1.0)),
        );
    }
}

impl<V: Tolerance> BSplineSurface<V>

pub fn is_const(&self) -> bool

Returns whether all control points are same or not. If the knot vector is clamped, it means whether the curve is constant or not.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let pt = Vector2::new(1.0, 2.0);
let ctrl_pts = vec![
    vec![pt.clone(), pt.clone(), pt.clone()],
    vec![pt.clone(), pt.clone(), pt.clone()],
];
let mut bspsurface = BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts);
assert!(bspsurface.is_const());

*bspsurface.control_point_mut(1, 2) = Vector2::new(2.0, 3.0);
assert!(!bspsurface.is_const());

Remarks

If the knot vector is not clamped and the BSpline basis function is not partition of unity, then perhaps returns true even if the surface is not constant.

use truck_geometry::*;
let uknot_vec = KnotVec::uniform_knot(1, 5);
let vknot_vec = KnotVec::uniform_knot(1, 5);
let pt = Vector2::new(1.0, 2.0);
let ctrl_pts = vec![
    vec![pt.clone(), pt.clone(), pt.clone()],
    vec![pt.clone(), pt.clone(), pt.clone()],
];
let mut bspsurface = BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts);

// bspsurface is not constant.
assert_eq!(bspsurface.subs(0.0, 0.0), Vector2::new(0.0, 0.0));
assert_ne!(bspsurface.subs(0.5, 0.5), Vector2::new(0.0, 0.0));

// bspsurface.is_const() is true.
assert!(bspsurface.is_const());

impl<P: ControlPoint<f64> + Tolerance> BSplineSurface<P>

pub fn add_uknot(&mut self, x: f64) -> &mut Self

Adds a knot x of the first parameter u, and do not change self as a surface.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();
bspsurface.add_uknot(0.0).add_uknot(0.3).add_uknot(0.5).add_uknot(1.0);
assert!(bspsurface.near2_as_surface(&org_surface));
assert_eq!(bspsurface.uknot_vec().len(), org_surface.uknot_vec().len() + 4);

pub fn add_vknot(&mut self, x: f64) -> &mut Self

add a knot x for the second parameter, and do not change self as a surface.
Return false if cannot add the knot, i.e.

• the index of x will be lower than the degree, or
• the index of x will be higher than the number of control points.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();
bspsurface.add_vknot(0.0).add_vknot(0.3).add_vknot(0.5).add_vknot(1.0);
assert!(bspsurface.near2_as_surface(&org_surface));
assert_eq!(bspsurface.vknot_vec().len(), org_surface.vknot_vec().len() + 4);

pub fn try_remove_uknot(&mut self, idx: usize) -> Result<&mut Self>

Removes the uknot corresponding to the indice idx, and do not change self as a curve.
If the knot cannot be removed, returns Error::CannotRemoveKnot.

Examples

use truck_geometry::*;
use errors::Error;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

bspsurface.add_uknot(0.3).add_uknot(0.5);

assert!(bspsurface.try_remove_uknot(3).is_ok());
assert_eq!(bspsurface.try_remove_uknot(2), Err(Error::CannotRemoveKnot(2)));

assert_eq!(bspsurface.uknot_vec().len(), org_surface.uknot_vec().len() + 1);
assert!(bspsurface.near2_as_surface(&org_surface));

pub fn remove_uknot(&mut self, idx: usize) -> &mut Self

Removes the uknot corresponding to the indices idx, and do not change self as a curve. If cannot remove the knot, do not change self and return self.

Examples

use truck_geometry::*;
use errors::Error;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

bspsurface.add_uknot(0.3).add_uknot(0.5);
bspsurface.remove_uknot(3).remove_uknot(3);

assert!(bspsurface.near2_as_surface(&org_surface));
assert_eq!(bspsurface.uknot_vec().len(), org_surface.uknot_vec().len())

pub fn try_remove_vknot(&mut self, idx: usize) -> Result<&mut Self>

Removes a vknot corresponding to the indice idx, and do not change self as a curve.
If the knot cannot be removed, returns Error::CannotRemoveKnot.

Examples

use truck_geometry::*;
use errors::Error;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

bspsurface.add_vknot(0.3).add_vknot(0.5);
assert!(bspsurface.try_remove_vknot(3).is_ok());
assert_eq!(bspsurface.try_remove_vknot(2), Err(Error::CannotRemoveKnot(2)));

assert!(bspsurface.near2_as_surface(&org_surface));
assert_eq!(bspsurface.vknot_vec().len(), org_surface.vknot_vec().len() + 1);

pub fn remove_vknot(&mut self, idx: usize) -> &mut Self

Removes a uknot corresponding to the indices idx, and do not change self as a curve. If cannot remove the knot, do not change self and return self.

Examples

use truck_geometry::*;
use errors::Error;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

bspsurface.add_vknot(0.3).add_vknot(0.5);
bspsurface.remove_vknot(3).remove_vknot(3);

assert!(bspsurface.near2_as_surface(&org_surface));
assert_eq!(bspsurface.vknot_vec().len(), org_surface.vknot_vec().len())

pub fn elevate_vdegree(&mut self) -> &mut Self

Elevates the vdegree.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

bspsurface.elevate_vdegree();

assert_eq!(bspsurface.udegree(), org_surface.udegree());
assert_eq!(bspsurface.vdegree(), org_surface.vdegree() + 1);
assert!(bspsurface.near2_as_surface(&org_surface));

pub fn elevate_udegree(&mut self) -> &mut Self

Elevates the udegree.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

bspsurface.elevate_udegree();

assert_eq!(bspsurface.udegree(), org_surface.udegree() + 1);
assert_eq!(bspsurface.vdegree(), org_surface.vdegree());
assert!(bspsurface.near2_as_surface(&org_surface));

pub fn syncro_uvdegrees(&mut self) -> &mut Self

Aligns the udegree with the same degrees.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

assert_ne!(bspsurface.udegree(), bspsurface.vdegree());
bspsurface.syncro_uvdegrees();
assert_eq!(bspsurface.udegree(), bspsurface.vdegree());
assert!(bspsurface.near2_as_surface(&org_surface));

pub fn syncro_uvknots(&mut self) -> &mut Self

Makes the uknot vector and the vknot vector the same knot vector.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::uniform_knot(1, 2);
let vknot_vec = KnotVec::bezier_knot(2);
let knot_vecs = (uknot_vec, vknot_vec);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 0.0, 1.0), Vector3::new(2.0, 0.0, 2.0)],
    vec![Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 1.0, 1.0), Vector3::new(2.0, 1.0, 2.0)],
    vec![Vector3::new(0.0, 2.0, 0.0), Vector3::new(1.0, 2.0, 1.0), Vector3::new(2.0, 2.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let org_surface = bspsurface.clone();

assert_ne!(bspsurface.uknot_vec(), bspsurface.vknot_vec());
bspsurface.syncro_uvknots();
assert_eq!(bspsurface.uknot_vec(), bspsurface.vknot_vec());
assert!(bspsurface.near2_as_surface(&org_surface));

pub fn ucut(&mut self, u: f64) -> BSplineSurface<P>

Cuts the surface into two surfaces at the parameter u

Examples

use truck_geometry::*;

let knot_vec0 = KnotVec::uniform_knot(2, 2);
let knot_vec1 = KnotVec::uniform_knot(2, 2);
let ctrl_pts0 = vec![
    Vector2::new(0.0, 0.0), Vector2::new(0.5, 0.0), Vector2::new(2.0, 0.0), Vector2::new(2.5, 0.0),
];
let ctrl_pts1 = vec![
    Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(2.0, 1.0), Vector2::new(2.5, 1.0),
];
let ctrl_pts2 = vec![
    Vector2::new(0.0, 1.5), Vector2::new(0.5, 1.5), Vector2::new(2.0, 1.5), Vector2::new(2.5, 1.5),
];
let ctrl_pts3 = vec![
    Vector2::new(0.0, 2.5), Vector2::new(0.5, 2.5), Vector2::new(2.0, 2.5), Vector2::new(2.5, 2.5),
];
let ctrl_pts = vec![ctrl_pts0, ctrl_pts1, ctrl_pts2, ctrl_pts3];
let bspsurface = BSplineSurface::new((knot_vec0, knot_vec1), ctrl_pts);

let mut part0 = bspsurface.clone();
let part1 = part0.ucut(0.68);
const N: usize = 100;
for i in 0..=N {
    for j in 0..=N {
        let u = 0.68 * (i as f64) / (N as f64);
        let v = 1.0 * (j as f64) / (N as f64);
        assert_near2!(bspsurface.subs(u, v), part0.subs(u, v));
    }
}
for i in 0..=N {
    for j in 0..=N {
        let u = 0.68 + 0.32 * (i as f64) / (N as f64);
        let v = 1.0 * (j as f64) / (N as f64);
        assert_near2!(bspsurface.subs(u, v), part1.subs(u, v));
    }
}

pub fn vcut(&mut self, v: f64) -> BSplineSurface<P>

Cuts the curve to two curves at the parameter t

Examples

use truck_geometry::*;

let knot_vec0 = KnotVec::uniform_knot(2, 2);
let knot_vec1 = KnotVec::uniform_knot(2, 2);
let ctrl_pts0 = vec![
    Vector2::new(0.0, 0.0), Vector2::new(0.5, 0.0), Vector2::new(2.0, 0.0), Vector2::new(2.5, 0.0),
];
let ctrl_pts1 = vec![
    Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(2.0, 1.0), Vector2::new(2.5, 1.0),
];
let ctrl_pts2 = vec![
    Vector2::new(0.0, 1.5), Vector2::new(0.5, 1.5), Vector2::new(2.0, 1.5), Vector2::new(2.5, 1.5),
];
let ctrl_pts3 = vec![
    Vector2::new(0.0, 2.5), Vector2::new(0.5, 2.5), Vector2::new(2.0, 2.5), Vector2::new(2.5, 2.5),
];
let ctrl_pts = vec![ctrl_pts0, ctrl_pts1, ctrl_pts2, ctrl_pts3];
let bspsurface = BSplineSurface::new((knot_vec0, knot_vec1), ctrl_pts);

let mut part0 = bspsurface.clone();
let part1 = part0.vcut(0.68);
const N: usize = 100;
for i in 0..=N {
    for j in 0..=N {
        let u = 1.0 * (i as f64) / (N as f64);
        let v = 0.68 * (j as f64) / (N as f64);
        assert_near2!(bspsurface.subs(u, v), part0.subs(u, v));
    }
}
for i in 0..=N {
    for j in 0..=N {
        let u = 1.0 * (i as f64) / (N as f64);
        let v = 0.68 + 0.32 * (j as f64) / (N as f64);
        assert_near2!(bspsurface.subs(u, v), part1.subs(u, v));
    }
}

pub fn sectional_curve(&self, bnd_box: BoundingBox<Vector2>) -> BSplineCurve<P>

Creates a sectional curve with normalized knot vector from the parameter p to the parameter q.

Examples

use truck_geometry::*;

// a parabola surface: x = 2u - 1, y = 2v - 1, z = x^2 + y^z
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector3::new(-1.0, -1.0, 2.0), Vector3::new(-1.0, 0.0, 0.0), Vector3::new(-1.0, 1.0, 2.0)],
    vec![Vector3::new(0.0, -1.0, 0.0), Vector3::new(0.0, 0.0, -2.0), Vector3::new(0.0, 1.0, 0.0)],
    vec![Vector3::new(1.0, -1.0, 2.0), Vector3::new(1.0, 0.0, 0.0), Vector3::new(1.0, 1.0, 2.0)],
];
let mut bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// add some knots for the test!
bspsurface.add_uknot(0.26);
bspsurface.add_vknot(0.23);

let bnd_box = BoundingBox::from_iter(&[Vector2::new(0.2, 0.3), Vector2::new(0.8, 0.6)]);
let curve = bspsurface.sectional_curve(bnd_box);
const N: usize = 100;
assert_near2!(curve.subs(0.0), bspsurface.subs(0.2, 0.3));
assert_near2!(curve.subs(1.0), bspsurface.subs(0.8, 0.6));
for i in 0..=N {
    let t = i as f64 / N as f64;
    let pt = curve.subs(t);
    assert_near2!(pt[1], pt[0] * 0.5 - 0.1);
    assert_near2!(pt[2], pt[0] * pt[0] + pt[1] * pt[1]);
}

pub fn homotopy(
    bspcurve0: BSplineCurve<P>,
    bspcurve1: BSplineCurve<P>
) -> BSplineSurface<P>

Creates a surface with normailized knot vectors connecting two curves.

Examples

use truck_geometry::*;
let knot_vec0 = KnotVec::bezier_knot(2);
let ctrl_pts0 = vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)];
let bspcurve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);

let knot_vec1 = KnotVec::bezier_knot(2);
let ctrl_pts1 = vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 2.0)];
let bspcurve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);

let homotopy_surface = BSplineSurface::homotopy(bspcurve0, bspcurve1);
assert_eq!(
    homotopy_surface.control_points(),
    &vec![
        vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 2.0)],
        vec![Vector2::new(0.5, -1.0), Vector2::new(0.5, 1.0)],
        vec![Vector2::new(1.0, 0.0), Vector2::new(1.0, 2.0)],
    ],
);

pub fn by_boundary(
    curve0: BSplineCurve<P>,
    curve1: BSplineCurve<P>,
    curve2: BSplineCurve<P>,
    curve3: BSplineCurve<P>
) -> BSplineSurface<P>

Creats a surface by its boundary.

Examples

use truck_geometry::*;
let curve0 = BSplineCurve::new(
    KnotVec::bezier_knot(1),
    vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 0.0)],
);
let curve1 = BSplineCurve::new(
    KnotVec::bezier_knot(2),
    vec![Vector2::new(1.0, 0.0), Vector2::new(2.0, 0.5), Vector2::new(1.0, 1.0)],
);
let curve2 = BSplineCurve::new(
    KnotVec::bezier_knot(1),
    vec![Vector2::new(1.0, 1.0), Vector2::new(0.0, 1.0)],
);
let curve3 = BSplineCurve::new(
    KnotVec::bezier_knot(2),
    vec![Vector2::new(0.0, 1.0), Vector2::new(-1.0, 0.5), Vector2::new(0.0, 0.0)],
);
let surface = BSplineSurface::by_boundary(curve0, curve1, curve2, curve3);
assert_eq!(
    surface.control_points(),
    &vec![
        vec![Vector2::new(0.0, 0.0), Vector2::new(-1.0, 0.5), Vector2::new(0.0, 1.0)],
        vec![Vector2::new(1.0, 0.0), Vector2::new(2.0, 0.5), Vector2::new(1.0, 1.0)],
    ],
);

Remarks

If the end points of curves are not connected, curve1 and curve3 take precedence. i.e. curve1 and curve3 are contained in the boundary of the surface and curve0 and curve2 are not contained.

use truck_geometry::*;
let curve0 = BSplineCurve::new(
    KnotVec::bezier_knot(1),
    vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 0.0)],
);
let curve1 = BSplineCurve::new(
    KnotVec::bezier_knot(2),
    vec![Vector2::new(2.0, 0.0), Vector2::new(3.0, 0.5), Vector2::new(2.0, 1.0)],
);
let curve2 = BSplineCurve::new(
    KnotVec::bezier_knot(1),
    vec![Vector2::new(1.0, 1.0), Vector2::new(0.0, 1.0)],
);
let curve3 = BSplineCurve::new(
    KnotVec::bezier_knot(2),
    vec![Vector2::new(-1.0, 1.0), Vector2::new(-2.0, 0.5), Vector2::new(-1.0, 0.0)],
);
let surface = BSplineSurface::by_boundary(
    curve0.clone(),
    curve1.clone(),
    curve2.clone(),
    curve3.clone()
);
assert_ne!(surface.subs(0.0, 0.0), curve0.subs(0.0));
assert_eq!(surface.subs(0.0, 0.0), curve3.subs(1.0));

pub fn knot_normalize(&mut self) -> &mut Self

Normalizes the knot vectors

pub fn knot_translate(&mut self, x: f64, y: f64) -> &mut Self

Translates the knot vectors.

pub fn optimize(&mut self) -> &mut Self

Removes knots in order from the back

pub fn splitted_boundary(&self) -> [BSplineCurve<P>; 4]

Get the boundary by four splitted curves.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 2.0)],
    vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);
let curves = bspsurface.splitted_boundary();
assert_eq!(
    curves[0].control_points(),
    &vec![Vector2::new(0.0, 0.0), Vector2::new(0.0, 1.0), Vector2::new(0.0, 2.0), Vector2::new(0.0, 3.0)],
);
assert_eq!(
    curves[1].control_points(),
    &vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],
);
assert_eq!(
    curves[2].control_points(),
    &vec![Vector2::new(1.0, 3.0), Vector2::new(1.0, 2.0), Vector2::new(1.0, 1.0), Vector2::new(1.0, 0.0)],
);
assert_eq!(
    curves[3].control_points(),
    &vec![Vector2::new(1.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(0.0, 0.0)],
);

pub fn boundary(&self) -> BSplineCurve<P>

Extracts the boundary of surface

pub fn near_as_surface(&self, other: &BSplineSurface<P>) -> bool

Determines whether self and other is near as the B-spline surfaces or not.

Divides each knot domain into the number of degree equal parts, and check |self(u, v) - other(u, v)| < TOLERANCE for each end points (u, v).

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 2.0)],
    vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],
];
let bspsurface0 = BSplineSurface::new(knot_vecs, ctrl_pts);
let mut bspsurface1 = bspsurface0.clone();
assert!(bspsurface0.near_as_surface(&bspsurface1));

*bspsurface1.control_point_mut(1, 1) = Vector2::new(0.4, 1.0);
assert!(!bspsurface0.near_as_surface(&bspsurface1));

pub fn near2_as_surface(&self, other: &BSplineSurface<P>) -> bool

Determines whether self and other is near in square order as the B-spline surfaces or not.

Divides each knot domain into the number of degree equal parts, and check |self(u, v) - other(u, v)| < TOLERANCE for each end points (u, v).

Examples

use truck_geometry::*;
let eps = TOLERANCE;
let knot_vecs = (KnotVec::bezier_knot(3), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 1.0), Vector2::new(1.0, 1.0)],
    vec![Vector2::new(0.0, 2.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 2.0)],
    vec![Vector2::new(0.0, 3.0), Vector2::new(0.5, 3.5), Vector2::new(1.0, 3.0)],
];
let bspsurface0 = BSplineSurface::new(knot_vecs, ctrl_pts);
let mut bspsurface1 = bspsurface0.clone();
assert!(bspsurface0.near_as_surface(&bspsurface1));

*bspsurface1.control_point_mut(1, 1) += Vector2::new(eps, eps / 2.0);
assert!(bspsurface0.near_as_surface(&bspsurface1));
assert!(!bspsurface0.near2_as_surface(&bspsurface1));

impl<V> BSplineSurface<V> where
    V: MetricSpace<Metric = f64> + Index<usize, Output = f64> + Bounded<f64> + Copy, 

pub fn roughly_bounding_box(&self) -> BoundingBox<V>

Returns the bounding box including all control points.

Trait Implementations

impl<V> BoundedSurface for BSplineSurface<V> where
    BSplineSurface<V>: ParametricSurface, 

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

The range of the parameter of the surface.

impl<V: Clone> Clone for BSplineSurface<V>

fn clone(&self) -> BSplineSurface<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for BSplineSurface<V>

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

Formats the value using the given formatter.

impl<'de, V> Deserialize<'de> for BSplineSurface<V> where
    V: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl IncludeCurve<BSplineCurve<Point2<f64>>> for BSplineSurface<Point2>

fn include(&self, curve: &BSplineCurve<Point2>) -> bool

Returns whether the curve curve is included in the surface self.

impl IncludeCurve<BSplineCurve<Point3<f64>>> for BSplineSurface<Point3>

fn include(&self, curve: &BSplineCurve<Point3>) -> bool

Returns whether the curve curve is included in the surface self.

impl IncludeCurve<NURBSCurve<Vector4<f64>>> for BSplineSurface<Point3>

fn include(&self, curve: &NURBSCurve<Vector4>) -> bool

Returns whether the curve curve is included in the surface self.

impl<V: Clone> Invertible for BSplineSurface<V>

fn invert(&mut self)

Inverts self

fn inverse(&self) -> Self

Returns the inverse.

impl Mul<&'_ BSplineSurface<Vector2<f64>>> for Matrix2

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

fn mul(self, spline: &BSplineSurface<Vector2>) -> Self::Output

Performs the * operation.

impl Mul<&'_ BSplineSurface<Vector2<f64>>> for f64

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

fn mul(self, spline: &BSplineSurface<Vector2>) -> Self::Output

Performs the * operation.

impl Mul<&'_ BSplineSurface<Vector3<f64>>> for Matrix3

type Output = BSplineSurface<Vector3>

The resulting type after applying the * operator.

fn mul(self, spline: &BSplineSurface<Vector3>) -> Self::Output

Performs the * operation.

impl Mul<&'_ BSplineSurface<Vector3<f64>>> for f64

type Output = BSplineSurface<Vector3>

The resulting type after applying the * operator.

fn mul(self, spline: &BSplineSurface<Vector3>) -> Self::Output

Performs the * operation.

impl Mul<&'_ BSplineSurface<Vector4<f64>>> for Matrix4

type Output = BSplineSurface<Vector4>

The resulting type after applying the * operator.

fn mul(self, spline: &BSplineSurface<Vector4>) -> Self::Output

Performs the * operation.

impl Mul<&'_ BSplineSurface<Vector4<f64>>> for f64

type Output = BSplineSurface<Vector4>

The resulting type after applying the * operator.

fn mul(self, spline: &BSplineSurface<Vector4>) -> Self::Output

Performs the * operation.

impl Mul<BSplineSurface<Vector2<f64>>> for Matrix2

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

fn mul(self, spline: BSplineSurface<Vector2>) -> Self::Output

Performs the * operation.

impl Mul<BSplineSurface<Vector2<f64>>> for f64

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

fn mul(self, spline: BSplineSurface<Vector2>) -> Self::Output

Performs the * operation.

impl Mul<BSplineSurface<Vector3<f64>>> for Matrix3

type Output = BSplineSurface<Vector3>

The resulting type after applying the * operator.

fn mul(self, spline: BSplineSurface<Vector3>) -> Self::Output

Performs the * operation.

impl Mul<BSplineSurface<Vector3<f64>>> for f64

type Output = BSplineSurface<Vector3>

The resulting type after applying the * operator.

fn mul(self, spline: BSplineSurface<Vector3>) -> Self::Output

Performs the * operation.

impl Mul<BSplineSurface<Vector4<f64>>> for Matrix4

type Output = BSplineSurface<Vector4>

The resulting type after applying the * operator.

fn mul(self, spline: BSplineSurface<Vector4>) -> Self::Output

Performs the * operation.

impl Mul<BSplineSurface<Vector4<f64>>> for f64

type Output = BSplineSurface<Vector4>

The resulting type after applying the * operator.

fn mul(self, spline: BSplineSurface<Vector4>) -> Self::Output

Performs the * operation.

impl Mul<f64> for &BSplineSurface<Vector2>

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self::Output

Performs the * operation.

impl Mul<f64> for BSplineSurface<Vector2>

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self::Output

Performs the * operation.

impl Mul<f64> for &BSplineSurface<Vector3>

type Output = BSplineSurface<Vector3>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self::Output

Performs the * operation.

impl Mul<f64> for BSplineSurface<Vector3>

type Output = BSplineSurface<Vector3>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self::Output

Performs the * operation.

impl Mul<f64> for &BSplineSurface<Vector4>

type Output = BSplineSurface<Vector4>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self::Output

Performs the * operation.

impl Mul<f64> for BSplineSurface<Vector4>

type Output = BSplineSurface<Vector4>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self::Output

Performs the * operation.

impl<P: ControlPoint<f64>> ParameterDivision2D for BSplineSurface<P> where
    P: EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff> + MetricSpace<Metric = f64>, 

fn parameter_division(
    &self,
    range: ((f64, f64), (f64, f64)),
    tol: f64
) -> (Vec<f64>, Vec<f64>)

Creates the surface division

impl<P: ControlPoint<f64>> ParametricSurface for BSplineSurface<P>

fn subs(&self, u: f64, v: f64) -> P

Substitutes to a B-spline surface.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// bspsurface: (v, 2v(1 - v)(2u - 1) + u)
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            bspsurface.subs(u, v),
            Vector2::new(v, 2.0 * v * (1.0 - v) * (2.0 * u - 1.0) + u),
        );
    }
}

fn uder(&self, u: f64, v: f64) -> P::Diff

Substitutes derived B-spline surface by the first parameter u.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// bspsurface: (v, 2v(1 - v)(2u - 1) + u), uderivation: (0.0, 4v(1 - v) + 1)
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            bspsurface.uder(u, v),
            Vector2::new(0.0, 4.0 * v * (1.0 - v) + 1.0),
        );
    }
}

fn vder(&self, u: f64, v: f64) -> P::Diff

Substitutes derived B-spline surface by the first parameter v.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(1), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// bspsurface: (v, 2v(1 - v)(2u - 1) + u), vderivation: (1, -2(2u - 1)(2v - 1))
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            bspsurface.vder(u, v),
            Vector2::new(1.0, -2.0 * (2.0 * u - 1.0) * (2.0 * v - 1.0)),
        );
    }
}

fn uuder(&self, u: f64, v: f64) -> P::Diff

Substitutes 2nd-ord derived B-spline surface by the first parameter u.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 0.5), Vector2::new(0.5, 1.0), Vector2::new(1.0, 0.5)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// bspsurface: (v, 2 u^2 v^2 - 2 u^2 v - 6 u v^2 + 6uv + 2v^2 + u - 2v)
// uuder: (0, 4v(v - 1))
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            bspsurface.uuder(u, v),
            Vector2::new(0.0, 4.0 * v * (v - 1.0)),
        );
    }
}

fn vvder(&self, u: f64, v: f64) -> P::Diff

Substitutes 2nd-ord derived B-spline surface by the second parameter v.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 0.5), Vector2::new(0.5, 1.0), Vector2::new(1.0, 0.5)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// bspsurface: (v, 2 u^2 v^2 - 2 u^2 v - 6 u v^2 + 6uv + 2v^2 + u - 2v)
// vvder: (0, 4(u^2 - 3u + 1))
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            bspsurface.vvder(u, v),
            Vector2::new(0.0, 4.0 * (u * u - 3.0 * u + 1.0)),
        );
    }
}

fn uvder(&self, u: f64, v: f64) -> P::Diff

Substitutes 2nd-ord derived B-spline surface by the both parameters u, v.

Examples

use truck_geometry::*;
let knot_vecs = (KnotVec::bezier_knot(2), KnotVec::bezier_knot(2));
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.5, -1.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 0.5), Vector2::new(0.5, 1.0), Vector2::new(1.0, 0.5)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.5, 2.0), Vector2::new(1.0, 1.0)],
];
let bspsurface = BSplineSurface::new(knot_vecs, ctrl_pts);

// bspsurface: (v, 2 u^2 v^2 - 2 u^2 v - 6 u v^2 + 6uv + 2v^2 + u - 2v)
// uvder: (0, 8uv - 4u - 12v + 6)
const N: usize = 100; // sample size
for i in 0..=N {
    let u = (i as f64) / (N as f64);
    for j in 0..=N {
        let v = (j as f64) / (N as f64);
        assert_near2!(
            bspsurface.uvder(u, v),
            Vector2::new(0.0, 8.0 * u * v - 4.0 * u - 12.0 * v + 6.0),
        );
    }
}

type Point = P

The surface is in the space of Self::Point.

type Vector = P::Diff

The derivation vector of the curve.

impl ParametricSurface3D for BSplineSurface<Point3>

fn normal(&self, u: f64, v: f64) -> Vector3<f64>

Returns the normal vector at (u, v).

impl<V: PartialEq> PartialEq<BSplineSurface<V>> for BSplineSurface<V>

fn eq(&self, other: &BSplineSurface<V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &BSplineSurface<V>) -> bool

This method tests for !=.

impl<P> SearchNearestParameter for BSplineSurface<P> where
    P: ControlPoint<f64> + EuclideanSpace<Scalar = f64, Diff = <P as ControlPoint<f64>>::Diff> + MetricSpace<Metric = f64>,
    <P as ControlPoint<f64>>::Diff: InnerSpace<Scalar = f64> + Tolerance, 

type Point = P

point

type Parameter = (f64, f64)

curve => f64, surface => (f64, f64)

fn search_nearest_parameter(
    &self,
    point: P,
    hint: Option<(f64, f64)>,
    trials: usize
) -> Option<(f64, f64)>

Search nearest parameter t such that self.subs(t) is nearest point.
Returns None if could not find such parameter.

impl SearchParameter for BSplineSurface<Point2>

type Point = Point2

point

type Parameter = (f64, f64)

curve => f64, surface => (f64, f64)

fn search_parameter(
    &self,
    point: Point2,
    hint: Option<(f64, f64)>,
    trials: usize
) -> Option<(f64, f64)>

Search parameter t such that self.subs(t) is near point.
Returns None if could not find such parameter.

impl SearchParameter for BSplineSurface<Point3>

type Point = Point3

point

type Parameter = (f64, f64)

curve => f64, surface => (f64, f64)

fn search_parameter(
    &self,
    point: Point3,
    hint: Option<(f64, f64)>,
    trials: usize
) -> Option<(f64, f64)>

Search parameter t such that self.subs(t) is near point.
Returns None if could not find such parameter.

impl<V> Serialize for BSplineSurface<V> where
    V: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<M, P: EuclideanSpace<Scalar = f64>> Transformed<M> for BSplineSurface<P> where
    M: Transform<P>, 

fn transform_by(&mut self, trans: M)

transform by trans.

fn transformed(&self, trans: T) -> Self

transformed geometry by trans.

impl<V> StructuralPartialEq for BSplineSurface<V>