Nurbs3D.hh

/*
 * Nurbs3D.hh
 *
 *  Created on: Jul 1, 2010
 *      Author: jordt
 */

#ifndef NURBS3D_HH_
#define NURBS3D_HH_

#include <Base/Math/Vector3.hh>
#include <Base/Debug/Error.hh>
#include "NurbsBase.hh"



//class SimpleOptimizerNurbs3D;
//class AdvancedOptimizerNurbs3D;

namespace BIAS{

  /** This class implements a NURBS-function with a three dimensional
    * parameter space (A NURBS volume). The dimension of the output
    * values is defined by the template type of control points
    * Note: For common NURBS surface use the Nurbs2D class with three dimensional
    * control points
    * @author jordt
    */

  template <class ControlPointsT>
  class Nurbs3D : public NurbsBase {

  friend class SimpleOptimizerNurbs3D;
  friend class AdvancedOptimizerNurbs3D;

  public:

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

    ~Nurbs3D();

    /// Evaluate the NURBS function at a given point in the parameter space
    /// @param nurbsParam Point in the parameter space ( [0,0,0] - [1,1,1] )
    /// @param result The return value
    void Eval(const BIAS::Vector3<double> &nurbsParam, ControlPointsT &result) 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,
              const ControlPointsT minZ,const ControlPointsT maxZ);

  protected:

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

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

    /// A vector containing the control points in the vicinity of the hyper sphere
    std::vector<BIAS::Vector3<int> > sphereCtrlPoints_;

    // 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 indexW The w 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  int &indexW, const ControlPointsT &value){
      BIASASSERT(indexU >= 0);
      BIASASSERT(indexU < numCtrlPoints_);
      BIASASSERT(indexV >= 0);
      BIASASSERT(indexV < numCtrlPoints_);
      BIASASSERT(indexW >= 0);
      BIASASSERT(indexW < numCtrlPoints_);
      controlPoints_[indexU][indexV][indexW] = 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
    /// @param indexW The w index of the control point
    inline ControlPointsT GetCtrlPoint(const int &indexU,const int &indexV,const int &indexW) const{
      BIASASSERT(indexU >= 0);
      BIASASSERT(indexU < numCtrlPoints_);
      BIASASSERT(indexV >= 0);
      BIASASSERT(indexV < numCtrlPoints_);
      BIASASSERT(indexW >= 0);
      BIASASSERT(indexW < numCtrlPoints_);
      return controlPoints_[indexU][indexV][indexW];
    }

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

    /// 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 int z,const  BIAS::Vector3<double> &nurbsParam, double &result, double* baseFuncCache) const{
      result = (BaseFunc(0,x,degree_,nurbsParam[0],baseFuncCache)*BaseFunc(1,y,degree_,nurbsParam[1],baseFuncCache)*BaseFunc(2,z,degree_,nurbsParam[2],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::Vector3<double> &nurbsParam, BIAS::Vector3<int> &begin, BIAS::Vector3<int> &end) const{
      for (int i = 0; i < 3; 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 /* NURBS3D_HH_ */