Tools/Math/Interpol.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
#ifndef INTERPOL_H_INCLUDED
#define INTERPOL_H_INCLUDED
//------------------------------------------------------------------------------
#include <vector>
#include <map>
#include "Tools/Math/LA_Vector.h"
#include "Tools/Streams/InOut.h"
//------------------------------------------------------------------------------
namespace interpol {
//------------------------------------------------------------------------------
class Point
{
public:
  Point();
  Point(double x, double y);

public:
  double x;
  double y;
};
//------------------------------------------------------------------------------
bool operator<(const Point& p1, const Point& p2);
//------------------------------------------------------------------------------
class Interpolation;
class LinearInterpolation;
class SplineInterpolation;
//------------------------------------------------------------------------------
class InterpolationFactory
{
public:
  enum Type
  {
    Linear,
    Spline
  };

public:
  static Interpolation* Create(Type type);
  static Interpolation* Create(Type type, const Interpolation* pSource);
  static Interpolation* Transform(Type type, Interpolation* pSource);
  static void Destroy(Interpolation* pInterpolation);

  static void Write(Out& out, const Interpolation* pInterpolation);
  static Interpolation* Read(In& in);
};
//------------------------------------------------------------------------------
class Interpolation
{
public:
  typedef std::map<int, Point>::const_iterator ConstPointIterator;

protected:
  Interpolation();
  virtual ~Interpolation();

private:
  Interpolation(const Interpolation& interpolation) {}
  Interpolation& operator=(const Interpolation& interpolation) { return *this; }

public:
  virtual int AddPoint(const Point& p);
  virtual int AddPoint(double x, double y);
  virtual bool MovePoint(int index, const Point& p);
  virtual bool RemovePoint(int index);

  virtual double GetInterpolatedY(double x) const = 0;

  virtual ConstPointIterator GetPointBegin() const;
  virtual ConstPointIterator GetPointEnd() const;

  virtual InterpolationFactory::Type GetType() const = 0;


protected:
  virtual void Assign(const Interpolation& interpolation);
  virtual void OnChange() {}

private:
  virtual void BuildSortedPoints();

protected:
  std::vector<Point> xSortedPoints;

private:
  int nextIndex;
  std::map<int, Point> points;

  friend class InterpolationFactory;
  friend Out& operator<<(Out& stream, const Interpolation& interpolation);
  friend In& operator>>(In& stream, Interpolation& interpolation);
};
//------------------------------------------------------------------------------
class LinearInterpolation : public Interpolation
{
protected:
  LinearInterpolation();
  virtual ~LinearInterpolation();

public:
  virtual double GetInterpolatedY(double x) const;
  virtual InterpolationFactory::Type GetType() const;

  friend class InterpolationFactory;
};
//------------------------------------------------------------------------------
class SplineInterpolation : public Interpolation
{
protected:
  SplineInterpolation();
  virtual ~SplineInterpolation();

public:
  virtual double GetInterpolatedY(double x) const;
  virtual InterpolationFactory::Type GetType() const;

protected:
  virtual void OnChange();
  
private:
  virtual void CalcSplines();

private:
  LA::Vector x;
  LA::Vector y;
  LA::Vector a;
  LA::Vector b;
  LA::Vector c;
  LA::Vector d;

  friend class InterpolationFactory;
};
//------------------------------------------------------------------------------
Out& operator<<(Out& stream, const Point& p);
In& operator>>(In& stream, Point& p);
} // namespace interpol
//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------

---