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

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

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkAffineTransformation.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 _IRTKAFFINETRANSFORMATION_H

#define _IRTKAFFINETRANSFORMATION_H

class irtkAffineTransformation : public irtkRigidTransformation
{

protected:

  double _sx;

  double _sy;

  double _sz;

  double _sxy;

  double _syz;

  double _sxz;

  virtual irtkMatrix Parameters2Matrix(double *) const;

  virtual irtkMatrix Parameters2Matrix_15DOFs(double *) const;

  virtual void SetParameters(double *);

public:

  irtkAffineTransformation();

  irtkAffineTransformation(const irtkRigidTransformation &);

  irtkAffineTransformation(const irtkAffineTransformation &);

  virtual ~irtkAffineTransformation();

  virtual void   PutScaleX(double);

  virtual double GetScaleX();

  virtual void   PutScaleY(double);

  virtual double GetScaleY();

  virtual void   PutScaleZ(double);

  virtual double GetScaleZ();

  virtual void   PutShearXY(double);

  virtual double GetShearXY();

  virtual void   PutShearYZ(double);

  virtual double GetShearYZ();

  virtual void   PutShearXZ(double);

  virtual double GetShearXZ();

  virtual int NumberOfDOFs() const;

  virtual void   Put(int, double);

  virtual double Get(int) const;

  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 irtkAffineTransformation::NumberOfDOFs() const
{
  return 12;
}

inline irtkAffineTransformation::irtkAffineTransformation()
{
  int i;

  // Initialize rotations and translations
  _tx = _ty = _tz = 0;
  _rx = _ry = _rz = 0;

  // Initialize scale and shears
  _sx  = _sy  = _sz  = 100;
  _sxy = _syz = _sxz = 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 irtkAffineTransformation::irtkAffineTransformation(const irtkRigidTransformation &t)
{
  int i;

  // Copy rotations and translations
  _tx = t.Get(0);
  _ty = t.Get(1);
  _tz = t.Get(2);
  _rx = t.Get(3);
  _ry = t.Get(4);
  _rz = t.Get(5);

  // Initialize scale and shears
  _sx  = 100;
  _sy  = 100;
  _sz  = 100;
  _sxy = 0;
  _syz = 0;
  _sxz = 0;

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

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

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

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

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

  // Copy rotations and translations
  _tx = t._tx;
  _ty = t._ty;
  _tz = t._tz;
  _rx = t._rx;
  _ry = t._ry;
  _rz = t._rz;

  // Copy scale and shears
  _sx  = t._sx;
  _sy  = t._sy;
  _sz  = t._sz;
  _sxy = t._sxy;
  _syz = t._syz;
  _sxz = t._sxz;

  // 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 irtkAffineTransformation::~irtkAffineTransformation()
{
}

inline void irtkAffineTransformation::PutScaleX(double sx)
{
  _sx = sx;
  this->UpdateMatrix();
}

inline double irtkAffineTransformation::GetScaleX()
{
  return _sx;
}

inline void irtkAffineTransformation::PutScaleY(double sy)
{
  _sy = sy;
  this->UpdateMatrix();
}

inline double irtkAffineTransformation::GetScaleY()
{
  return _sy;
}

inline void irtkAffineTransformation::PutScaleZ(double sz)
{
  _sz = sz;
  this->UpdateMatrix();
}

inline double irtkAffineTransformation::GetScaleZ()
{
  return _sz;
}

inline void irtkAffineTransformation::PutShearXY(double sxy)
{
  _sxy = sxy;
  this->UpdateMatrix();
}

inline double irtkAffineTransformation::GetShearXY()
{
  return _sxy;
}

inline void irtkAffineTransformation::PutShearYZ(double syz)
{
  _syz = syz;
  this->UpdateMatrix();
}

inline double irtkAffineTransformation::GetShearYZ()
{
  return _syz;
}

inline void irtkAffineTransformation::PutShearXZ(double sxz)
{
  _sxz = sxz;
  this->UpdateMatrix();
}

inline double irtkAffineTransformation::GetShearXZ()
{
  return _sxz;
}

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

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

inline void irtkAffineTransformation::SetParameters(double *params)
{
  this->irtkRigidTransformation::SetParameters(params);

  _sx  = params[SX];
  _sy  = params[SY];
  _sz  = params[SZ];

  _sxy = params[SXY];
  _syz = params[SYZ];
  _sxz = params[SXZ];

  this->UpdateMatrix();
}

#endif

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