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();
      

      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);
    
    

      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);
      
//-------------------------- 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);
    
      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);

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

      float operator () (float x, float y); 
          
      float getXDefaultValue(Index x) const;

      float getYDefaultValue() const {return y_default_value_;}

      // Set the default values in x direction.
      void setXDefaultValues(vector<float> x_default_values) {x_default_values_ = x_default_values;}

      // Set the default values in y direction.
      void setYDefaultValue(float y_default_value) {y_default_value_ = y_default_value;} 
        
      
      // Set the lower/upper bound in y direction
      void  setYLowerBound(float lb) {y_lower_bound_ = lb;}
      void  setYUpperBound(float ub) {y_upper_bound_ = ub;}
      // Get the lower/upper bound in y direction
      float getYLowerBound() {return y_lower_bound_;}
      float getYUpperBound() {return y_upper_bound_;}
      // Set the lower/upper bounds in x direction
      void  setXLowerBounds(vector<float> lb) {x_lower_bounds_ = lb;}
      void  setXUpperBounds(vector<float> ub) {x_upper_bounds_ = ub;}

      const vector<float>&  getXLowerBounds() const {return x_lower_bounds_ ;}  

      const vector<float>&  getXUpperBounds() const {return x_upper_bounds_;}  

      float getXLowerBounds(Index x) const;  

      float getXUpperBounds(Index x) const;  

      bool isXNatural(Index x);
      vector<bool> isXNatural() const {return x_is_natural_;}

      void makeXNatural(Index x, bool recompute = true);

      void makeAllXNatural(bool recompute = true);

      void makeYNatural(bool y_is_natural, bool recompute = true);

      bool isYNatural() {return y_is_natural_;}
      
      // Set the lower/upper derivatives in x direction
      void  setXLowerDerivatives(vector<float> ld, bool recompute = true); 
      void  setXUpperDerivatives(vector<float> ud, bool recompute = true); 

      float getXLowerDerivatives(Index x);

      float getXUpperDerivatives(Index x); 

      vector<float>& getXLowerDerivatives() {return x_lower_derivatives_;}
      vector<float>& getXUpperDerivatives() {return x_upper_derivatives_;}

      // Set the lower/upper derivative in y direction
      void setYLowerDerivative (float ld, bool recompute = true); 
      void setYUpperDerivative (float ud, bool recompute = true);

      // Get the lower/upper derivative in y direction
      float getYLowerDerivative() {return y_lower_derivative_;}
      float getYUpperDerivative() {return y_upper_derivative_;}

      
      CubicSpline1D& getSpline(Position i); 

      const CubicSpline1D& getSpline(Position i) const;

      Size getNumberOfSplines() const {return splines_.size();} 
  
    private :
      
      void createBiCubicSpline(); 
        
      // 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