/vol/vipdata/irtk/packages/transformation/include/irtkRigidTransformation.h

/*=========================================================================

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkRigidTransformation.h 2 2008-12-23 12:40:14Z dr $
  Copyright : Imperial College, Department of Computing
              Visual Information Processing (VIP), 2008 onwards
  Date      : $Date: 2008-12-23 12:40:14 +0000 (Tue, 23 Dec 2008) $
  Version   : $Revision: 2 $
  Changes   : $Author: dr $

=========================================================================*/

#ifndef _IRTKRIGIDTRANSFORMATION_H

#define _IRTKRIGIDTRANSFORMATION_H

class irtkRigidTransformation : public irtkHomogeneousTransformation
{

protected:

  double _tx;

  double _ty;

  double _tz;

  double _rx;

  double _ry;

  double _rz;

  virtual irtkMatrix Parameters2Matrix(double *) const;

  virtual void Matrix2Parameters(irtkMatrix, double*) const;

  virtual void SetParameters(double *params);

public:

  irtkRigidTransformation();

  irtkRigidTransformation(const irtkRigidTransformation &);

  virtual ~irtkRigidTransformation();

  void   PutTranslationX(double);

  virtual double GetTranslationX();

  virtual void   PutTranslationY(double);

  virtual double GetTranslationY();

  virtual void   PutTranslationZ(double);

  virtual double GetTranslationZ();

  virtual void   PutRotationX(double);

  virtual double GetRotationX();

  virtual void   PutRotationY(double);

  virtual double GetRotationY();

  virtual void   PutRotationZ(double);

  virtual double GetRotationZ();

  virtual int NumberOfDOFs() const;

  virtual void   Put(int, double);

  virtual double Get(int) const;

  virtual void Rotate(double& x, double& y, double& z);

  virtual Bool IsIdentity();

  virtual void Print();

  static int CheckHeader(char *);

  virtual const char *NameOfClass();

  virtual irtkCifstream& Read(irtkCifstream&);

  virtual irtkCofstream& Write(irtkCofstream&);

  virtual istream& Import(istream&);

  virtual ostream& Export(ostream&);

  virtual void PutMatrix(const irtkMatrix &);

  virtual void UpdateMatrix();

  virtual void UpdateParameter();
};

inline int irtkRigidTransformation::NumberOfDOFs() const
{
  return 6;
}

inline irtkRigidTransformation::irtkRigidTransformation()
{
  int i;

  _tx = _ty = _tz = 0;
  _rx = _ry = _rz = 0;

  // Free memory allocated for DOF status by base class
  delete []_status;

  // Allocate memory for DOF status
  _status = new _Status[this->NumberOfDOFs()];

  // Initialize memory for DOF status
  for (i = 0; i < this->NumberOfDOFs(); i++) {
    _status[i] = _Active;
  }

  // Update transformation matrix
  this->UpdateMatrix();
}

inline irtkRigidTransformation::irtkRigidTransformation(const irtkRigidTransformation &t)
{
  int i;

  _tx = t._tx;
  _ty = t._ty;
  _tz = t._tz;
  _rx = t._rx;
  _ry = t._ry;
  _rz = t._rz;

  // Free memory allocated for DOF status by base class
  delete []_status;

  // Allocate memory for DOF status
  _status = new _Status[this->NumberOfDOFs()];

  // Initialize memory for DOF status
  for (i = 0; i < this->NumberOfDOFs(); i++) {
    _status[i] = t._status[i];
  }

  // Update transformation matrix
  this->UpdateMatrix();
}

inline irtkRigidTransformation::~irtkRigidTransformation()
{
}

inline void irtkRigidTransformation::PutRotationX(double rx)
{
  _rx = rx;
  this->UpdateMatrix();
}

inline double irtkRigidTransformation::GetRotationX()
{
  return _rx;
}

inline void irtkRigidTransformation::PutRotationY(double ry)
{
  _ry = ry;
  this->UpdateMatrix();
}

inline double irtkRigidTransformation::GetRotationY()
{
  return _ry;
}

inline void irtkRigidTransformation::PutRotationZ(double rz)
{
  _rz = rz;
  this->UpdateMatrix();
}

inline double irtkRigidTransformation::GetRotationZ()
{
  return _rz;
}

inline void irtkRigidTransformation::PutTranslationX(double tx)
{
  _tx = tx;
  this->UpdateMatrix();
}

inline double irtkRigidTransformation::GetTranslationX()
{
  return _tx;
}

inline void irtkRigidTransformation::PutTranslationY(double ty)
{
  _ty = ty;
  this->UpdateMatrix();
}

inline double irtkRigidTransformation::GetTranslationY()
{
  return _ty;
}

inline void irtkRigidTransformation::PutTranslationZ(double tz)
{
  _tz = tz;
  this->UpdateMatrix();
}

inline double irtkRigidTransformation::GetTranslationZ()
{
  return _tz;
}

inline void irtkRigidTransformation::PutMatrix(const irtkMatrix &matrix)
{
  _matrix = matrix;
  this->UpdateParameter();
}

inline const char *irtkRigidTransformation::NameOfClass()
{
  return "irtkRigidTransformation";
}

inline void irtkRigidTransformation::SetParameters(double *params)
{
  _tx = params[TX];
  _ty = params[TY];
  _tz = params[TZ];

  _rx = params[RX];
  _ry = params[RY];
  _rz = params[RZ];

  this->UpdateMatrix();
}

#endif

Generated on Mon Mar 23 16:55:53 2009 for IRTK by Doxygen 1.5.4