cubicSpline1D.h

Go to the documentation of this file.

#ifndef BALL_MATHS_CUBICSPLINE1D_H
#define BALL_MATHS_CUBICSPLINE1D_H

#include <set>
#include <map>

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_COMMON_LIMITS_H
# include <BALL/COMMON/limits.h>
#endif

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif

namespace BALL 
{

  class BALL_EXPORT CubicSpline1D
  {
    public: 
      
      static const int VERBOSITY_LEVEL_DEBUG;
      static const int VERBOSITY_LEVEL_CRITICAL;

  
      BALL_CREATE(CubicSpline1D)
      

      
      CubicSpline1D()
        throw();
      
      CubicSpline1D(const std::vector<float>& sample_positions, 
                    const std::vector<float>& sample_values, 
                    bool return_average = false, 
                    bool is_natural = true, 
                    float lower_derivative = 0.0,
                    float upper_derivative = 0.0,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();
    
      CubicSpline1D(const std::vector<float>& sample_positions, 
                    const std::vector<float>& sample_values, 
                    float default_value,
                    bool is_natural = true, 
                    float lower_derivative = 0.0,
                    float upper_derivative = 0.0,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();
    
      CubicSpline1D(const std::vector<float>& sample_positions, 
                    const std::vector<float>& sample_values, 
                    float default_value, 
                    float lower_bound, 
                    float upper_bound,  
                    bool is_natural = true, 
                    float lower_derivative = 0.0,
                    float upper_derivative = 0.0,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();
      
      CubicSpline1D(const std::vector<float>& sample_positions, 
                    const std::vector<float>& sample_values, 
                    float lower_bound, 
                    float upper_bound,  
                    bool return_average = false,
                    float default_value = std::numeric_limits<float>::min(), 
                    bool is_natural = true, 
                    float lower_derivative = 0.0,
                    float upper_derivative = 0.0,
                    int verbosity = VERBOSITY_LEVEL_DEBUG)
        throw();


      CubicSpline1D(const CubicSpline1D& cs1D)
        throw();
      
      virtual ~CubicSpline1D()
        throw();
  
      void setVerbosity(int verbosity) { verbosity_ = verbosity; }

      int  getVerbosity() const { return verbosity_; }
      
      float operator () (float x) throw();

      std::vector<float> getCurvature() const 
       throw() {return curvature_;}
      
      void setCurvature(std::vector<float> curvature) throw();
      
      void setValues(std::vector<float> values, bool recompute = true) throw();
      
      std::vector<float> getValues() const throw() {return sample_values_;}
      
      std::vector<float> getPositions() const throw() {return sample_positions_;}
      
      void setPositions(std::vector<float> positions, bool recompute = true) throw();
      
      void  setDefaultValue(float value) throw() {default_value_ = value;}
      float getDefaultValue() const throw() {return default_value_;}              

      void setLowerBound(float lb) throw() {lower_bound_ = lb;}
      void setUpperBound(float ub) throw() {upper_bound_ = ub;}

      float getLowerBound() const throw() {return lower_bound_;}
      float getUpperBound() const throw() {return upper_bound_;}
    
      bool isNatural() const throw() {return  is_natural_;}
      
      void makeNatural(bool recompute = true) throw();
      
      void setBoudaryDerivatives(float lower_derivative, float upper_derivative, bool recompute = true) throw();
      
      void setLowerDerivative(float derivative, bool recompute = true) throw();
      
      float getLowerDerivative() const throw() {return lower_derivative_;}
      
      void setUpperDerivative(float derivative, bool recompute = true) throw();
      
      float getUpperDerivative() const  throw() {return upper_derivative_;}

    private : 
      
      void createSpline()
        throw(); 
    
      
      // Sample positions of the spline.
      std::vector<float> sample_positions_;
      // Sample values of the spline.
      std::vector<float> sample_values_;
      // Curvature of the spline.
      std::vector<float> curvature_;
      
      // Flag to denote, if the default values should be set to the average 
      bool return_average_;
      
      float default_value_; 
      
      // Lower bound of the spline
      float lower_bound_;

      // Upper bound of the spline
      float upper_bound_;
      
      // Flag to denote, if the spline is natural 
      bool is_natural_;
      
      // Value of the first derivative of the lower sample position
      float lower_derivative_;
      
      // Value of the first derivative of the upper sample position
      float upper_derivative_;

      int verbosity_;
  };

}
#endif

---