Struct truck_geometry::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);
        f64::assert_near2(&c, &1.0);
    }
}

Implementations

impl<V> BSplineSurface<V>

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

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<V>>
) -> Result<BSplineSurface<V>>

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<V>>
) -> BSplineSurface<V>

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<V>>
) -> BSplineSurface<V>

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<V>>

Returns the reference of the vector of the control points

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

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

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

Apply the given transformation to all control points.

pub fn ctrl_pts_row_iter(&self, column_idx: usize) -> CPRowIter<'_, V>

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) -> CPColumnIter<'_, V>

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 V

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

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

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
    V: 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<V> where
    V: 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<V> where
    V: 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<V: VectorSpace<Scalar = f64>> BSplineSurface<V>

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

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);
        Vector2::assert_near2(
            &bspsurface.subs(u, v),
            &Vector2::new(v, 2.0 * v * (1.0 - v) * (2.0 * u - 1.0) + u),
        );
    }
}

pub fn uder(&self, u: f64, v: f64) -> V

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);
        Vector2::assert_near2(
            &bspsurface.uder(u, v),
            &Vector2::new(0.0, 4.0 * v * (1.0 - v) + 1.0),
        );
    }
}

pub fn vder(&self, u: f64, v: f64) -> V

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);
        Vector2::assert_near2(
            &bspsurface.vder(u, v),
            &Vector2::new(1.0, -2.0 * (2.0 * u - 1.0) * (2.0 * v - 1.0)),
        );
    }
}

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

Returns the closure of substitution.

pub fn uderivation(&self) -> BSplineSurface<V>

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);
        Vector2::assert_near2(
            &uderivation.subs(u, v),
            &Vector2::new(0.0, 4.0 * v * (1.0 - v) + 1.0),
        );
    }
}

pub fn vderivation(&self) -> BSplineSurface<V>

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);
        Vector2::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<V: VectorSpace<Scalar = f64> + Tolerance> BSplineSurface<V>

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<V>

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);
        Vector2::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);
        Vector2::assert_near2(&bspsurface.subs(u, v), &part1.subs(u, v));
    }
}

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

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);
        Vector2::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);
        Vector2::assert_near2(&bspsurface.subs(u, v), &part1.subs(u, v));
    }
}

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

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

Examples

use truck_geometry::*;
use std::iter::FromIterator;

// 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;
Vector3::assert_near2(&curve.subs(0.0), &bspsurface.subs(0.2, 0.3));
Vector3::assert_near2(&curve.subs(1.0), &bspsurface.subs(0.8, 0.6));
for i in 0..=N {
    println!("{}", i);
    let t = i as f64 / N as f64;
    let pt = curve.subs(t);
    f64::assert_near2(&pt[1], &(pt[0] * 0.5 - 0.1));
    f64::assert_near2(&pt[2], &(pt[0] * pt[0] + pt[1] * pt[1]));
}

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

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<V>,
    curve1: BSplineCurve<V>,
    curve2: BSplineCurve<V>,
    curve3: BSplineCurve<V>
) -> BSplineSurface<V>

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<V>; 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<V>

Extracts the boundary of surface

pub fn near_as_surface(&self, other: &BSplineSurface<V>) -> 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<V>) -> 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: InnerSpace<Scalar = f64> + Tolerance> BSplineSurface<V>

pub fn search_nearest_parameter(
    &self,
    pt: V,
    (u0, v0): (f64, f64)
) -> Option<(f64, f64)>

Searches the parameter (u, v) which minimize |self(u, v) - point| by Newton's method with initial guess (u0, v0). If the repeated trial does not converge, then returns None.

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 pt = bspsurface.subs(0.3, 0.7);
let (u, v) = bspsurface.search_nearest_parameter(pt, (0.5, 0.5)).unwrap();
assert!(u.near2(&0.3) && v.near2(&0.7));

Remarks

It may converge to a local solution depending on the hint. cf. BSplineCurve::search_nearest_parameter

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.

impl BSplineSurface<Vector2>

pub fn search_parameter(
    &self,
    pt: Vector2,
    hint: (f64, f64)
) -> Option<(f64, f64)>

Serach the parameter (u, v) such that self.subs(u, v) is near pt. If cannot find, then return None.

Examples

use truck_geometry::*;
let knot_vec = KnotVec::uniform_knot(2, 3);
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.1, 0.0), Vector2::new(0.5, 0.0), Vector2::new(0.7, 0.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 0.1), Vector2::new(0.2, 0.2), Vector2::new(0.4, 0.3), Vector2::new(0.6, 0.2), Vector2::new(1.0, 0.3)],
    vec![Vector2::new(0.0, 0.5), Vector2::new(0.3, 0.6), Vector2::new(0.6, 0.4), Vector2::new(0.9, 0.6), Vector2::new(1.0, 0.5)],
    vec![Vector2::new(0.0, 0.7), Vector2::new(0.2, 0.8), Vector2::new(0.3, 0.6), Vector2::new(0.5, 0.9), Vector2::new(1.0, 0.7)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.1, 1.0), Vector2::new(0.5, 1.0), Vector2::new(0.7, 1.0), Vector2::new(1.0, 1.0)],
];
let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);

let pt = Vector2::new(0.3, 0.7);
let (u, v) = surface.search_parameter(pt, (0.5, 0.5)).unwrap();
Vector2::assert_near(&surface.subs(u, v), &pt);

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

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

Examples

use truck_geometry::*;
let knot_vec = KnotVec::uniform_knot(2, 3);
let ctrl_pts = vec![
    vec![Vector2::new(0.0, 0.0), Vector2::new(0.1, 0.0), Vector2::new(0.5, 0.0), Vector2::new(0.7, 0.0), Vector2::new(1.0, 0.0)],
    vec![Vector2::new(0.0, 0.1), Vector2::new(0.2, 0.2), Vector2::new(0.4, 0.3), Vector2::new(0.6, 0.2), Vector2::new(1.0, 0.3)],
    vec![Vector2::new(0.0, 0.5), Vector2::new(0.3, 0.6), Vector2::new(0.6, 0.4), Vector2::new(0.9, 0.6), Vector2::new(1.0, 0.5)],
    vec![Vector2::new(0.0, 0.7), Vector2::new(0.2, 0.8), Vector2::new(0.3, 0.6), Vector2::new(0.5, 0.9), Vector2::new(1.0, 0.7)],
    vec![Vector2::new(0.0, 1.0), Vector2::new(0.1, 1.0), Vector2::new(0.5, 1.0), Vector2::new(0.7, 1.0), Vector2::new(1.0, 1.0)],
];
let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);

let knot_vec0 = KnotVec::bezier_knot(2);
let ctrl_pts0 = vec![Vector2::new(0.0, 0.0), Vector2::new(1.0, 1.0), Vector2::new(0.0, 1.0)];
let curve0 = BSplineCurve::new(knot_vec0, ctrl_pts0);
assert!(surface.include(&curve0));

let knot_vec1 = KnotVec::bezier_knot(2);
let ctrl_pts1 = vec![Vector2::new(0.0, 0.0), Vector2::new(2.5, 1.0), Vector2::new(0.0, 1.0)];
let curve1 = BSplineCurve::new(knot_vec1, ctrl_pts1);
assert!(!surface.include(&curve1));

impl BSplineSurface<Vector3>

pub fn search_parameter(
    &self,
    pt: Vector3,
    hint: (f64, f64)
) -> Option<(f64, f64)>

Serach the parameter (u, v) such that self.subs(u, v) is near pt. If cannot find, then return None.

Examples

use truck_geometry::*;
let knot_vec = KnotVec::uniform_knot(2, 2);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(0.1, 0.0, 0.5), Vector3::new(0.5, 0.0, 0.3), Vector3::new(1.0, 0.0, 1.0)],
    vec![Vector3::new(0.0, 0.1, 0.1), Vector3::new(0.2, 0.2, 0.1), Vector3::new(0.4, 0.3, 0.4), Vector3::new(1.0, 0.3, 0.7)],
    vec![Vector3::new(0.0, 0.5, 0.4), Vector3::new(0.3, 0.6, 0.5), Vector3::new(0.6, 0.4, 1.0), Vector3::new(1.0, 0.5, 0.0)],
    vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.1, 1.0, 1.0), Vector3::new(0.5, 1.0, 0.5), Vector3::new(1.0, 1.0, 0.3)],
];
let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);

let pt = surface.subs(0.32, 0.76);
let (u, v) = surface.search_parameter(pt, (0.5, 0.5)).unwrap();
Vector3::assert_near(&surface.subs(u, v), &pt);

let pt = surface.subs(0.32, 0.76) + Vector3::new(0.0, 0.0, 0.001);
assert!(surface.search_parameter(pt, (0.5, 0.5)).is_none());

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

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

Examples

use truck_geometry::*;
use std::iter::FromIterator;
let knot_vec = KnotVec::uniform_knot(2, 3);
let ctrl_pts = vec![
    vec![Vector3::new(0.0, 0.0, 0.0), Vector3::new(0.1, 0.0, 0.5), Vector3::new(0.5, 0.0, 0.3), Vector3::new(1.0, 0.0, 1.0)],
    vec![Vector3::new(0.0, 0.1, 0.1), Vector3::new(0.2, 0.2, 0.1), Vector3::new(0.4, 0.3, 0.4), Vector3::new(1.0, 0.3, 0.7)],
    vec![Vector3::new(0.0, 0.5, 0.4), Vector3::new(0.3, 0.6, 0.5), Vector3::new(0.6, 0.4, 1.0), Vector3::new(1.0, 0.5, 0.0)],
    vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.1, 1.0, 1.0), Vector3::new(0.5, 1.0, 0.5), Vector3::new(1.0, 1.0, 0.3)],
];
let surface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);

let bnd_box = BoundingBox::from_iter(&[Vector2::new(0.2, 0.3), Vector2::new(0.8, 0.6)]);
let mut curve = surface.sectional_curve(bnd_box);
assert!(surface.include(&curve));

*curve.control_point_mut(2) += Vector3::new(0.0, 0.0, 0.001);
assert!(!surface.include(&curve));

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

pub 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>, 

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

Deserialize this value from the given Serde deserializer.

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

type Output = BSplineSurface<Vector2>

The resulting type after applying the * operator.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

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

Performs the * operation.

impl<V: InnerSpace<Scalar = f64>> ParameterDivision2D for BSplineSurface<V>

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

Creates the surface division

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

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

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

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

This method tests for !=.

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

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

Serialize this value into the given Serde serializer.

impl<V> StructuralPartialEq for BSplineSurface<V>

impl Surface for BSplineSurface<Vector2>

type Point = Point2

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

type Vector = Vector2

The derivation vector of the curve.

type Curve = BSplineCurve<Vector2>

The boundary curve

pub fn subs(&self, u: f64, v: f64) -> Self::Point

Substitutes the parameter (u, v).

pub fn uder(&self, u: f64, v: f64) -> Self::Vector

Returns the derivation by u.

pub fn vder(&self, u: f64, v: f64) -> Self::Vector

Returns the derivation by v.

pub fn normal(&self, _: f64, _: f64) -> Self::Vector

zero identity

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

The range of the parameter of the surface.

pub fn inverse(&self) -> Self

Returns the inverse of the surface.

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

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

impl Surface for BSplineSurface<Vector3>

type Point = Point3

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

type Vector = Vector3

The derivation vector of the curve.

type Curve = BSplineCurve<Vector3>

The boundary curve

pub fn subs(&self, u: f64, v: f64) -> Self::Point

Substitutes the parameter (u, v).

pub fn uder(&self, u: f64, v: f64) -> Self::Vector

Returns the derivation by u.

pub fn vder(&self, u: f64, v: f64) -> Self::Vector

Returns the derivation by v.

pub fn normal(&self, u: f64, v: f64) -> Self::Vector

Returns the normal vector at (u, v).

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

The range of the parameter of the surface.

pub fn inverse(&self) -> Self

Returns the inverse of the surface.

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

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