Nurbs2D.hh

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

#ifndef NURBS2D_HH
#define NURBS2D_HH

#include <Base/Math/Vector2.hh>
#include "NurbsBase.hh"

namespace BIAS{

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

  template <class ControlPointsT>
  class Nurbs2D : 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
    Nurbs2D(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,0] - [1,1] )
    /// @param result The return value
    void Eval(const BIAS::Vector2<double> &nurbsParam, ControlPointsT &result) const;

    /// Evaluate the NURBS function at a given point in the parameter space
    /// for a certain control point vector (helpfull for optimization)
    /// @param nurbsParam Point in the parameter space ( [0,0] - [1,1] )
    /// @param result The return value
    void EvalCustom(const BIAS::Vector2<double> &nurbsParam, ControlPointsT &result, const ControlPointsT** controlPoints) const;

    /// Very generic initialization function for the control points. The control points
    /// will be distributed equally over the cube defined by the min-max values.
    void Init(const ControlPointsT minX,const ControlPointsT maxX,
              const ControlPointsT minY,const ControlPointsT maxY);

  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 indexU The u index of the control point
    /// @param indexV The v index of the control point
    /// @param value The value that is assigned to the control point
    inline void SetCtrlPoint(const int &indexU,const int &indexV, const ControlPointsT &value){
      BIASASSERT(indexU >= 0);
      BIASASSERT(indexU < numCtrlPoints_);
      BIASASSERT(indexV >= 0);
      BIASASSERT(indexV < numCtrlPoints_);
      controlPoints_[indexU][indexV] = value;
    }

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

    /// Evaluate the base function for the control point for the point nurbsParam.
    inline void EvalBaseFunc(const int x,const int y,const BIAS::Vector2<double> &nurbsParam, double &result) const{
      result = (BaseFunc(0,x,degree_,nurbsParam[0])*BaseFunc(1,y,degree_,nurbsParam[1]));
    }

    /// Evaluate the base function for the control point for the point nurbsParam using
    /// a dedicated cache for the serial evaluation
    inline void EvalBaseFunc(const int x,const int y,const BIAS::Vector2<double> &nurbsParam, double &result, double* baseFuncCache) const{
      result = (BaseFunc(0,x,degree_,nurbsParam[0],baseFuncCache)*BaseFunc(1,y,degree_,nurbsParam[1],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 (indices)
    /// @param end The last control points (indices)
    inline void GetRelevantBaseCtrlPoints(const BIAS::Vector2<double> &nurbsParam, BIAS::Vector2<int> &begin, BIAS::Vector2<int> &end) const{
      for (int i = 0; i < 2; i++){
        begin[i] = 0;
        for (int j = 0; j < numCtrlPoints_-degree_; j++)
          if (nurbsParam[i] >= knotVector_[i][j+degree_])
            begin[i] = j;
          else
            break;
        end[i] = numCtrlPoints_-1;
        for (int j = numCtrlPoints_-1; j >= degree_; j--)
          if (nurbsParam[i] <= knotVector_[i][j-degree_])
            end[i] = j;
      }
    };

  };

}

#endif // NURBS2D_HH