Eigen::Spline< Scalar_, Dim_, Degree_ > Class Template Reference

A class representing multi-dimensional spline curves. More...

Public Types
enum	{ Dimension }
enum	{ Degree }
typedef SplineTraits< Spline >::BasisDerivativeType	BasisDerivativeType
	The data type used to store the values of the basis function derivatives. More...
typedef SplineTraits< Spline >::BasisVectorType	BasisVectorType
	The data type used to store non-zero basis functions. More...
typedef SplineTraits< Spline >::ControlPointVectorType	ControlPointVectorType
	The data type representing the spline's control points. More...
typedef SplineTraits< Spline >::KnotVectorType	KnotVectorType
	The data type used to store knot vectors. More...
typedef SplineTraits< Spline >::ParameterVectorType	ParameterVectorType
	The data type used to store parameter vectors. More...
typedef SplineTraits< Spline >::PointType	PointType
	The point type the spline is representing. More...
typedef Scalar_	Scalar

Public Member Functions
SplineTraits< Spline >::BasisDerivativeType	basisFunctionDerivatives (Scalar u, DenseIndex order) const
	Computes the non-zero spline basis function derivatives up to given order. More...
template<int DerivativeOrder>
SplineTraits< Spline, DerivativeOrder >::BasisDerivativeType	basisFunctionDerivatives (Scalar u, DenseIndex order=DerivativeOrder) const
	Computes the non-zero spline basis function derivatives up to given order. More...
SplineTraits< Spline >::BasisVectorType	basisFunctions (Scalar u) const
	Computes the non-zero basis functions at the given site. More...
const ControlPointVectorType &	ctrls () const
	Returns the ctrls of the underlying spline. More...
DenseIndex	degree () const
	Returns the spline degree. More...
SplineTraits< Spline >::DerivativeType	derivatives (Scalar u, DenseIndex order) const
	Evaluation of spline derivatives of up-to given order. More...
template<int DerivativeOrder>
SplineTraits< Spline, DerivativeOrder >::DerivativeType	derivatives (Scalar u, DenseIndex order=DerivativeOrder) const
	Evaluation of spline derivatives of up-to given order. More...
const KnotVectorType &	knots () const
	Returns the knots of the underlying spline. More...
PointType	operator() (Scalar u) const
	Returns the spline value at a given site $u$. More...
DenseIndex	span (Scalar u) const
	Returns the span within the knot vector in which u is falling. More...
	Spline ()
	Creates a (constant) zero spline. For Splines with dynamic degree, the resulting degree will be 0. More...
template<typename OtherVectorType , typename OtherArrayType >
	Spline (const OtherVectorType &knots, const OtherArrayType &ctrls)
	Creates a spline from a knot vector and control points. More...
template<int OtherDegree>
	Spline (const Spline< Scalar, Dimension, OtherDegree > &spline)
	Copy constructor for splines. More...

Static Public Member Functions
static BasisDerivativeType	BasisFunctionDerivatives (const Scalar u, const DenseIndex order, const DenseIndex degree, const KnotVectorType &knots)
	Computes the non-zero spline basis function derivatives up to given order. More...
static BasisVectorType	BasisFunctions (Scalar u, DenseIndex degree, const KnotVectorType &knots)
	Returns the spline's non-zero basis functions. More...
static DenseIndex	Span (typename SplineTraits< Spline >::Scalar u, DenseIndex degree, const typename SplineTraits< Spline >::KnotVectorType &knots)
	Computes the span within the provided knot vector in which u is falling. More...

Static Private Member Functions
template<typename DerivativeType >
static void	BasisFunctionDerivativesImpl (const typename Spline< Scalar_, Dim_, Degree_ >::Scalar u, const DenseIndex order, const DenseIndex p, const typename Spline< Scalar_, Dim_, Degree_ >::KnotVectorType &U, DerivativeType &N_)

Private Attributes
ControlPointVectorType	m_ctrls
KnotVectorType	m_knots

Detailed Description

template<typename Scalar_, int Dim_, int Degree_>
class Eigen::Spline< Scalar_, Dim_, Degree_ >

A class representing multi-dimensional spline curves.

The class represents B-splines with non-uniform knot vectors. Each control point of the B-spline is associated with a basis function

$$\begin{array}{rl}C(u)& =\sum _{i=0}^n{N}_{i,p}(u)P_i\end{array}$$

Template Parameters

Scalar_	The underlying data type (typically float or double)
Dim_	The curve dimension (e.g. 2 or 3)
Degree_	Per default set to Dynamic; could be set to the actual desired degree for optimization purposes (would result in stack allocation of several temporary variables).

Definition at line 37 of file Spline.h.

Member Typedef Documentation

BasisDerivativeType

template<typename Scalar_ , int Dim_, int Degree_>

typedef SplineTraits<Spline>::BasisDerivativeType Eigen::Spline< Scalar_, Dim_, Degree_ >::BasisDerivativeType

The data type used to store the values of the basis function derivatives.

Definition at line 57 of file Spline.h.

BasisVectorType

template<typename Scalar_ , int Dim_, int Degree_>

typedef SplineTraits<Spline>::BasisVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::BasisVectorType

The data type used to store non-zero basis functions.

Definition at line 54 of file Spline.h.

ControlPointVectorType

template<typename Scalar_ , int Dim_, int Degree_>

typedef SplineTraits<Spline>::ControlPointVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::ControlPointVectorType

The data type representing the spline's control points.

Definition at line 60 of file Spline.h.

KnotVectorType

template<typename Scalar_ , int Dim_, int Degree_>

typedef SplineTraits<Spline>::KnotVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::KnotVectorType

The data type used to store knot vectors.

Definition at line 48 of file Spline.h.

ParameterVectorType

template<typename Scalar_ , int Dim_, int Degree_>

typedef SplineTraits<Spline>::ParameterVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::ParameterVectorType

The data type used to store parameter vectors.

Definition at line 51 of file Spline.h.

PointType

template<typename Scalar_ , int Dim_, int Degree_>

typedef SplineTraits<Spline>::PointType Eigen::Spline< Scalar_, Dim_, Degree_ >::PointType

The point type the spline is representing.

Definition at line 45 of file Spline.h.

Scalar

template<typename Scalar_ , int Dim_, int Degree_>

typedef Scalar_ Eigen::Spline< Scalar_, Dim_, Degree_ >::Scalar

The spline curve's scalar type.

Definition at line 40 of file Spline.h.

Member Enumeration Documentation

anonymous enum

template<typename Scalar_ , int Dim_, int Degree_>

anonymous enum

Enumerator
Dimension	The spline curve's dimension.

Definition at line 41 of file Spline.h.

{ Dimension = Dim_  };

Code

anonymous enum

template<typename Scalar_ , int Dim_, int Degree_>

anonymous enum

Enumerator
Degree	The spline curve's degree.

Definition at line 42 of file Spline.h.

{ Degree = Degree_  };

Code

Constructor & Destructor Documentation

Spline() [1/3]

template<typename Scalar_ , int Dim_, int Degree_>

Eigen::Spline< Scalar_, Dim_, Degree_ >::Spline ( )

inline

Creates a (constant) zero spline. For Splines with dynamic degree, the resulting degree will be 0.

Definition at line 66 of file Spline.h.

    : m_knots(1, (Degree==Dynamic ? 2 : 2*Degree+2))
    , m_ctrls(ControlPointVectorType::Zero(Dimension,(Degree==Dynamic ? 1 : Degree+1))) 
    {
      // in theory this code can go to the initializer list but it will get pretty
      // much unreadable ...
      enum { MinDegree = (Degree==Dynamic ? 0 : Degree) };
      m_knots.template segment<MinDegree+1>(0) = Array<Scalar,1,MinDegree+1>::Zero();
      m_knots.template segment<MinDegree+1>(MinDegree+1) = Array<Scalar,1,MinDegree+1>::Ones();
    }

Code

Spline() [2/3]

template<typename Scalar_ , int Dim_, int Degree_>

template<typename OtherVectorType , typename OtherArrayType >

Eigen::Spline< Scalar_, Dim_, Degree_ >::Spline ( const OtherVectorType &  knots, const OtherArrayType &  ctrls  )

inline

Creates a spline from a knot vector and control points.

Parameters

knots	The spline's knot vector.
ctrls	The spline's control point vector.

Definition at line 83 of file Spline.h.

: m_knots(knots), m_ctrls(ctrls) {}

Code

Spline() [3/3]

template<typename Scalar_ , int Dim_, int Degree_>

template<int OtherDegree>

Eigen::Spline< Scalar_, Dim_, Degree_ >::Spline ( const Spline< Scalar, Dimension, OtherDegree > &  spline )

inline

Copy constructor for splines.

Parameters

spline

The input spline.

Definition at line 90 of file Spline.h.

                                                                 : 
    m_knots(spline.knots()), m_ctrls(spline.ctrls()) {}

Code

Member Function Documentation

BasisFunctionDerivatives()

template<typename Scalar_ , int Dim_, int Degree_>

SplineTraits< Spline< Scalar_, Dim_, Degree_ > >::BasisDerivativeType Eigen::Spline< Scalar_, Dim_, Degree_ >::BasisFunctionDerivatives ( const Scalar  u, const DenseIndex  order, const DenseIndex  degree, const KnotVectorType &  knots  )

static

Computes the non-zero spline basis function derivatives up to given order.

The function computes

$$\begin{array}{r}\frac{d^i}{d{u}^i}{N}_{i,p}(u),\text{hdots},\frac{d^i}{d{u}^i}{N}_{i+p+1,p}(u)\end{array}$$

with i ranging from 0 up to the specified order.

Parameters

u	Parameter $u\in [0;1]$ at which the non-zero basis function derivatives are computed.
order	The order up to which the basis function derivatives are computes.
degree	The degree of the underlying spline
knots	The underlying spline's knot vector.

Definition at line 497 of file Spline.h.

  {
    typename SplineTraits<Spline>::BasisDerivativeType der;
    BasisFunctionDerivativesImpl(u, order, degree, knots, der);
    return der;
  }

Code

basisFunctionDerivatives() [1/2]

template<typename Scalar_ , int Dim_, int Degree_>

SplineTraits< Spline< Scalar_, Dim_, Degree_ >, DerivativeOrder >::BasisDerivativeType Eigen::Spline< Scalar_, Dim_, Degree_ >::basisFunctionDerivatives	(	Scalar	u,
		DenseIndex	order
	)		const

Computes the non-zero spline basis function derivatives up to given order.

The function computes

$$\begin{array}{r}\frac{d^i}{d{u}^i}{N}_{i,p}(u),\text{hdots},\frac{d^i}{d{u}^i}{N}_{i+p+1,p}(u)\end{array}$$

with i ranging from 0 up to the specified order.

Parameters

u	Parameter $u\in [0;1]$ at which the non-zero basis function derivatives are computed.
order	The order up to which the basis function derivatives are computes.

Definition at line 478 of file Spline.h.

  {
    typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType der;
    BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
    return der;
  }

Code

basisFunctionDerivatives() [2/2]

template<typename Scalar_ , int Dim_, int Degree_>

template<int DerivativeOrder>

SplineTraits<Spline,DerivativeOrder>::BasisDerivativeType Eigen::Spline< Scalar_, Dim_, Degree_ >::basisFunctionDerivatives	(	Scalar	u,
		DenseIndex	order = DerivativeOrder
	)		const

Computes the non-zero spline basis function derivatives up to given order.

The function computes

$$\begin{array}{r}\frac{d^i}{d{u}^i}{N}_{i,p}(u),\text{hdots},\frac{d^i}{d{u}^i}{N}_{i+p+1,p}(u)\end{array}$$

with i ranging from 0 up to the specified order.

Parameters

u	Parameter $u\in [0;1]$ at which the non-zero basis function derivatives are computed.
order	The order up to which the basis function derivatives are computes. Using the template version of this function is more efficieent since temporary objects are allocated on the stack whenever this is possible.

BasisFunctionDerivativesImpl()

template<typename Scalar_ , int Dim_, int Degree_>

template<typename DerivativeType >

void Eigen::Spline< Scalar_, Dim_, Degree_ >::BasisFunctionDerivativesImpl ( const typename Spline< Scalar_, Dim_, Degree_ >::Scalar  u, const DenseIndex  order, const DenseIndex  p, const typename Spline< Scalar_, Dim_, Degree_ >::KnotVectorType &  U, DerivativeType &  N_  )

staticprivate

Definition at line 373 of file Spline.h.

  {
    typedef Spline<Scalar_, Dim_, Degree_> SplineType;
    enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
 
    const DenseIndex span = SplineType::Span(u, p, U);
 
    const DenseIndex n = (std::min)(p, order);
 
    N_.resize(n+1, p+1);
 
    BasisVectorType left = BasisVectorType::Zero(p+1);
    BasisVectorType right = BasisVectorType::Zero(p+1);
 
    Matrix<Scalar,Order,Order> ndu(p+1,p+1);
 
    Scalar saved, temp; // FIXME These were double instead of Scalar. Was there a reason for that?
 
    ndu(0,0) = 1.0;
 
    DenseIndex j;
    for (j=1; j<=p; ++j)
    {
      left[j] = u-U[span+1-j];
      right[j] = U[span+j]-u;
      saved = 0.0;
 
      for (DenseIndex r=0; r<j; ++r)
      {
        /* Lower triangle */
        ndu(j,r) = right[r+1]+left[j-r];
        temp = ndu(r,j-1)/ndu(j,r);
        /* Upper triangle */
        ndu(r,j) = static_cast<Scalar>(saved+right[r+1] * temp);
        saved = left[j-r] * temp;
      }
 
      ndu(j,j) = static_cast<Scalar>(saved);
    }
 
    for (j = p; j>=0; --j) 
      N_(0,j) = ndu(j,p);
 
    // Compute the derivatives
    DerivativeType a(n+1,p+1);
    DenseIndex r=0;
    for (; r<=p; ++r)
    {
      DenseIndex s1,s2;
      s1 = 0; s2 = 1; // alternate rows in array a
      a(0,0) = 1.0;
 
      // Compute the k-th derivative
      for (DenseIndex k=1; k<=static_cast<DenseIndex>(n); ++k)
      {
        Scalar d = 0.0;
        DenseIndex rk,pk,j1,j2;
        rk = r-k; pk = p-k;
 
        if (r>=k)
        {
          a(s2,0) = a(s1,0)/ndu(pk+1,rk);
          d = a(s2,0)*ndu(rk,pk);
        }
 
        if (rk>=-1) j1 = 1;
        else        j1 = -rk;
 
        if (r-1 <= pk) j2 = k-1;
        else           j2 = p-r;
 
        for (j=j1; j<=j2; ++j)
        {
          a(s2,j) = (a(s1,j)-a(s1,j-1))/ndu(pk+1,rk+j);
          d += a(s2,j)*ndu(rk+j,pk);
        }
 
        if (r<=pk)
        {
          a(s2,k) = -a(s1,k-1)/ndu(pk+1,r);
          d += a(s2,k)*ndu(r,pk);
        }
 
        N_(k,r) = static_cast<Scalar>(d);
        j = s1; s1 = s2; s2 = j; // Switch rows
      }
    }
 
    /* Multiply through by the correct factors */
    /* (Eq. [2.9])                             */
    r = p;
    for (DenseIndex k=1; k<=static_cast<DenseIndex>(n); ++k)
    {
      for (j=p; j>=0; --j) N_(k,j) *= r;
      r *= p-k;
    }
  }

Code

basisFunctions()

template<typename Scalar_ , int Dim_, int Degree_>

SplineTraits< Spline< Scalar_, Dim_, Degree_ > >::BasisVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::basisFunctions

(

Scalar

u

)

const

Computes the non-zero basis functions at the given site.

Splines have local support and a point from their image is defined by exactly $p+1$ control points $P_i$ where $p$ is the spline degree.

This function computes the $p+1$ non-zero basis function values for a given parameter value $u$. It returns

$$\begin{array}{r}{N}_{i,p}(u),\text{hdots},N_{i+p+1,p}(u)\end{array}$$

Parameters

u	Parameter $u\in [0;1]$ at which the non-zero basis functions are computed.

Definition at line 363 of file Spline.h.

  {
    return Spline::BasisFunctions(u, degree(), knots());
  }

Code

BasisFunctions()

template<typename Scalar_ , int Dim_, int Degree_>

Spline< Scalar_, Dim_, Degree_ >::BasisVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::BasisFunctions ( Scalar  u, DenseIndex  degree, const KnotVectorType &  knots  )

static

Returns the spline's non-zero basis functions.

The function computes and returns

$$\begin{array}{r}{N}_{i,p}(u),\text{hdots},N_{i+p+1,p}(u)\end{array}$$

Parameters

u	The site at which the basis functions are computed.
degree	The degree of the underlying spline.
knots	The underlying spline's knot vector.

Definition at line 249 of file Spline.h.

  {
    const DenseIndex p = degree;
    const DenseIndex i = Spline::Span(u, degree, knots);
 
    const KnotVectorType& U = knots;
 
    BasisVectorType left(p+1); left(0) = Scalar(0);
    BasisVectorType right(p+1); right(0) = Scalar(0);
 
    VectorBlock<BasisVectorType,Degree>(left,1,p) = u - VectorBlock<const KnotVectorType,Degree>(U,i+1-p,p).reverse();
    VectorBlock<BasisVectorType,Degree>(right,1,p) = VectorBlock<const KnotVectorType,Degree>(U,i+1,p) - u;
 
    BasisVectorType N(1,p+1);
    N(0) = Scalar(1);
    for (DenseIndex j=1; j<=p; ++j)
    {
      Scalar saved = Scalar(0);
      for (DenseIndex r=0; r<j; r++)
      {
        const Scalar tmp = N(r)/(right(r+1)+left(j-r));
        N[r] = saved + right(r+1)*tmp;
        saved = left(j-r)*tmp;
      }
      N(j) = saved;
    }
    return N;
  }

Code

ctrls()

template<typename Scalar_ , int Dim_, int Degree_>

const ControlPointVectorType& Eigen::Spline< Scalar_, Dim_, Degree_ >::ctrls ( ) const

inline

Returns the ctrls of the underlying spline.

Definition at line 101 of file Spline.h.

{ return m_ctrls; }

Code

degree()

template<typename Scalar_ , int Dim_, int Degree_>

DenseIndex Eigen::Spline< Scalar_, Dim_, Degree_ >::degree

Returns the spline degree.

Definition at line 282 of file Spline.h.

  {
    if (Degree_ == Dynamic)
      return m_knots.size() - m_ctrls.cols() - 1;
    else
      return Degree_;
  }

Code

derivatives() [1/2]

template<typename Scalar_ , int Dim_, int Degree_>

SplineTraits< Spline< Scalar_, Dim_, Degree_ >, DerivativeOrder >::DerivativeType Eigen::Spline< Scalar_, Dim_, Degree_ >::derivatives	(	Scalar	u,
		DenseIndex	order
	)		const

Evaluation of spline derivatives of up-to given order.

The function returns

$$\begin{array}{rl}\frac{d^i}{d{u}^i}C(u)& =\sum _{i=0}^n\frac{d^i}{d{u}^i}{N}_{i,p}(u)P_i\end{array}$$

for i ranging between 0 and order.

Parameters

u	Parameter $u\in [0;1]$ at which the spline derivative is evaluated.
order	The order up to which the derivatives are computed.

Definition at line 344 of file Spline.h.

  {
    typename SplineTraits< Spline >::DerivativeType res;
    derivativesImpl(*this, u, order, res);
    return res;
  }

Code

derivatives() [2/2]

template<typename Scalar_ , int Dim_, int Degree_>

template<int DerivativeOrder>

SplineTraits<Spline,DerivativeOrder>::DerivativeType Eigen::Spline< Scalar_, Dim_, Degree_ >::derivatives	(	Scalar	u,
		DenseIndex	order = DerivativeOrder
	)		const

Evaluation of spline derivatives of up-to given order.

The function returns

$$\begin{array}{rl}\frac{d^i}{d{u}^i}C(u)& =\sum _{i=0}^n\frac{d^i}{d{u}^i}{N}_{i,p}(u)P_i\end{array}$$

for i ranging between 0 and order.

Parameters

u	Parameter $u\in [0;1]$ at which the spline derivative is evaluated.
order	The order up to which the derivatives are computed. Using the template version of this function is more efficieent since temporary objects are allocated on the stack whenever this is possible.

knots()

template<typename Scalar_ , int Dim_, int Degree_>

const KnotVectorType& Eigen::Spline< Scalar_, Dim_, Degree_ >::knots ( ) const

inline

Returns the knots of the underlying spline.

Definition at line 96 of file Spline.h.

{ return m_knots; }

Code

operator()()

template<typename Scalar_ , int Dim_, int Degree_>

Spline< Scalar_, Dim_, Degree_ >::PointType Eigen::Spline< Scalar_, Dim_, Degree_ >::operator()

(

Scalar

u

)

const

Returns the spline value at a given site $u$.

The function returns

$$\begin{array}{rl}C(u)& =\sum _{i=0}^n{N}_{i,p}{P}_i\end{array}$$

Parameters

u	Parameter $u\in [0;1]$ at which the spline is evaluated.

Returns

The spline value at the given location $u$.

Definition at line 297 of file Spline.h.

  {
    enum { Order = SplineTraits<Spline>::OrderAtCompileTime };
 
    const DenseIndex span = this->span(u);
    const DenseIndex p = degree();
    const BasisVectorType basis_funcs = basisFunctions(u);
 
    const Replicate<BasisVectorType,Dimension,1> ctrl_weights(basis_funcs);
    const Block<const ControlPointVectorType,Dimension,Order> ctrl_pts(ctrls(),0,span-p,Dimension,p+1);
    return (ctrl_weights * ctrl_pts).rowwise().sum();
  }

Code

span()

template<typename Scalar_ , int Dim_, int Degree_>

DenseIndex Eigen::Spline< Scalar_, Dim_, Degree_ >::span

(

Scalar

u

)

const

Returns the span within the knot vector in which u is falling.

Parameters

u	The site for which the span is determined.

Definition at line 291 of file Spline.h.

  {
    return Spline::Span(u, degree(), knots());
  }

Code

Span()

template<typename Scalar_ , int Dim_, int Degree_>

DenseIndex Eigen::Spline< Scalar_, Dim_, Degree_ >::Span ( typename SplineTraits< Spline< Scalar_, Dim_, Degree_ > >::Scalar  u, DenseIndex  degree, const typename SplineTraits< Spline< Scalar_, Dim_, Degree_ > >::KnotVectorType &  knots  )

static

Computes the span within the provided knot vector in which u is falling.

Definition at line 236 of file Spline.h.

  {
    // Piegl & Tiller, "The NURBS Book", A2.1 (p. 68)
    if (u <= knots(0)) return degree;
    const Scalar* pos = std::upper_bound(knots.data()+degree-1, knots.data()+knots.size()-degree-1, u);
    return static_cast<DenseIndex>( std::distance(knots.data(), pos) - 1 );
  }

Code

Member Data Documentation

m_ctrls

template<typename Scalar_ , int Dim_, int Degree_>

ControlPointVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::m_ctrls

private

Control points.

Definition at line 224 of file Spline.h.

m_knots

template<typename Scalar_ , int Dim_, int Degree_>

KnotVectorType Eigen::Spline< Scalar_, Dim_, Degree_ >::m_knots

private

Knot vector.

Definition at line 223 of file Spline.h.

---

The documentation for this class was generated from the following file:

• Spline.h