u3d_bspl3_matrices.hpp

/* u3d_bspl3_matricies.hpp */
/* $Id: u3d_bspl3_matrices.hpp,v 1.3 2009/03/17 09:34:13 urij Exp $ */
#ifndef __u3d_bspl3_matricies_hpp
#define __u3d_bspl3_matricies_hpp

enum U3dBspl3MatrixType
  {
    LinearInt,     
    Parabolic,     
    Cubic,         
    BS,            
    Beta,          
    CatmullRom,    
    KB,            
    Undefined      
  };

//------------------------------------------------------------------------------------------
class U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3AbstractMatrix(){m_is_constructed = false; m_type = Undefined;};
  
  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];
  
  U3dBspl3MatrixType type() const {return m_type;}

protected:
  
  bool m_is_constructed;   
  
  U3dBspl3MatrixType m_type;
  
  double m_bm[4][4];
};

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

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

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

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

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

//------------------------------------------------------------------------------------------
class U3dBspl3KBMatrix : public U3dBspl3AbstractMatrix
{
public:
  
  U3dBspl3KBMatrix(double a, double b, double c, double d);
  
  U3dBspl3KBMatrix(const U3dBspl3KBMatrix &obj);
  
  virtual ~U3dBspl3KBMatrix(){};
  
protected:
  
  void reconstruct(double a, double b, double c, double d); 
};

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


#endif /* u3d_bspl3_matricies.hpp */