cubicSpline2D.h

Go to the documentation of this file.

#ifndef BALL_MATHS_CUBICSPLINE2D_H
#define BALL_MATHS_CUBICSPLINE2D_H

#include <set>
#include <map>

#ifndef BALL_MATHS_CUBICSPLINE1D_H
# include <BALL/MATHS/cubicSpline1D.h>
#endif

#ifndef BALL_COMMON_EXCEPTION_H
#include <BALL/COMMON/exception.h>
#endif

namespace BALL 
{
  class BALL_EXPORT CubicSpline2D
  {
    public:

      static const int VERBOSITY_LEVEL_DEBUG;
      static const int VERBOSITY_LEVEL_CRITICAL;

      BALL_CREATE(CubicSpline2D)

      //@}

      CubicSpline2D()
        throw();
      

      CubicSpline2D(const std::vector<std::vector<float> >& sample_positions_x,
                    const std::vector<float>& sample_positions_y,
                    const std::vector<std::vector<float> >& sample_values, 
                    bool  return_average = false,
                    bool  is_natural = true,    
                    const std::vector<float>& x_lower_derivatives = std::vector<float>(),  
                    const std::vector<float>& x_upper_derivatives = std::vector<float>(),
                    float y_lower_derivative = 0., 
                    float y_upper_derivative = 0.,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();
    
    

      CubicSpline2D(const std::vector<std::vector<float> >& sample_positions_x,
                    const std::vector<float>& sample_positions_y,
                    const std::vector<std::vector<float> >& sample_values, 
                    const std::vector<float>& x_default_values, 
                    float y_default_value, 
                    const std::vector<float>& x_lower_bounds,
                    const std::vector<float>& x_upper_bounds,
                    float y_lower_bound,
                    float y_upper_bound,
                    bool  is_natural = true,  
                    const std::vector<float>& x_lower_derivatives = std::vector<float>(), 
                    const std::vector<float>& x_upper_derivatives = std::vector<float>(),
                    float y_lower_derivative = 0.0,
                    float y_upper_derivative = 0.0,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();
      
//-------------------------- Constructors with equal x sample positions for all y ------------------------
     //Assumes that all rows have the same x-positions.


      CubicSpline2D(const std::vector<float>& sample_positions_x,
                    const std::vector<float>& sample_positions_y,
                    const std::vector<std::vector<float> >& sample_values, 
                    bool  return_average = false,
                    bool  is_natural = true,    
                    const std::vector<float>& x_lower_derivatives = std::vector<float>(),  
                    const std::vector<float>& x_upper_derivatives = std::vector<float>(),
                    float y_lower_derivative = 0., 
                    float y_upper_derivative = 0.,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();
    
      CubicSpline2D(const std::vector<float>& sample_positions_x,
                    const std::vector<float>& sample_positions_y,
                    const std::vector<std::vector<float> >& sample_values, 
                    const std::vector<float>& x_default_values, 
                    float y_default_value, 
                    const std::vector<float>& x_lower_bounds,
                    const std::vector<float>& x_upper_bounds,
                    float y_lower_bound,
                    float y_upper_bound,
                    bool  is_natural = true,  
                    const std::vector<float>& x_lower_derivatives = std::vector<float>(), 
                    const std::vector<float>& x_upper_derivatives = std::vector<float>(),
                    float y_lower_derivative = 0.0,
                    float y_upper_derivative = 0.0,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();

      
      CubicSpline2D(const CubicSpline2D& cs2D)
        throw();
      
      virtual ~CubicSpline2D()
        throw();
  
      void setVerbosity(int verbosity);

      float operator () (float x, float y)
        throw(); 
          
      // Returns the x-th default value in x direction.
      // If x is out of bound,  <tt> std::numeric_limits<float>::min() </tt> is returned.
      float getXDefaultValue(Index x) const throw(Exception::OutOfRange);
      // Returns the y-th default value in x direction.
      // If y is out of bound,  <tt> std::numeric_limits<float>::min() </tt> is returned.
      float getYDefaultValue() const throw () {return  y_default_value_;}
      // Set the default values in x direction.
      void setXDefaultValues(vector<float> x_default_values)  throw() {x_default_values_ = x_default_values;}
      // Set the default values in y direction.
      void setYDefaultValue(float y_default_value)  throw() {y_default_value_ = y_default_value;} 
        
      
      // Set the lower/upper bound in y direction
      void  setYLowerBound(float lb) throw() {y_lower_bound_ = lb;}
      void  setYUpperBound(float ub) throw() {y_upper_bound_ = ub;}
      // Get the lower/upper bound in y direction
      float getYLowerBound() throw() {return y_lower_bound_;}
      float getYUpperBound() throw() {return y_upper_bound_;}
      // Set the lower/upper bounds in x direction
      void  setXLowerBounds(vector<float> lb) throw() {x_lower_bounds_ = lb;}
      void  setXUpperBounds(vector<float> ub) throw() {x_upper_bounds_ = ub;}
      const vector<float>&  getXLowerBounds() const throw(Exception::OutOfRange) {return x_lower_bounds_ ;}  
      const vector<float>&  getXUpperBounds() const throw(Exception::OutOfRange) {return x_upper_bounds_;}  
      float getXLowerBounds(Index x) const throw(Exception::OutOfRange);  
      float getXUpperBounds(Index x) const throw(Exception::OutOfRange);  


      bool isXNatural(Index x) throw();
      vector<bool> isXNatural() const throw() {return x_is_natural_;}
      void makeXNatural(Index x, bool recompute = true) throw();
      void makeAllXNatural(bool recompute = true) throw();
      void makeYNatural(bool y_is_natural, bool recompute = true) throw();
      // Returns true if the spline in y direction
      // for each call in {\tt operator ()}  is natural.
      bool isYNatural() throw() {return y_is_natural_;}
      
      // Set the lower/upper derivatives in x direction
      void  setXLowerDerivatives(vector<float> ld, bool recompute = true) throw(); 
      void  setXUpperDerivatives(vector<float> ud, bool recompute = true) throw(); 
      float getXLowerDerivatives(Index x) throw(Exception::OutOfRange);
      float getXUpperDerivatives(Index x) throw(Exception::OutOfRange); 
      vector<float>& getXLowerDerivatives() throw() {return x_lower_derivatives_;}
      vector<float>& getXUpperDerivatives() throw() {return x_upper_derivatives_;}
      // Set the lower/upper derivative in y direction
      void setYLowerDerivative (float ld, bool recompute = true) throw(); 
      void setYUpperDerivative (float ud, bool recompute = true) throw();
      // Get the lower/upper derivative in y direction
      float getYLowerDerivative() throw() {return y_lower_derivative_;}
      float getYUpperDerivative() throw() {return y_upper_derivative_;}

      
      CubicSpline1D& getSpline(Position i) throw(Exception::OutOfRange); 
      // {if (i < ..) return splines_[i]; else throw{Exception::OutOfBounds}} 
      const CubicSpline1D& getSpline(Position i) const throw(Exception::OutOfRange);
      Size getNumberOfSplines() const throw() {return splines_.size();} 
  
    private :
      
      void createBiCubicSpline()
        throw(); 
        
      // Sample x positions of the spline.
      // Note: we allow for each y value different x positions.
      std::vector< std::vector<float> > sample_positions_x_;
      
      // Sample y positions of the spline.
      std::vector<float>                sample_positions_y_;

      // For each y position a 1D cubic spline is stored.
      std::vector<CubicSpline1D>        splines_;
      
      // Sample values of the spline.
      std::vector<std::vector<float> >  sample_values_;
      
      //
      //  Parameters 
      //
      
      // Flag to denote, if the default values should be set to the average of the spline averages. 
      bool                   return_average_;
      
      std::vector<float>    x_default_values_; 
      
      float                 y_default_value_; 

      float default_value_;
      
      // Lower bounds of the spline in x direction.
      vector<float>         x_lower_bounds_;

      // Upper bounds of the spline in x direction. 
      vector<float>         x_upper_bounds_;
      
      // Lower bound of the splines in y direction.
      float                 y_lower_bound_;

      // Upper bound of the splines in y direction. 
      float                 y_upper_bound_;
      
      
      // Flag to denote, if the splines in x direction is natural.
      vector<bool>          x_is_natural_;
      
      // Flag to denote, if the splines in y direction are natural.
      bool                  y_is_natural_;

      
      // Values of the first derivatives of the lower x sample position
      vector<float>         x_lower_derivatives_;
      
      // Values of the first derivatives of the upper x sample position
      vector<float>         x_upper_derivatives_;
      
      // Value of the first derivatives of the lower y sample position
      float                 y_lower_derivative_;
      
      // Value of the first derivatives of the upper y sample position
      float                 y_upper_derivative_;

      int                   verbosity_;
  };



}
#endif

---