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

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

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

#define _IRTKTRANSFORMATION_H

#include <irtkImage.h>

typedef enum { _Active, _Passive, _Unknown } _Status;

#define IRTKTRANSFORMATION_MAGIC            815007

#define IRTKTRANSFORMATION_HOMOGENEOUS      1
#define IRTKTRANSFORMATION_RIGID            2
#define IRTKTRANSFORMATION_AFFINE           3
#define IRTKTRANSFORMATION_BSPLINE_FFD      4
#define IRTKTRANSFORMATION_LINEAR_FFD       5
#define IRTKTRANSFORMATION_EIGEN_FFD        6
#define IRTKTRANSFORMATION_MFFD             7
#define IRTKTRANSFORMATION_FLUID            8
#define IRTKTRANSFORMATION_LATTICE_FFD      9
#define IRTKTRANSFORMATION_MULTI_FRAME_LATTICE_FFD 10
#define IRTKTRANSFORMATION_QUATERNION       11
#define IRTKTRANSFORMATION_BSPLINE_FFD_EXT1 12
#define IRTKTRANSFORMATION_LINEAR_FFD_EXT1  13
#define IRTKTRANSFORMATION_BSPLINE_FFD_4D   14

class irtkTransformation : public irtkObject
{

protected:

  _Status *_status;

  irtkTransformation();

public:

  static irtkTransformation *New(char *);

  static irtkTransformation *New(irtkTransformation *);

  virtual ~irtkTransformation();

  virtual int    NumberOfDOFs() const = 0;

  virtual double Get(int) const = 0;

  virtual void   Put(int, double) = 0;

  virtual void   PutStatus(int, _Status);

  virtual _Status GetStatus(int) const;

  virtual void Transform(irtkPoint &);

  virtual void Transform(irtkPointSet &);

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

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

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

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

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

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

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

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

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

  virtual double Jacobian(double, double, double, double = 0);

  virtual double LocalJacobian(double, double, double, double = 0);

  virtual double GlobalJacobian(double, double, double, double = 0);

  virtual Bool IsIdentity() = 0;

  virtual void Read (char *);

  virtual void Write(char *);

  virtual void Import(char *);

  virtual void Export(char *);

  virtual irtkCifstream& Read(irtkCifstream&) = 0;

  virtual irtkCofstream& Write( irtkCofstream&) = 0;

  virtual istream& Import(istream&);

  virtual ostream& Export(ostream&);

  virtual void Draw ();

  virtual void Print() = 0;

  virtual const char *NameOfClass() = 0;
};


inline _Status irtkTransformation::GetStatus(int index) const
{
  if (index >= this->NumberOfDOFs()) {
    cerr << "irtkTransformation::GetStatus: No such dof" << endl;
    exit(1);
  }
  return _status[index];
}

inline void irtkTransformation::PutStatus(int index, _Status s)
{
  if (index >= this->NumberOfDOFs()) {
    cerr << "irtkTransformation::PutStatus: No such dof" << endl;
    exit(1);
  }
  _status[index] = s;
}

inline void irtkTransformation::Transform(irtkPoint &p)
{
  this->Transform(p._x, p._y, p._z);
}

inline void irtkTransformation::Transform(irtkPointSet &pset)
{
  for (int i = 0; i < pset.Size(); i++) {
    irtkPoint p = pset(i);
    this->Transform(p._x, p._y, p._z);
    pset(i) = p;
  }
}

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

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

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

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

inline double irtkTransformation::Jacobian(double x, double y, double z, double t)
{
  irtkMatrix jac(3, 3);

  // Calculate Jacobian
  this->Jacobian(jac, x, y, z, t);

  // Determinant of Jacobian of deformation derivatives
  return (jac(0, 0)*jac(1, 1)*jac(2, 2) + jac(0, 1)*jac(1, 2)*jac(2, 0) +
          jac(0, 2)*jac(1, 0)*jac(2, 1) - jac(0, 2)*jac(1, 1)*jac(2, 0) -
          jac(0, 0)*jac(1, 2)*jac(2, 1) - jac(0, 1)*jac(1, 0)*jac(2, 2));
}


inline double irtkTransformation::LocalJacobian(double x, double y, double z, double t)
{
  irtkMatrix jac(3, 3);

  // Calculate Jacobian
  this->LocalJacobian(jac, x, y, z, t);

  // Determinant of Jacobian of deformation derivatives
  return (jac(0, 0)*jac(1, 1)*jac(2, 2) + jac(0, 1)*jac(1, 2)*jac(2, 0) +
          jac(0, 2)*jac(1, 0)*jac(2, 1) - jac(0, 2)*jac(1, 1)*jac(2, 0) -
          jac(0, 0)*jac(1, 2)*jac(2, 1) - jac(0, 1)*jac(1, 0)*jac(2, 2));
}

inline double irtkTransformation::GlobalJacobian(double x, double y, double z, double t)
{
  irtkMatrix jac(3, 3);

  // Calculate Jacobian
  this->GlobalJacobian(jac, x, y, z, t);

  // Determinant of Jacobian of deformation derivatives
  return (jac(0, 0)*jac(1, 1)*jac(2, 2) + jac(0, 1)*jac(1, 2)*jac(2, 0) +
          jac(0, 2)*jac(1, 0)*jac(2, 1) - jac(0, 2)*jac(1, 1)*jac(2, 0) -
          jac(0, 0)*jac(1, 2)*jac(2, 1) - jac(0, 1)*jac(1, 0)*jac(2, 2));
}

inline void irtkTransformation::Import(char *name)
{
  ifstream from(name);

  if (!from) {
    cerr << "irtkTransformation::Import: Can't open file " << name << "\n";
    exit(1);
  }

  this->Import(from);
}

inline void irtkTransformation::Export(char *name)
{
  ofstream to(name);

  if (!to) {
    cerr << "irtkTransformation::Export: Can't open file " << name << "\n";
    exit(1);
  }

  this->Export(to);

  // This seems to be required under Mac OS X
  to.close();
}

inline istream& irtkTransformation::Import(istream &)
{
  cerr << "irtkTransformation::Import: Cannot import transformation" << endl;
  exit(1);
}

inline ostream& irtkTransformation::Export(ostream &)
{
  cerr << "irtkTransformation::Export: Cannot export transformation" << endl;
  exit(1);
}

// Homogeneous transformation classes
#include <irtkHomogeneousTransformation.h>
#include <irtkRigidTransformation.h>
#include <irtkAffineTransformation.h>

#include <irtkFreeFormTransformation.h>
#include <irtkFreeFormTransformation3D.h>
#include <irtkBSplineFreeFormTransformation3D.h>
#include <irtkLinearFreeFormTransformation.h>

#include <irtkMultiLevelFreeFormTransformation.h>

#include <irtkFluidFreeFormTransformation.h>
#include <irtkEigenFreeFormTransformation.h>

#include <irtkFreeFormTransformation4D.h>
#include <irtkBSplineFreeFormTransformation4D.h>

#include <irtkImageTransformation.h>
#include <irtkImageTransformation2.h>
#include <irtkImageHomogeneousTransformation.h>

// For backwards compatibility
typedef class irtkBSplineFreeFormTransformation3D irtkBSplineFreeFormTransformation;

#endif

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