u3d_bspl3_family.hpp

// u3d_bspl3_family.hpp
// $Id: u3d_bspl3_family.hpp,v 1.13 2007/08/22 10:13:58 guser1 Exp $
#ifndef U3D_BSPL3_FAMILY_
#define U3D_BSPL3_FAMILY_

#include <vector>
#include <u3d_point.hpp>

using namespace std;

#define U3D_MATH_BSPL_PARAM_PREC 1.e-10

//------------------------------------------------------------------------------------------
class U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3AbstractMatrix(){m_is_constructed = false;};
  
  U3dBspl3AbstractMatrix(const U3dBspl3AbstractMatrix &obj);            
  
  virtual ~U3dBspl3AbstractMatrix(){};
  
  virtual double getB(int i, double t) const; 
  
  virtual void info() const;
  
  bool isConstructed() const
  {return m_is_constructed;}
  
  const double (&get() const)[4][4];
 
protected:

  bool m_is_constructed;   

  double m_bm[4][4];
};

//------------------------------------------------------------------------------------------
class U3dBspl3BetaMatrix : public U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3BetaMatrix(double beta1, double beta2);
  
  U3dBspl3BetaMatrix(const U3dBspl3BetaMatrix &obj);
  
  virtual ~U3dBspl3BetaMatrix(){};
  
protected:
  
  void reconstruct(double beta1, double beta2); 
};

//------------------------------------------------------------------------------------------
class U3dBspl3CRomMatrix : public U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3CRomMatrix(double t);
  
  U3dBspl3CRomMatrix(const U3dBspl3CRomMatrix &obj);
  
  virtual ~U3dBspl3CRomMatrix(){};
  
protected:
  
  void reconstruct(double t); 
};

//------------------------------------------------------------------------------------------
class U3dBspl3BSMatrix : public U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3BSMatrix();
  
  U3dBspl3BSMatrix(const U3dBspl3BSMatrix &obj);
  
  virtual ~U3dBspl3BSMatrix(){};
  
protected:
  
  void reconstruct(); 
};

//------------------------------------------------------------------------------------------
class U3dBspl3BezierMatrix : public U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3BezierMatrix();
  
  U3dBspl3BezierMatrix(const U3dBspl3BezierMatrix &obj);
  
  virtual ~U3dBspl3BezierMatrix(){};
  
protected:
  
  void reconstruct(); 
};


//------------------------------------------------------------------------------------------
class U3dSimpleBspl3Curve
{
public:
  
  U3dSimpleBspl3Curve(const U3dBspl3AbstractMatrix *bm, const double (&cp)[4]);
  
  virtual ~U3dSimpleBspl3Curve(){};
  
  double get(double p) const;
  
  double getSp(double p) const;
  
  double getSpp(double p) const;
  
  void getCoeffs(double (&c)[4]) const {
    c[0] = m_rv[0];
    c[1] = m_rv[1];
    c[2] = m_rv[2];
    c[3] = m_rv[3];
  }
    
  double getLineDeviation(double k, double b, double p);
  
protected:
  
  const U3dBspl3AbstractMatrix *m_bm;
  
  double m_rv[4];
  
private:

  void cp2rv(const U3dBspl3AbstractMatrix *bm, const double (&cp)[4]);
};

typedef vector<U3dSimpleBspl3Curve*> U3dSimpleBspl3CurveAr;

//------------------------------------------------------------------------------------------
class U3dSimpleBspl3Surface
{
public:
  
  U3dSimpleBspl3Surface(const U3dBspl3AbstractMatrix *bm, const double (&cp)[4][4]);
  
  virtual ~U3dSimpleBspl3Surface(){};
  
  double get(double p, double q) const;
  
  double getSp(double p, double q) const;
  
  double getSq(double p, double q) const;
  
  double getSpp(double p, double q) const;
  
  double getSqq(double p, double q) const;
  
  double getSpq(double p, double q) const;
  
protected:
  
  const U3dBspl3AbstractMatrix *m_bm;
  
  double m_rm[4][4];
  
  double calc(double *pp, double *qq) const;
  
private:
  
  void cp2rm(const U3dBspl3AbstractMatrix *bm, const double (&cp)[4][4]);
};


//------------------------------------------------------------------------------------------
class U3dSimpleBspl3Surf3d
{
public:
  
  U3dSimpleBspl3Surf3d(const U3dBspl3AbstractMatrix *bm, const double (&cp)[4][4][4]);
  
  virtual ~U3dSimpleBspl3Surf3d(){};
  
  double get(double p, double q, double r) const;
  
protected:
  
  double m_rt[4][4][4];
  
  const U3dBspl3AbstractMatrix *m_bm;
  
  void make_tensor(const U3dBspl3AbstractMatrix *bm, const double (&cp)[4][4][4]);

  double calc(double *pp, double *qq, double *rr) const;
};


//------------------------------------------------------------------------------------------
class U3dBspl3Curve
{
public:
  U3dBspl3Curve (const U3dBspl3AbstractMatrix *bm, const std::vector<double> &ps);
  
  virtual ~U3dBspl3Curve();
  
  double get(double p) const;
  
protected:
  
  U3dSimpleBspl3CurveAr m_spline;
  
  bool m_is_interpolated;
  
private:
  
  bool ips2spline(const U3dBspl3AbstractMatrix *bm, const std::vector<double> &ps);
};

#endif /*U3D_BSPL3_FAMILY_*/