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

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

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

#define _HOMOGENEOUSTRANSFORMATION_H

typedef enum {TX, TY, TZ, RX, RY, RZ, SX, SY, SZ, SXY, SYZ, SXZ, SYX, SZY, SZX}
irtkHomogeneousTransformationParameterIndex;

class irtkHomogeneousTransformation : public irtkTransformation
{

protected:

  irtkMatrix _matrix;

public:

  irtkHomogeneousTransformation();

  irtkHomogeneousTransformation(const irtkMatrix &);

  irtkHomogeneousTransformation(const irtkHomogeneousTransformation &);

  virtual ~irtkHomogeneousTransformation();

  virtual int    NumberOfDOFs() const;

  virtual double Get(int) const;

  virtual void   Put(int, double);

  virtual irtkMatrix GetMatrix() const;

  virtual void      PutMatrix(const irtkMatrix &);

  virtual void Transform(double &, double &, double &, double = 0);

  virtual void GlobalTransform(double &, double &, double &, double = 0);

  virtual void LocalTransform (double &, double &, double &, double = 0);

  virtual void GlobalDisplacement(double &, double &, double &, double = 0);

  virtual void LocalDisplacement(double &, double &, double &, double = 0);

  virtual void Invert();

  virtual double Inverse(double &, double &, double &, double = 0, double = 0.01);

  virtual void Jacobian(irtkMatrix &, double, double, double, double = 0);

  virtual void LocalJacobian(irtkMatrix &, double, double, double, double = 0);

  virtual void GlobalJacobian(irtkMatrix &, double, double, double, double = 0);

  virtual Bool IsIdentity();

  virtual void Print();

  virtual const char *NameOfClass();

  virtual irtkCifstream& Read(irtkCifstream&);

  virtual irtkCofstream& Write(irtkCofstream&);

  virtual void Import(char *);

  virtual void Export(char *);

  virtual istream& Import(istream&);

  virtual ostream& Export(ostream&);

};

inline int irtkHomogeneousTransformation::NumberOfDOFs() const
{
  return 12;
}

inline irtkHomogeneousTransformation::irtkHomogeneousTransformation()
{
  int i;

  // Create 4 x 4 transformation matrix
  _matrix = irtkMatrix(4, 4);

  // Initialize to identity
  _matrix.Ident();

  // 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;
  }
}

inline irtkHomogeneousTransformation::irtkHomogeneousTransformation(const irtkMatrix &matrix)
{
  int i;

  _matrix = matrix;

  // 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;
  }
}

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

  _matrix = t._matrix;

  // 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];
  }
}

inline irtkHomogeneousTransformation::~irtkHomogeneousTransformation()
{
}

inline void irtkHomogeneousTransformation::PutMatrix(const irtkMatrix &matrix)
{
  _matrix = matrix;
}

inline irtkMatrix irtkHomogeneousTransformation::GetMatrix() const
{
  return _matrix;
}

inline void irtkHomogeneousTransformation::GlobalTransform(double &x, double &y, double &z, double t)
{
  this->Transform(x, y, z, t);
}

inline void irtkHomogeneousTransformation::LocalTransform(double &x, double &y, double &z, double)
{
}

inline void irtkHomogeneousTransformation::GlobalDisplacement(double &x, double &y, double &z, double t)
{
  double a, b, c;

  a = x;
  b = y;
  c = z;
  this->Transform(a, b, c, t);
  x = a - x;
  y = b - y;
  z = c - z;
}

inline void irtkHomogeneousTransformation::LocalDisplacement(double &x, double &y, double &z, double)
{
  x = 0;
  y = 0;
  z = 0;
}

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

#endif

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