Loading...
Searching...
No Matches
Spline.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 20010-2011 Hauke Heibel <hauke.heibel@gmail.com>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10#ifndef EIGEN_SPLINE_H
11#define EIGEN_SPLINE_H
12
13#include "SplineFwd.h"
14
15namespace Eigen
16{
34 template <typename _Scalar, int _Dim, int _Degree>
35 class Spline
36 {
37 public:
38 typedef _Scalar Scalar;
39 enum { Dimension = _Dim };
40 enum { Degree = _Degree };
41
43 typedef typename SplineTraits<Spline>::PointType PointType;
44
46 typedef typename SplineTraits<Spline>::KnotVectorType KnotVectorType;
47
49 typedef typename SplineTraits<Spline>::ParameterVectorType ParameterVectorType;
50
52 typedef typename SplineTraits<Spline>::BasisVectorType BasisVectorType;
53
55 typedef typename SplineTraits<Spline>::BasisDerivativeType BasisDerivativeType;
56
58 typedef typename SplineTraits<Spline>::ControlPointVectorType ControlPointVectorType;
59
65 : m_knots(1, (Degree==Dynamic ? 2 : 2*Degree+2))
66 , m_ctrls(ControlPointVectorType::Zero(Dimension,(Degree==Dynamic ? 1 : Degree+1)))
67 {
68 // in theory this code can go to the initializer list but it will get pretty
69 // much unreadable ...
70 enum { MinDegree = (Degree==Dynamic ? 0 : Degree) };
71 m_knots.template segment<MinDegree+1>(0) = Array<Scalar,1,MinDegree+1>::Zero();
72 m_knots.template segment<MinDegree+1>(MinDegree+1) = Array<Scalar,1,MinDegree+1>::Ones();
73 }
74
80 template <typename OtherVectorType, typename OtherArrayType>
81 Spline(const OtherVectorType& knots, const OtherArrayType& ctrls) : m_knots(knots), m_ctrls(ctrls) {}
82
87 template <int OtherDegree>
89 m_knots(spline.knots()), m_ctrls(spline.ctrls()) {}
90
94 const KnotVectorType& knots() const { return m_knots; }
95
99 const ControlPointVectorType& ctrls() const { return m_ctrls; }
100
112 PointType operator()(Scalar u) const;
113
126 typename SplineTraits<Spline>::DerivativeType
127 derivatives(Scalar u, DenseIndex order) const;
128
134 template <int DerivativeOrder>
135 typename SplineTraits<Spline,DerivativeOrder>::DerivativeType
136 derivatives(Scalar u, DenseIndex order = DerivativeOrder) const;
137
154 typename SplineTraits<Spline>::BasisVectorType
155 basisFunctions(Scalar u) const;
156
170 typename SplineTraits<Spline>::BasisDerivativeType
171 basisFunctionDerivatives(Scalar u, DenseIndex order) const;
172
178 template <int DerivativeOrder>
179 typename SplineTraits<Spline,DerivativeOrder>::BasisDerivativeType
180 basisFunctionDerivatives(Scalar u, DenseIndex order = DerivativeOrder) const;
181
185 DenseIndex degree() const;
186
191 DenseIndex span(Scalar u) const;
192
196 static DenseIndex Span(typename SplineTraits<Spline>::Scalar u, DenseIndex degree, const typename SplineTraits<Spline>::KnotVectorType& knots);
197
210 static BasisVectorType BasisFunctions(Scalar u, DenseIndex degree, const KnotVectorType& knots);
211
218 const Scalar u, const DenseIndex order, const DenseIndex degree, const KnotVectorType& knots);
219
220 private:
221 KnotVectorType m_knots;
222 ControlPointVectorType m_ctrls;
224 template <typename DerivativeType>
225 static void BasisFunctionDerivativesImpl(
227 const DenseIndex order,
228 const DenseIndex p,
230 DerivativeType& N_);
231 };
232
233 template <typename _Scalar, int _Dim, int _Degree>
235 typename SplineTraits< Spline<_Scalar, _Dim, _Degree> >::Scalar u,
236 DenseIndex degree,
237 const typename SplineTraits< Spline<_Scalar, _Dim, _Degree> >::KnotVectorType& knots)
238 {
239 // Piegl & Tiller, "The NURBS Book", A2.1 (p. 68)
240 if (u <= knots(0)) return degree;
241 const Scalar* pos = std::upper_bound(knots.data()+degree-1, knots.data()+knots.size()-degree-1, u);
242 return static_cast<DenseIndex>( std::distance(knots.data(), pos) - 1 );
243 }
244
245 template <typename _Scalar, int _Dim, int _Degree>
249 DenseIndex degree,
251 {
253
254 const DenseIndex p = degree;
255 const DenseIndex i = Spline::Span(u, degree, knots);
256
257 const KnotVectorType& U = knots;
258
259 BasisVectorType left(p+1); left(0) = Scalar(0);
260 BasisVectorType right(p+1); right(0) = Scalar(0);
261
262 VectorBlock<BasisVectorType,Degree>(left,1,p) = u - VectorBlock<const KnotVectorType,Degree>(U,i+1-p,p).reverse();
263 VectorBlock<BasisVectorType,Degree>(right,1,p) = VectorBlock<const KnotVectorType,Degree>(U,i+1,p) - u;
264
265 BasisVectorType N(1,p+1);
266 N(0) = Scalar(1);
267 for (DenseIndex j=1; j<=p; ++j)
268 {
269 Scalar saved = Scalar(0);
270 for (DenseIndex r=0; r<j; r++)
271 {
272 const Scalar tmp = N(r)/(right(r+1)+left(j-r));
273 N[r] = saved + right(r+1)*tmp;
274 saved = left(j-r)*tmp;
275 }
276 N(j) = saved;
277 }
278 return N;
279 }
280
281 template <typename _Scalar, int _Dim, int _Degree>
283 {
284 if (_Degree == Dynamic)
285 return m_knots.size() - m_ctrls.cols() - 1;
286 else
287 return _Degree;
288 }
289
290 template <typename _Scalar, int _Dim, int _Degree>
292 {
293 return Spline::Span(u, degree(), knots());
294 }
295
296 template <typename _Scalar, int _Dim, int _Degree>
298 {
299 enum { Order = SplineTraits<Spline>::OrderAtCompileTime };
300
301 const DenseIndex span = this->span(u);
302 const DenseIndex p = degree();
303 const BasisVectorType basis_funcs = basisFunctions(u);
304
305 const Replicate<BasisVectorType,Dimension,1> ctrl_weights(basis_funcs);
306 const Block<const ControlPointVectorType,Dimension,Order> ctrl_pts(ctrls(),0,span-p,Dimension,p+1);
307 return (ctrl_weights * ctrl_pts).rowwise().sum();
308 }
309
310 /* --------------------------------------------------------------------------------------------- */
311
312 template <typename SplineType, typename DerivativeType>
313 void derivativesImpl(const SplineType& spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType& der)
314 {
315 enum { Dimension = SplineTraits<SplineType>::Dimension };
316 enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
317 enum { DerivativeOrder = DerivativeType::ColsAtCompileTime };
318
319 typedef typename SplineTraits<SplineType>::ControlPointVectorType ControlPointVectorType;
320 typedef typename SplineTraits<SplineType,DerivativeOrder>::BasisDerivativeType BasisDerivativeType;
321 typedef typename BasisDerivativeType::ConstRowXpr BasisDerivativeRowXpr;
322
323 const DenseIndex p = spline.degree();
324 const DenseIndex span = spline.span(u);
325
326 const DenseIndex n = (std::min)(p, order);
327
328 der.resize(Dimension,n+1);
329
330 // Retrieve the basis function derivatives up to the desired order...
331 const BasisDerivativeType basis_func_ders = spline.template basisFunctionDerivatives<DerivativeOrder>(u, n+1);
332
333 // ... and perform the linear combinations of the control points.
334 for (DenseIndex der_order=0; der_order<n+1; ++der_order)
335 {
336 const Replicate<BasisDerivativeRowXpr,Dimension,1> ctrl_weights( basis_func_ders.row(der_order) );
337 const Block<const ControlPointVectorType,Dimension,Order> ctrl_pts(spline.ctrls(),0,span-p,Dimension,p+1);
338 der.col(der_order) = (ctrl_weights * ctrl_pts).rowwise().sum();
339 }
340 }
341
342 template <typename _Scalar, int _Dim, int _Degree>
343 typename SplineTraits< Spline<_Scalar, _Dim, _Degree> >::DerivativeType
345 {
346 typename SplineTraits< Spline >::DerivativeType res;
347 derivativesImpl(*this, u, order, res);
348 return res;
349 }
350
351 template <typename _Scalar, int _Dim, int _Degree>
352 template <int DerivativeOrder>
353 typename SplineTraits< Spline<_Scalar, _Dim, _Degree>, DerivativeOrder >::DerivativeType
354 Spline<_Scalar, _Dim, _Degree>::derivatives(Scalar u, DenseIndex order) const
355 {
356 typename SplineTraits< Spline, DerivativeOrder >::DerivativeType res;
357 derivativesImpl(*this, u, order, res);
358 return res;
359 }
360
361 template <typename _Scalar, int _Dim, int _Degree>
362 typename SplineTraits< Spline<_Scalar, _Dim, _Degree> >::BasisVectorType
364 {
365 return Spline::BasisFunctions(u, degree(), knots());
366 }
367
368 /* --------------------------------------------------------------------------------------------- */
369
370
371 template <typename _Scalar, int _Dim, int _Degree>
372 template <typename DerivativeType>
375 const DenseIndex order,
376 const DenseIndex p,
378 DerivativeType& N_)
379 {
380 typedef Spline<_Scalar, _Dim, _Degree> SplineType;
381 enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
382
383 typedef typename SplineTraits<SplineType>::Scalar Scalar;
384 typedef typename SplineTraits<SplineType>::BasisVectorType BasisVectorType;
385
386 const DenseIndex span = SplineType::Span(u, p, U);
387
388 const DenseIndex n = (std::min)(p, order);
389
390 N_.resize(n+1, p+1);
391
392 BasisVectorType left = BasisVectorType::Zero(p+1);
393 BasisVectorType right = BasisVectorType::Zero(p+1);
394
395 Matrix<Scalar,Order,Order> ndu(p+1,p+1);
396
397 Scalar saved, temp; // FIXME These were double instead of Scalar. Was there a reason for that?
398
399 ndu(0,0) = 1.0;
400
401 DenseIndex j;
402 for (j=1; j<=p; ++j)
403 {
404 left[j] = u-U[span+1-j];
405 right[j] = U[span+j]-u;
406 saved = 0.0;
407
408 for (DenseIndex r=0; r<j; ++r)
409 {
410 /* Lower triangle */
411 ndu(j,r) = right[r+1]+left[j-r];
412 temp = ndu(r,j-1)/ndu(j,r);
413 /* Upper triangle */
414 ndu(r,j) = static_cast<Scalar>(saved+right[r+1] * temp);
415 saved = left[j-r] * temp;
416 }
417
418 ndu(j,j) = static_cast<Scalar>(saved);
419 }
420
421 for (j = p; j>=0; --j)
422 N_(0,j) = ndu(j,p);
423
424 // Compute the derivatives
425 DerivativeType a(n+1,p+1);
426 DenseIndex r=0;
427 for (; r<=p; ++r)
428 {
429 DenseIndex s1,s2;
430 s1 = 0; s2 = 1; // alternate rows in array a
431 a(0,0) = 1.0;
432
433 // Compute the k-th derivative
434 for (DenseIndex k=1; k<=static_cast<DenseIndex>(n); ++k)
435 {
436 Scalar d = 0.0;
437 DenseIndex rk,pk,j1,j2;
438 rk = r-k; pk = p-k;
439
440 if (r>=k)
441 {
442 a(s2,0) = a(s1,0)/ndu(pk+1,rk);
443 d = a(s2,0)*ndu(rk,pk);
444 }
445
446 if (rk>=-1) j1 = 1;
447 else j1 = -rk;
448
449 if (r-1 <= pk) j2 = k-1;
450 else j2 = p-r;
451
452 for (j=j1; j<=j2; ++j)
453 {
454 a(s2,j) = (a(s1,j)-a(s1,j-1))/ndu(pk+1,rk+j);
455 d += a(s2,j)*ndu(rk+j,pk);
456 }
457
458 if (r<=pk)
459 {
460 a(s2,k) = -a(s1,k-1)/ndu(pk+1,r);
461 d += a(s2,k)*ndu(r,pk);
462 }
463
464 N_(k,r) = static_cast<Scalar>(d);
465 j = s1; s1 = s2; s2 = j; // Switch rows
466 }
467 }
468
469 /* Multiply through by the correct factors */
470 /* (Eq. [2.9]) */
471 r = p;
472 for (DenseIndex k=1; k<=static_cast<DenseIndex>(n); ++k)
473 {
474 for (j=p; j>=0; --j) N_(k,j) *= r;
475 r *= p-k;
476 }
477 }
478
479 template <typename _Scalar, int _Dim, int _Degree>
480 typename SplineTraits< Spline<_Scalar, _Dim, _Degree> >::BasisDerivativeType
482 {
483 typename SplineTraits<Spline<_Scalar, _Dim, _Degree> >::BasisDerivativeType der;
484 BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
485 return der;
486 }
487
488 template <typename _Scalar, int _Dim, int _Degree>
489 template <int DerivativeOrder>
490 typename SplineTraits< Spline<_Scalar, _Dim, _Degree>, DerivativeOrder >::BasisDerivativeType
491 Spline<_Scalar, _Dim, _Degree>::basisFunctionDerivatives(Scalar u, DenseIndex order) const
492 {
493 typename SplineTraits< Spline<_Scalar, _Dim, _Degree>, DerivativeOrder >::BasisDerivativeType der;
494 BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
495 return der;
496 }
497
498 template <typename _Scalar, int _Dim, int _Degree>
499 typename SplineTraits<Spline<_Scalar, _Dim, _Degree> >::BasisDerivativeType
502 const DenseIndex order,
503 const DenseIndex degree,
505 {
506 typename SplineTraits<Spline>::BasisDerivativeType der;
507 BasisFunctionDerivativesImpl(u, order, degree, knots, der);
508 return der;
509 }
510}
511
512#endif // EIGEN_SPLINE_H
A class representing multi-dimensional spline curves.
Definition: Spline.h:36
SplineTraits< Spline >::ParameterVectorType ParameterVectorType
The data type used to store parameter vectors.
Definition: Spline.h:49
SplineTraits< Spline >::KnotVectorType KnotVectorType
The data type used to store knot vectors.
Definition: Spline.h:46
DenseIndex degree() const
Returns the spline degree.
Definition: Spline.h:282
Spline(const Spline< Scalar, Dimension, OtherDegree > &spline)
Copy constructor for splines.
Definition: Spline.h:88
SplineTraits< Spline >::BasisDerivativeType basisFunctionDerivatives(Scalar u, DenseIndex order) const
Computes the non-zero spline basis function derivatives up to given order.
Definition: Spline.h:481
SplineTraits< Spline >::DerivativeType derivatives(Scalar u, DenseIndex order) const
Evaluation of spline derivatives of up-to given order.
Definition: Spline.h:344
SplineTraits< Spline >::BasisVectorType BasisVectorType
The data type used to store non-zero basis functions.
Definition: Spline.h:52
const ControlPointVectorType & ctrls() const
Returns the ctrls of the underlying spline.
Definition: Spline.h:99
Spline()
Creates a (constant) zero spline. For Splines with dynamic degree, the resulting degree will be 0.
Definition: Spline.h:64
PointType operator()(Scalar u) const
Returns the spline value at a given site .
Definition: Spline.h:297
@ Degree
Definition: Spline.h:40
@ Dimension
Definition: Spline.h:39
_Scalar Scalar
Definition: Spline.h:38
SplineTraits< Spline >::PointType PointType
The point type the spline is representing.
Definition: Spline.h:43
SplineTraits< Spline >::BasisDerivativeType BasisDerivativeType
The data type used to store the values of the basis function derivatives.
Definition: Spline.h:55
SplineTraits< Spline, DerivativeOrder >::DerivativeType derivatives(Scalar u, DenseIndex order=DerivativeOrder) const
Evaluation of spline derivatives of up-to given order.
static DenseIndex Span(typename SplineTraits< Spline >::Scalar u, DenseIndex degree, const typename SplineTraits< Spline >::KnotVectorType &knots)
Computes the spang within the provided knot vector in which u is falling.
Definition: Spline.h:234
static BasisVectorType BasisFunctions(Scalar u, DenseIndex degree, const KnotVectorType &knots)
Returns the spline's non-zero basis functions.
Definition: Spline.h:247
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.
Definition: Spline.h:500
DenseIndex span(Scalar u) const
Returns the span within the knot vector in which u is falling.
Definition: Spline.h:291
SplineTraits< Spline >::ControlPointVectorType ControlPointVectorType
The data type representing the spline's control points.
Definition: Spline.h:58
SplineTraits< Spline, DerivativeOrder >::BasisDerivativeType basisFunctionDerivatives(Scalar u, DenseIndex order=DerivativeOrder) const
Computes the non-zero spline basis function derivatives up to given order.
Spline(const OtherVectorType &knots, const OtherArrayType &ctrls)
Creates a spline from a knot vector and control points.
Definition: Spline.h:81
const KnotVectorType & knots() const
Returns the knots of the underlying spline.
Definition: Spline.h:94
SplineTraits< Spline >::BasisVectorType basisFunctions(Scalar u) const
Computes the non-zero basis functions at the given site.
Definition: Spline.h:363
Namespace containing all symbols from the Eigen library.
Definition: AdolcForward:45