Struct truck_geometry::nurbs::NURBSSurface

pub struct NURBSSurface<V>(_);

NURBS surface

Implementations

impl<V> NURBSSurface<V>

pub const fn new(bspsurface: BSplineSurface<V>) -> Self

constructor

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

Returns the nurbs surface before rationalized

pub fn non_rationalized_mut(&mut self) -> &mut BSplineSurface<V>

Returns the nurbs surface before rationalized

pub fn into_non_rationalized(self) -> BSplineSurface<V>

Returns the nurbs surface before rationalized

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
) -> impl ExactSizeIterator<Item = &V> + FusedIterator<Item = &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) -> Iter<'_, 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.

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) -> NURBSCurve<V> where
    V: Clone, 

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

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

Creates the column sectional curve.

impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> NURBSSurface<V>

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

Substitutes to a NURBS surface.

pub fn uder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff

Substitutes derived NURBS surface by the first parameter u.

pub fn vder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff

Substitutes derived NURBS surface by the first parameter v.

pub fn uuder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff

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

pub fn vvder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff

Substitutes 2nd-ord derived NURBS surface by the first parameter v.

pub fn uvder(&self, u: f64, v: f64) -> <V::Point as EuclideanSpace>::Diff

Substitutes 2nd-ord derived NURBS surface by both parameter u, v.

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

Returns the closure of substitution.

impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> NURBSSurface<V> where
    V::Point: Tolerance, 

pub fn is_const(&self) -> bool

Returns whether constant curve or not, i.e. all control points are same or not.

Examples

use truck_geometry::*;
let uknot_vec = KnotVec::bezier_knot(1);
let vknot_vec = KnotVec::bezier_knot(2);
let pt = Vector3::new(1.0, 2.0, 1.0);
// allows differences upto scalars
let ctrl_pts = vec![
    vec![pt.clone(), pt.clone() * 2.0, pt.clone() * 3.0],
    vec![pt.clone() * 0.5, pt.clone() * 0.25, pt.clone() * 0.125],
];
let mut surface = NURBSSurface::new(BSplineSurface::new((uknot_vec, vknot_vec), ctrl_pts));
assert!(surface.is_const());

*surface.control_point_mut(1, 2) = Vector3::new(2.0, 3.0, 1.0);
assert!(!surface.is_const());

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

Determines whether self and other is near as the B-spline rational 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![Vector3::new(0.0, 0.0, 1.0), Vector3::new(0.5, -1.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],
    vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.5, 1.0, 1.0), Vector3::new(1.0, 1.0, 1.0)],
    vec![Vector3::new(0.0, 2.0, 1.0), Vector3::new(0.5, 2.0, 3.0), Vector3::new(1.0, 2.0, 1.0)],
    vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(0.5, 3.5, 2.0), Vector3::new(1.0, 3.0, 1.0)],
];
let surface0 = NURBSSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));
let mut surface1 = surface0.clone();
assert!(surface0.near_as_surface(&surface1));

*surface1.control_point_mut(1, 1) = Vector3::new(0.5, 1.0, 0.9);
assert!(!surface0.near_as_surface(&surface1));

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

Determines whether self and other is near in square order as the B-spline rational 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![Vector3::new(0.0, 0.0, 1.0), Vector3::new(0.5, -1.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],
    vec![Vector3::new(0.0, 1.0, 1.0), Vector3::new(0.5, 1.0, 1.0), Vector3::new(1.0, 1.0, 1.0)],
    vec![Vector3::new(0.0, 2.0, 1.0), Vector3::new(0.5, 2.0, 3.0), Vector3::new(1.0, 2.0, 1.0)],
    vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(0.5, 3.5, 2.0), Vector3::new(1.0, 3.0, 1.0)],
];
let surface0 = NURBSSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));
let mut surface1 = surface0.clone();
assert!(surface0.near_as_surface(&surface1));

*surface1.control_point_mut(1, 1) = Vector3::new(0.5, 1.0, 1.0 - eps);
assert!(surface0.near_as_surface(&surface1));
assert!(!surface0.near2_as_surface(&surface1));

impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V> + Tolerance> NURBSSurface<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.

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

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

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.

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.

pub fn try_remove_vknot(&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.

pub fn remove_vknot(&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.

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

Elevates the udegree.

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

Elevates the vdegree.

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

Aligns the udegree with the same degrees.

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

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

pub fn ucut(&mut self, u: f64) -> Self

Cuts the surface into two surfaces at the parameter u

pub fn vcut(&mut self, v: f64) -> Self

Cuts the surface into two surfaces at the parameter v

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) -> [NURBSCurve<V>; 4]

Get the boundary by four splitted curves.

Example

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

pub fn boundary(&self) -> NURBSCurve<V>

Extracts the boundary of surface

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

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

Returns the bounding box including all control points.

Trait Implementations

impl<V> BoundedSurface for NURBSSurface<V> where
    Self: ParametricSurface, 

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

The range of the parameter of the surface.

impl<V: Clone> Clone for NURBSSurface<V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for NURBSSurface<V>

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

Formats the value using the given formatter.

impl<'de, V> Deserialize<'de> for NURBSSurface<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<Point3<f64>>> for NURBSSurface<Vector4>

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

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

impl IncludeCurve<NURBSCurve<Vector3<f64>>> for NURBSSurface<Vector3>

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

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

impl IncludeCurve<NURBSCurve<Vector4<f64>>> for NURBSSurface<Vector4>

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

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

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

fn invert(&mut self)

Inverts self

fn inverse(&self) -> Self

Returns the inverse.

impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> ParameterDivision2D for NURBSSurface<V> where
    V::Point: MetricSpace<Metric = f64>, 

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

Creates the surface division

impl<V: Homogeneous<f64> + ControlPoint<f64, Diff = V>> ParametricSurface for NURBSSurface<V>

type Point = V::Point

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

type Vector = V::Vector

The derivation vector of the curve.

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

Substitutes the parameter (u, v).

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

Returns the derivation by u.

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

Returns the derivation by v.

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

Returns the 2nd-order derivation by u.

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

Returns the 2nd-order derivation by both u and v.

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

Returns the 2nd-order derivation by v.

impl ParametricSurface3D for NURBSSurface<Vector4>

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

Returns the normal vector at (u, v).

impl<V: PartialEq> PartialEq<NURBSSurface<V>> for NURBSSurface<V>

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

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

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

This method tests for !=.

impl<V: Homogeneous<f64>> SearchNearestParameter for NURBSSurface<V> where
    Self: ParametricSurface<Point = V::Point, Vector = V::Vector>,
    V::Point: EuclideanSpace<Scalar = f64> + MetricSpace<Metric = f64>,
    V::Vector: InnerSpace<Scalar = f64> + Tolerance, 

fn search_nearest_parameter(
    &self,
    point: V::Point,
    hint: Option<(f64, f64)>,
    trials: usize
) -> 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![Vector3::new(0.0, 0.0, 1.0), Vector3::new(1.0, -2.0, 2.0), Vector3::new(1.0, 0.0, 1.0)],
    vec![Vector3::new(0.0, 2.0, 2.0), Vector3::new(2.0, 4.0, 4.0), Vector3::new(2.0, 2.0, 2.0)],
    vec![Vector3::new(0.0, 4.0, 2.0), Vector3::new(2.0, 8.0, 4.0), Vector3::new(2.0, 4.0, 2.0)],
    vec![Vector3::new(0.0, 3.0, 1.0), Vector3::new(1.0, 7.0, 2.0), Vector3::new(1.0, 3.0, 1.0)],
];
let surface = NURBSSurface::new(BSplineSurface::new(knot_vecs, ctrl_pts));
let pt = surface.subs(0.3, 0.7);
let (u, v) = surface.search_nearest_parameter(pt, Some((0.5, 0.5)), 100).unwrap();
assert!(u.near(&0.3) && v.near(&0.7));

Remarks

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

type Point = V::Point

point

type Parameter = (f64, f64)

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

impl SearchParameter for NURBSSurface<Vector3>

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

Serach the parameter (u, v) such that self.subs(u, v).rational_projection() 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, 1.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.4)],
    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 bspsurface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);
let surface = NURBSSurface::new(bspsurface);

let pt = surface.subs(0.3, 0.7);
let (u, v) = surface.search_parameter(pt, Some((0.5, 0.5)), 100).unwrap();
assert_near!(surface.subs(u, v), pt);

type Point = Point2

point

type Parameter = (f64, f64)

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

impl SearchParameter for NURBSSurface<Vector4>

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

Serach the parameter (u, v) such that self.subs(u, v).rational_projection() 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![Vector4::new(0.0, 0.0, 0.0, 1.0), Vector4::new(0.1, 0.0, 0.5, 0.4), Vector4::new(1.0, 0.0, 0.6, 2.0), Vector4::new(0.4, 0.0, 0.4, 0.4)],
    vec![Vector4::new(0.0, 0.2, 0.2, 2.0), Vector4::new(0.24, 0.24, 0.1, 1.2), Vector4::new(2.4, 1.8, 2.4, 0.6), Vector4::new(1.4, 0.42, 0.98, 1.4)],
    vec![Vector4::new(0.0, 1.5, 1.2, 3.0), Vector4::new(1.02, 2.04, 1.7, 3.4), Vector4::new(0.42, 0.28, 0.7, 0.7), Vector4::new(0.6, 0.3, 0.0, 0.6)],
    vec![Vector4::new(0.0, 1.0, 1.0, 1.0), Vector4::new(0.2, 2.0, 2.0, 2.0), Vector4::new(0.85, 1.7, 0.85, 1.7), Vector4::new(1.0, 1.0, 0.3, 1.0)],
];
let bspsurface = BSplineSurface::new((knot_vec.clone(), knot_vec), ctrl_pts);
let surface = NURBSSurface::new(bspsurface);

let pt = surface.subs(0.3, 0.7);
let (u, v) = surface.search_parameter(pt, Some((0.5, 0.5)), 100).unwrap();
assert_near!(surface.subs(u, v), pt);

type Point = Point3

point

type Parameter = (f64, f64)

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

impl<V> Serialize for NURBSSurface<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, V: Copy> Transformed<M> for NURBSSurface<V> where
    M: Copy + Mul<V, Output = V>, 

fn transform_by(&mut self, trans: M)

transform by trans.

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

transformed geometry by trans.

impl<V> StructuralPartialEq for NURBSSurface<V>