Nurbs1D.hh

/*
 * NurbsBase.hh
 *
 *  Created on: Jul 13, 2010
 *      Author: jordt
 */

#ifndef NURBS1D_HH
#define NURBS1D_HH

#include <Base/Debug/Error.hh>

#include "NurbsBase.hh"

namespace BIAS{

  /** This class implements a NURBS-function with a one dimensional
    * parameter space (A NURBS line). The dimension of the output
    * values is defined by the template type of control points
    * @author jordt
    */

  template <class ControlPointsT>
  class Nurbs1D : public NurbsBase {

  public:

    /// Standard Constructor
    /// @param knotsPerDim The number of knots in the knot vector (without the dublications)
    /// @param degree The degree of the b-splines
    Nurbs1D(int knotsPerDim = 4, int degree = 2);

    /// Evaluate the NURBS function at a given point in the parameter space
    /// @param nurbsParam Point in the parameter space ( [0] - [1] )
    /// @param result The return value
    void Eval(const double &nurbsParam, ControlPointsT &result) const;

  protected:

    /// The array of control points
    ControlPointsT* controlPoints_;

    /// The corresponding weights to the function points
    double * weights_;

    // Some inline functions:

  public:

    /// Set the value of a specific control point. No out of bounds checks are
    /// performed in release builds
    /// @param index The index of the control point
    /// @param value The value that is assigned to the control point
    inline void SetCtrlPoint(const int &index, const ControlPointsT &value){
      BIASASSERT(index >= 0);
      BIASASSERT(index < numCtrlPoints_);
      controlPoints_[index]= value;
    }

    /// Get the value of a specific control point. No out of bounds checks are
    /// performed in release builds
    /// @param index The index of the control point
    inline ControlPointsT GetCtrlPoint(int &index) const{
      BIASASSERT(index >= 0);
      BIASASSERT(index < numCtrlPoints_);
      return controlPoints_[index];
    }  const

    /// Evaluate the base function for the control point (x,y,z) for the point nurbsParam.
    inline void EvalBaseFunc(const int x,const double &nurbsParam, double &result) const{
      result = (BaseFunc(0,x,degree_,nurbsParam));
    }

    /// Evaluate the base function for the control point (x,y,z) for the point nurbsParam using
    /// a dedicated cache for the serial evaluation
    inline void EvalBaseFunc(const int x,const int y,const double &nurbsParam, double &result, double* baseFuncCache) const{
      result = (BaseFunc(0,x,degree_,nurbsParam,baseFuncCache));
    }

    /// for a given point in the parameter space, this functions yields for each dimension the first and
    /// the last control point index influencing the value at this position.
    /// @param nurbsParam The point in the parameter space to perform the test in
    /// @param begin The first control point (index)
    /// @param end The last control points (index)
    inline void GetRelevantBaseCtrlPoints(const double &nurbsParam, int &begin, int &end) const{

      begin = 0;
      for (int j = 0; j < numCtrlPoints_-degree_; j++)
        if (nurbsParam >= knotVector_[0][j+degree_])
          begin = j;
        else
          break;
      end = numCtrlPoints_-1;
      for (int j = numCtrlPoints_-1; j >= degree_; j--)
        if (nurbsParam <= knotVector_[0][j-degree_])
          end = j;
      }

    /// Returns the position of a knot with a given index
    double GetKnot(int index) const;

    /// Set the position of a knot with a given index
    void SetKnot(int index, double value);

  };

}

#endif // NURBS1D_HH