STK::BSplineCoefficients< Data > Class Template Reference

Compute the regression B-splines coefficients. More...

#include <STK_BSplineCoefficients.h>

Inheritance diagram for STK::BSplineCoefficients< Data >:

Public Types
typedef IBasis< Data, ArrayXX >	Base
Public Types inherited from STK::IBasis< Data, ArrayXX >
typedef Data::Type	Type

Public Member Functions
	BSplineCoefficients (Data const *p_data=0, int nbControlPoints=1, int degree=3, Regress::KnotsPosition position=Regress::uniformKnotsPositions_, bool useDataValues=true)
	Default constructor : initialize the data members with default values.
	BSplineCoefficients (Data const &data, int nbControlPoints, int degree=3, Regress::KnotsPosition position=Regress::uniformKnotsPositions_, bool useDataValues=true)
	Constructor : initialize the data members.
	BSplineCoefficients (BSplineCoefficients const &coefs)
	copy constructor.
virtual	~BSplineCoefficients ()
	Destructor.
BSplineCoefficients *	clone () const
	clone pattern implementation
virtual bool	run ()
	run the computations.
int	degree () const
int	nbKnots () const
int	nbControlPoints () const
VectorX const &	knots () const
void	setNbControlPoints (int nbControlPoints)
	Set the number of control point (the number of BSpline)
void	setDim (int dim)
	Alias for setting the number of control point (the number of BSpline)
void	setDegree (int degree=3)
	Set the degree of the BSpline basis.
void	setPosition (Regress::KnotsPosition position)
	Set the kind of position to use for the knots.
void	setParameters (Data const &data, int nbControlPoints, int degree=3, Regress::KnotsPosition position=Regress::uniformKnotsPositions_)
	Set the whole set of parameters for computing the coefficients.
void	setData (Data const &data, int nbControlPoints, int degree=3, Regress::KnotsPosition position=Regress::uniformKnotsPositions_)
	[DEPRECATED] Set the whole set of parameters for computing the coefficients
template<class OtherVector >
ArrayXX	extrapolate (OtherVector const &x) const
Public Member Functions inherited from STK::IBasis< Data, ArrayXX >
	IBasis ()
	default constructor
	IBasis (Data const *p_data, int dim, bool useDataValues=true)
	constructor
	IBasis (Data const &data, int dim, bool useDataValues=true)
	constructor
	IBasis (IBasis const &basis)
	copy constructor.
virtual	~IBasis ()
	destructor
int	dim () const
ArrayXX const &	coefficients () const
Type	minValue () const
Type	maxValue () const
void	setData (Data const &data)
	Set the data set.
void	setDim (int dim)
void	setMinValue (Type const &minValue)
void	setMaxValue (Type const &maxValue)
bool	initializeStep ()
	Initialize the parameters minValue_ and maxValue_ using data set.
Public Member Functions inherited from STK::IRunnerBase
String const &	error () const
	get the last error message.

Protected Member Functions
bool	computeKnots ()
	compute the position of the knots of the B-spline curves.
void	computeCoefficients ()
	Compute the coefficients of the B-spline curves.
Protected Member Functions inherited from STK::IBasis< Data, ArrayXX >
virtual void	update ()
	update IBasis if a parameter or a new data set is set, update the state of this runner.
Protected Member Functions inherited from STK::IRunnerBase
	IRunnerBase ()
	default constructor
	IRunnerBase (IRunnerBase const &runner)
	copy constructor
virtual	~IRunnerBase ()
	destructor

Protected Attributes
int	degree_
	degree of the B-splines curves.
Regress::KnotsPosition	position_
	Method used in order to position the knots.
int	nbKnots_
	number of knots of the B-spline curves.
int	lastControlPoint_
	Index of the last control point of the B-spline curves.
VectorX	knots_
	Data of the knots.
Protected Attributes inherited from STK::IBasis< Data, ArrayXX >
Data const *	p_data_
	the input data set
int	dim_
	number of dimension to build
bool	useDataValues_
Type	minValue_
	Minimal value of the data.
Type	maxValue_
	Maximal value of the data.
ArrayXX	coefficients_
	Array2D of the coefficients.
Protected Attributes inherited from STK::IRunnerBase
String	msg_error_
	String with the last error message.
bool	hasRun_
	true if run has been used, false otherwise

Private Member Functions
void	computeUniformKnots ()
	compute the position of the uniform knots.
void	computePeriodicKnots ()
	compute the position of the periodic knots.
void	computeDensityKnots (bool isSorted)
	compute the position of the density knots
void	computeCoefficientsRow (int irow, Real const &value)
	Compute a row of the coefficients matrix for a given value.

Detailed Description

template<class Data>
class STK::BSplineCoefficients< Data >

Compute the regression B-splines coefficients.

The BSplineCoefficients class computes the coefficients of a BSpline curve using the de Boor's algorithm. The knots can be uniform (the default), periodic or density placed.

Given the number of control points and the degree of the B-splines, the number of knots is given by the formula nbKnots = nbControlPoints + degree + 1.

Note

If the input data set is a vector of size n the output matrix of the coefficients Coefficients() is a matrix of size (n, nbControlPoints).

Definition at line 62 of file STK_BSplineCoefficients.h.

Member Typedef Documentation

Base

template<class Data >

typedef IBasis<Data, ArrayXX> STK::BSplineCoefficients< Data >::Base

Definition at line 65 of file STK_BSplineCoefficients.h.

Constructor & Destructor Documentation

BSplineCoefficients() [1/3]

template<class Data >

STK::BSplineCoefficients< Data >::BSplineCoefficients	(	Data const *	p_data = 0,
		int	nbControlPoints = 1,
		int	degree = 3,
		Regress::KnotsPosition	position = Regress::uniformKnotsPositions_,
		bool	useDataValues = true
	)

Default constructor : initialize the data members with default values.

The number of knots is given by the formula nbKnots = nbControlPoints + degree +1.

Parameters

p_data	the input data values
nbControlPoints	number of control points
degree	degree of the B-spline curves
position	method to use for positioning the knots
useDataValues	if true use data in order to find the minValue_ and maxValue_, use values set otherwise.

Definition at line 209 of file STK_BSplineCoefficients.h.

                                                : Base(p_data, nbControlPoints, useDataValues)
                                                , degree_(degree)
                                                , position_(position)
                                                , nbKnots_(nbControlPoints + degree + 1)
                                                , lastControlPoint_(dim_-1)
                                                , knots_( Range(0, nbKnots_) )
{ }

BSplineCoefficients() [2/3]

template<class Data >

STK::BSplineCoefficients< Data >::BSplineCoefficients	(	Data const &	data,
		int	nbControlPoints,
		int	degree = 3,
		Regress::KnotsPosition	position = Regress::uniformKnotsPositions_,
		bool	useDataValues = true
	)

Constructor : initialize the data members.

The number of knots is given by the formula nbKnots = nbControlPoints + degree +1.

Parameters

data	the input data values
nbControlPoints	number of control points
degree	degree of the B-spline curves
position	method to use for positioning the knots
useDataValues	if true use data in order to find the minValue_ and maxValue_, use values set otherwise.

Definition at line 225 of file STK_BSplineCoefficients.h.

                                              : Base(data, nbControlPoints, useDataValues)
                                              , degree_(degree)
                                              , position_(position)
                                              , nbKnots_(nbControlPoints + degree +1)
                                              , lastControlPoint_(dim_-1)
                                              , knots_( Range(0, nbKnots_) )
{}

BSplineCoefficients() [3/3]

template<class Data >

STK::BSplineCoefficients< Data >::BSplineCoefficients

(

BSplineCoefficients< Data > const &

coefs

)

copy constructor.

Parameters

coefs

the coefficients to copy

Definition at line 242 of file STK_BSplineCoefficients.h.

                                              : Base(coefs)
                                              , degree_(coefs.degree_)
                                              , position_(coefs.position_)
                                              , nbKnots_(coefs.nbKnots_)
                                              , lastControlPoint_(coefs.lastControlPoint_)
                                              , knots_(coefs.knots_)
{}

~BSplineCoefficients()

template<class Data >

virtual STK::BSplineCoefficients< Data >::~BSplineCoefficients ( )

inlinevirtual

Destructor.

Definition at line 111 of file STK_BSplineCoefficients.h.

{}

Member Function Documentation

clone()

template<class Data >

BSplineCoefficients * STK::BSplineCoefficients< Data >::clone ( ) const

inline

clone pattern implementation

Definition at line 113 of file STK_BSplineCoefficients.h.

{ return new BSplineCoefficients(*this);}

computeCoefficients()

template<class Data >

void STK::BSplineCoefficients< Data >::computeCoefficients ( )

protected

Compute the coefficients of the B-spline curves.

Definition at line 442 of file STK_BSplineCoefficients.h.

{
#ifdef STK_REGRESS_VERBOSE
  stk_cout << _T("BSplineCoefficients::computeCoefficients()\n");
#endif
 
  // compute the coefficients
  for (int i=p_data_->begin(); i< p_data_->end(); i++)
  { computeCoefficientsRow(i, (*p_data_)[i]);}
 
#ifdef STK_REGRESS_VERBOSE
  stk_cout << _T("BSplineCoefficients::computeCoefficients() done\n");
#endif
}

References _T, and stk_cout.

computeCoefficientsRow()

template<class Data >

void STK::BSplineCoefficients< Data >::computeCoefficientsRow ( int  irow, Real const &  value  )

private

Compute a row of the coefficients matrix for a given value.

Parameters

irow	index of the row
value	the value to which we want to compute the row

Definition at line 515 of file STK_BSplineCoefficients.h.

{
  // value outside the range of the knots case
  if (value <= minValue_)
  {
    coefficients_(irow, 0) = 1.0;
    return;
  }
  if (value >= maxValue_)
  {
    coefficients_(irow, lastControlPoint_) = 1.0;
    return;
  }
  // find interval
  int k, k1;
  for (k=0, k1=1; k<lastControlPoint_; k++, k1++)
  {
    if (value < knots_[k1]) break;
  }
  // begin recursion
  coefficients_(irow, k) = 1.0;
  for (int d=1; d<=degree_; d++)
  {
    // right (south-west corner) term only
    coefficients_(irow, k-d) = ( (knots_[k1] - value)/(knots_[k1] - knots_[k1-d]) )
                               * coefficients_(irow, k1-d);
    // compute internal terms
    for (int i = k1-d; i<k; i++)
    {
      const Real knots_i = knots_[i], knots_id1 = knots_[i+d+1];
      coefficients_(irow, i) = ( (value - knots_i)/(knots_[i+d] - knots_i) )
                               * coefficients_(irow, i)
                             + ( (knots_id1 - value)/(knots_id1 - knots_[i+1]) )
                               * coefficients_(irow, i+1);
    }
    // left (north-west corner) term only
    coefficients_(irow, k) *= (value - knots_[k])/(knots_[k+d] - knots_[k]);
  }
}

computeDensityKnots()

template<class Data >

void STK::BSplineCoefficients< Data >::computeDensityKnots ( bool  isSorted )

private

compute the position of the density knots

Parameters

isSorted

true if the data is sorted, false otherwise

Definition at line 486 of file STK_BSplineCoefficients.h.

{
  // sorted data
  Data xtri(*p_data_, true);
  // sort the data
  if (!isSorted) heapSort< Data >(xtri);
 
  // compute step
  Real step = xtri.size()/(Real)(lastControlPoint_-degree_+1);
 
  // set internal knots
  int first = xtri.begin();
  for (int k = degree_ + 1, kcell =1; k <= lastControlPoint_; k++, kcell++)
  {
    int cell = first + int(kcell* step);
    knots_[k] = (xtri[cell] + xtri[cell+1])/2.;
  }
  // set external knots
  for ( int k=0, j = lastControlPoint_+1; k <= degree_; j++, k++)
  {
    knots_[k] = xtri.front();
    knots_[j] = xtri.back();
  }
}

computeKnots()

template<class Data >

bool STK::BSplineCoefficients< Data >::computeKnots ( )

protected

compute the position of the knots of the B-spline curves.

Definition at line 406 of file STK_BSplineCoefficients.h.

{
  // resize and initialize knots
  knots_.resize( Range(0, nbKnots_) ) = minValue_;
  // set knots values
  switch (position_)
  {
    // uniform position
    case Regress::uniformKnotsPositions_:
      computeUniformKnots();
      break;
    // periodic position
    case Regress::periodicKnotsPositions_:
      computePeriodicKnots();
      break;
    // density position
    case Regress::densityKnotsPositions_:
      computeDensityKnots(true);
      break;
    default:
 
      msg_error_ = STKERROR_NO_ARG(BSplineCoefficients::computeKnots,invalid position);
      return false;
      break;
  }
  // shift knots
  if (position_ != Regress::densityKnotsPositions_)
  {
    Real range = (maxValue_ - minValue_);
    for (int k = 0; k < nbKnots_; k++) knots_[k] = minValue_ + range * knots_[k];
  }
  return true;
}

References STK::BSplineCoefficients< Data >::computeKnots(), STK::Regress::densityKnotsPositions_, STK::IRunnerBase::msg_error_, STK::Regress::periodicKnotsPositions_, STKERROR_NO_ARG, and STK::Regress::uniformKnotsPositions_.

Referenced by STK::BSplineCoefficients< Data >::computeKnots().

computePeriodicKnots()

template<class Data >

void STK::BSplineCoefficients< Data >::computePeriodicKnots ( )

private

compute the position of the periodic knots.

Definition at line 475 of file STK_BSplineCoefficients.h.

{
  // compute step
  Real step = 1.0/(dim_ - degree_);
  // set knots
  for (int k = 0, j = -degree_; k < nbKnots_; j++, k++)
    knots_[k] = j * step;
;
}

computeUniformKnots()

template<class Data >

void STK::BSplineCoefficients< Data >::computeUniformKnots ( )

private

compute the position of the uniform knots.

Definition at line 459 of file STK_BSplineCoefficients.h.

{
  // compute step
  Real step = 1.0/(dim_ - degree_);
  // set internal knots
  const int first = degree_ + 1;
  for (int k = first, j = 1; k <= lastControlPoint_; j++, k++)  knots_[k] = j * step;
  // set external knots
  for ( int k=0, j = lastControlPoint_+1; k < first; j++, k++)
  {
    knots_[k] = 0;
    knots_[j] = 1;
  }
}

degree()

template<class Data >

int STK::BSplineCoefficients< Data >::degree ( ) const

inline

Returns

the degree of the B-Splines

Definition at line 118 of file STK_BSplineCoefficients.h.

{ return degree_;}

References STK::BSplineCoefficients< Data >::degree_.

extrapolate()

template<class Data >

template<class OtherVector >

ArrayXX STK::BSplineCoefficients< Data >::extrapolate

(

OtherVector const &

x

)

const

Returns

the extrapolated matrix of coefficients for a given set of x-values.

Parameters

x	the values to extrapolate

Definition at line 354 of file STK_BSplineCoefficients.h.

{
  // check if knots exists
  if (!this->hasRun_)
  { STKRUNTIME_ERROR_NO_ARG(BSplineCoefficients::extrapolate,No run);}
  // resize coeficients
  ArrayXX coefs(x.range(), Range(0, lastControlPoint_, 0), 0.0);
  // check if the original data set was not reduced to a single point
  if (minValue_ == maxValue_) return coefs;
  // compute the coefficients
  for (int irow=x.begin(); irow< x.end(); irow++)
  {
    const Real value = x[irow];
    // value outside the range of the knots case
    if (value <= minValue_)
    {
      coefs(irow, 0) = 1.0;
      continue;
    }
    if (value >= maxValue_)
    {
      coefs(irow, lastControlPoint_) = 1.0;
      continue;
    }
    // find interval
    int k, k1;
    for (k=0, k1=1; k<lastControlPoint_; k++, k1++)
    {
      if (value < knots_[k1]) break;
    }
    // begin recursion
    coefs(irow, k) = 1.0;
    for (int d=1; d<=degree_; d++)
    {
      // right (south-west corner) term only
      coefs(irow, k-d) = ( (knots_[k1] - value)/(knots_[k1] - knots_[k1-d]) ) * coefs(irow, k1-d);
      // compute internal terms
      for (int i = k1-d; i<k; i++)
      {
        const Real knots_i = knots_[i], knots_id1 = knots_[i+d+1];
        coefs(irow, i) = ( (value - knots_i)/(knots_[i+d] - knots_i) ) * coefs(irow, i)
                       + ( (knots_id1 - value)/(knots_id1 - knots_[i+1]) ) * coefs(irow, i+1);
      }
      // left (north-west corner) term only
      coefs(irow, k) *= (value - knots_[k])/(knots_[k+d] - knots_[k]);
    }
  }
  return coefs;
}

References STK::MultidimRegression< Array, Weight >::coefs(), STK::BSplineCoefficients< Data >::extrapolate(), STK::IRunnerBase::hasRun_, STK::IRegression< Array, Array, Weight >::run(), and STKRUNTIME_ERROR_NO_ARG.

Referenced by STK::BSplineCoefficients< Data >::extrapolate().

knots()

template<class Data >

VectorX const & STK::BSplineCoefficients< Data >::knots ( ) const

inline

Returns

the vector of knots of the B-spline curve

Definition at line 124 of file STK_BSplineCoefficients.h.

{ return knots_;}

References STK::BSplineCoefficients< Data >::knots_.

Referenced by STK::BSplineRegression< YArray, XVector, Weights >::knots().

nbControlPoints()

template<class Data >

int STK::BSplineCoefficients< Data >::nbControlPoints ( ) const

inline

Returns

the number of control points of the curve (as dim())

Definition at line 122 of file STK_BSplineCoefficients.h.

{ return dim_;}

References STK::IBasis< Data, ArrayXX >::dim_.

nbKnots()

template<class Data >

int STK::BSplineCoefficients< Data >::nbKnots ( ) const

inline

Returns

the number of knots of the B-spline curve

Definition at line 120 of file STK_BSplineCoefficients.h.

{ return nbKnots_;}

References STK::BSplineCoefficients< Data >::nbKnots_.

run()

template<class Data >

bool STK::BSplineCoefficients< Data >::run ( )

virtual

run the computations.

Implements STK::IRunnerBase.

Definition at line 331 of file STK_BSplineCoefficients.h.

{
  // check if data exists
  if (!p_data_)
  {
   msg_error_ = STKERROR_NO_ARG(Error in BSplineCoefficients::run,p_data_ is null);
   return false;
  }
  if (!this->initializeStep()) return false;
  knots_ = minValue_;
  // compute the knots and coefficients
  if (computeKnots()) { computeCoefficients();}
  else                { return false;}
  this->hasRun_ = true;
  return true;
}

References STK::IRunnerBase::hasRun_, STK::IRegression< Array, Array, Weight >::initializeStep(), STK::IRunnerBase::msg_error_, STK::BSplineCoefficients< Data >::run(), and STKERROR_NO_ARG.

Referenced by STK::BSplineCoefficients< Data >::run().

setData()

template<class Data >

void STK::BSplineCoefficients< Data >::setData	(	Data const &	data,
		int	nbControlPoints,
		int	degree = 3,
		Regress::KnotsPosition	position = Regress::uniformKnotsPositions_
	)

[DEPRECATED] Set the whole set of parameters for computing the coefficients

Parameters

data	the input data values
nbControlPoints	number of control points
degree	degree of the B-spline curves (default is 3)
position	method to use for positioning the knots (default is uniform)

Definition at line 257 of file STK_BSplineCoefficients.h.

{ // set data
  p_data_ = &data;
  dim_ = nbControlPoints;
  degree_ = degree;
  position_ = position;
  nbKnots_ = dim_ + degree_ +1;
  lastControlPoint_ = dim_-1;
  Base::update();
}

References STK::IRunnerBase::update().

setDegree()

template<class Data >

void STK::BSplineCoefficients< Data >::setDegree

(

int

degree = 3

)

Set the degree of the BSpline basis.

Parameters

degree

degree of the B-spline curves (default is 3)

Definition at line 309 of file STK_BSplineCoefficients.h.

{
  degree_ = degree;
  nbKnots_ = dim_ + degree_ +1;
  lastControlPoint_ = dim_-1;
  knots_.resize( Range(0, nbKnots_)  );
  Base::update();
}

References STK::IRunnerBase::update().

setDim()

template<class Data >

void STK::BSplineCoefficients< Data >::setDim ( int  dim )

inline

Alias for setting the number of control point (the number of BSpline)

Parameters

dim	number of control points

Definition at line 133 of file STK_BSplineCoefficients.h.

{ setNbControlPoints(dim);}

References STK::IBasis< Data, ArrayXX >::dim(), and STK::BSplineCoefficients< Data >::setNbControlPoints().

setNbControlPoints()

template<class Data >

void STK::BSplineCoefficients< Data >::setNbControlPoints

(

int

nbControlPoints

)

Set the number of control point (the number of BSpline)

Parameters

nbControlPoints

number of control points

Definition at line 296 of file STK_BSplineCoefficients.h.

{
  dim_ = nbControlPoints;
  nbKnots_ = dim_ + degree_ +1;
  lastControlPoint_ = dim_-1;
  knots_.resize( Range(0, nbKnots_) );
  Base::update();
}

References STK::IRunnerBase::update().

Referenced by STK::BSplineCoefficients< Data >::setDim().

setParameters()

template<class Data >

void STK::BSplineCoefficients< Data >::setParameters	(	Data const &	data,
		int	nbControlPoints,
		int	degree = 3,
		Regress::KnotsPosition	position = Regress::uniformKnotsPositions_
	)

Set the whole set of parameters for computing the coefficients.

Parameters

data	the input data values
nbControlPoints	number of control points
degree	degree of the B-spline curves (default is 3)
position	method to use for positioning the knots (default is uniform)

Definition at line 276 of file STK_BSplineCoefficients.h.

{ // set data
  p_data_ = &data;
  dim_ = nbControlPoints;
  degree_ = degree;
  position_ = position;
  nbKnots_ = dim_ + degree_ +1;
  lastControlPoint_ = dim_-1;
  knots_.resize( Range(0, nbKnots_) );
  Base::update();
}

References STK::IRunnerBase::update().

setPosition()

template<class Data >

void STK::BSplineCoefficients< Data >::setPosition

(

Regress::KnotsPosition

position

)

Set the kind of position to use for the knots.

Parameters

position

method to use for positioning the knots (default is uniform)

Definition at line 322 of file STK_BSplineCoefficients.h.

{
  position_ = position;
  Base::update();
}

References STK::IRunnerBase::update().

Member Data Documentation

degree_

template<class Data >

int STK::BSplineCoefficients< Data >::degree_

protected

degree of the B-splines curves.

Definition at line 174 of file STK_BSplineCoefficients.h.

Referenced by STK::BSplineCoefficients< Data >::degree().

knots_

template<class Data >

VectorX STK::BSplineCoefficients< Data >::knots_

protected

Data of the knots.

Definition at line 184 of file STK_BSplineCoefficients.h.

Referenced by STK::BSplineCoefficients< Data >::knots().

lastControlPoint_

template<class Data >

int STK::BSplineCoefficients< Data >::lastControlPoint_

protected

Index of the last control point of the B-spline curves.

This is dim_ - 1.

Definition at line 182 of file STK_BSplineCoefficients.h.

nbKnots_

template<class Data >

int STK::BSplineCoefficients< Data >::nbKnots_

protected

number of knots of the B-spline curves.

Definition at line 178 of file STK_BSplineCoefficients.h.

Referenced by STK::BSplineCoefficients< Data >::nbKnots().

position_

template<class Data >

Regress::KnotsPosition STK::BSplineCoefficients< Data >::position_

protected

Method used in order to position the knots.

Definition at line 176 of file STK_BSplineCoefficients.h.

---

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

• STK_BSplineCoefficients.h