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

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

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

#define _IRTKFREEFORMTRANSFORMATION4D_H

#include <irtkGeometry.h>

#define FFDLOOKUPTABLESIZE 1000

class irtkFreeFormTransformation4D : public irtkFreeFormTransformation
{

protected:

  int _x;

  int _y;

  int _z;

  int _t;

  double _dx;

  double _dy;

  double _dz;

  double _dt;

  double _tMin;

  double _tMax;

  double _xaxis[3];

  double _yaxis[3];

  double _zaxis[3];

  irtkPoint _origin;

  irtkMatrix _matL2W;

  irtkMatrix _matW2L;

  double ****_xdata;

  double ****_ydata;

  double ****_zdata;

  static double ****Allocate  (double ****, int, int, int, int);

  static double ****Deallocate(double ****, int, int, int, int);

  virtual void UpdateMatrix();

public:

  virtual void Subdivide() = 0;

  virtual int GetX() const;

  virtual int GetY() const;

  virtual int GetZ() const;

  virtual int GetT() const;

  virtual int NumberOfDOFs() const;

  virtual void GetSpacing(double &, double &, double &, double &) const;

  virtual void  PutOrientation(double *, double *, double *);

  virtual void  GetOrientation(double *, double *, double *) const;

  virtual void   Put(int, double);

  virtual void   Put(int, int, int, int, double, double, double);

  virtual double Get(int) const;

  virtual void   Get(int, int, int, int, double &, double &, double &) const;

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

  virtual void   PutStatus(int, int, int, int, _Status);

  virtual void   PutStatus(int, int, int, int, _Status, _Status, _Status);

  virtual void   PutStatus(int, _Status);

  virtual void   GetStatus(int, int, int, int, _Status &, _Status &, _Status &);

  virtual _Status GetStatus(int);

  virtual void WorldToLattice(double &, double &, double &) const;

  virtual void WorldToLattice(irtkPoint &) const;

  virtual double TimeToLattice(double) const;

  virtual void LatticeToWorld(double &, double &, double &) const;

  virtual void LatticeToWorld(irtkPoint &) const;

  virtual double LatticeToTime(double) const;

  virtual void IndexToLattice(int index, int& i, int& j, int& k, int& l) const;

  virtual int  LatticeToIndex(int i, int j, int k, int l) const;

  virtual void  ControlPointLocation(int, double &, double &, double &) const;

  virtual irtkPoint ControlPointLocation(int) const;

  virtual void BoundingBox(irtkPoint &, irtkPoint &) const;

  virtual void BoundingBox(double &, double &, double &,
                           double &, double &, double &) const;

  virtual void BoundingBox(int, double &, double &, double &, double &,
                           double &, double &, double &, double &, double = 1) const = 0;

  virtual void BoundingBox(irtkGreyImage *, int, int &, int &, int &, int &,
                           int &, int &, int &, int &, double = 1) const = 0;

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

  virtual Bool IsIdentity();

  virtual const char *NameOfClass();

};

inline int irtkFreeFormTransformation4D::GetX() const
{
  return _x;
}

inline int irtkFreeFormTransformation4D::GetY() const
{
  return _y;
}

inline int irtkFreeFormTransformation4D::GetZ() const
{
  return _z;
}

inline int irtkFreeFormTransformation4D::GetT() const
{
  return _t;
}

inline int irtkFreeFormTransformation4D::NumberOfDOFs() const
{
  return 3*_x*_y*_z*_t;
}

inline double irtkFreeFormTransformation4D::Get(int index) const
{
  int i, j, k, l;

  if (index >= 3*_x*_y*_z*_t) {
    cerr << "irtkFreeFormTransformation4D::Get: No such dof" << endl;
    exit(1);
  }

  if (index < _x*_y*_z*_t) {
    l = index/(_z*_y*_x);
    k = index%(_z*_y*_x)/(_y*_x);
    j = index%(_z*_y*_x)%(_y*_x)/_x;
    i = index%(_z*_y*_x)%(_y*_x)%_x;
    cout << "x = " << i << " " << j << " " << k << " " << l << endl;

    return _xdata[l][k][j][i];
  } else if (index < 2*_x*_y*_z*_t) {
    index -= _x*_y*_z*_t;

    l = index/(_z*_y*_x);
    k = index%(_z*_y*_x)/(_y*_x);
    j = index%(_z*_y*_x)%(_y*_x)/_x;
    i = index%(_z*_y*_x)%(_y*_x)%_x;
    cout << "y  = " << i << " " << j << " " << k << " " << l << endl;

    return _ydata[l][k][j][i];
  } else {
    index -= 2*_x*_y*_z*_t;

    l = index/(_z*_y*_x);
    k = index%(_z*_y*_x)/(_y*_x);
    j = index%(_z*_y*_x)%(_y*_x)/_x;
    i = index%(_z*_y*_x)%(_y*_x)%_x;
    cout << "z = " << i << " " << j << " " << k << " " << l << endl;

    return _zdata[l][k][j][i];
  }
}

inline void irtkFreeFormTransformation4D::Get(int i, int j, int k, int l, double &x, double &y, double &z) const
{
  if ((i < 0) || (i >= _x) || (j < 0) || (j >= _y) || (k < 0) || (k >= _z) || (l < 0) || (l >= _t)) {
    cerr << "irtkFreeFormTransformation4D::Get: No such dof" << endl;
    exit(1);
  }
  x = _xdata[l][k][j][i];
  y = _ydata[l][k][j][i];
  z = _zdata[l][k][j][i];
}

inline void irtkFreeFormTransformation4D::Put(int index, double x)
{
  int i, j, k, l;

  if (index >= 3*_x*_y*_z*_t) {
    cerr << "irtkFreeFormTransformation4D::Put: No such dof" << endl;
    exit(1);
  }

  if (index < _x*_y*_z*_t) {
    l = index/(_z*_y*_x);
    k = index%(_z*_y*_x)/(_y*_x);
    j = index%(_z*_y*_x)%(_y*_x)/_x;
    i = index%(_z*_y*_x)%(_y*_x)%_x;

    _xdata[l][k][j][i] = x;
  } else if (index < 2*_x*_y*_z*_t) {
    index -= _x*_y*_z*_t;

    l = index/(_z*_y*_x);
    k = index%(_z*_y*_x)/(_y*_x);
    j = index%(_z*_y*_x)%(_y*_x)/_x;
    i = index%(_z*_y*_x)%(_y*_x)%_x;

    _ydata[l][k][j][i] = x;
  } else {
    index -= 2*_x*_y*_z*_t;

    l = index/(_z*_y*_x) ;
    k = index%(_z*_y*_x)/(_y*_x) ;
    j = index%(_z*_y*_x)%(_y*_x)/_x;
    i = index%(_z*_y*_x)%(_y*_x)%_x;

    _zdata[l][k][j][i] = x;
  }
}

inline void irtkFreeFormTransformation4D::Put(int i, int j, int k, int l, double x, double y, double z)
{
  if ((i < 0) || (i >= _x) || (j < 0) || (j >= _y) || (k < 0) || (k >= _z) || (l < 0) || (l >= _t)) {
    cerr << "irtkFreeFormTransformation4D::Put: No such dof" << endl;
    exit(1);
  }
  _xdata[l][k][j][i] = x;
  _ydata[l][k][j][i] = y;
  _zdata[l][k][j][i] = z;
}

inline void irtkFreeFormTransformation4D::GetSpacing(double &dx, double &dy, double &dz, double &dt) const
{
  dx = _dx;
  dy = _dy;
  dz = _dz;
  dt = _dt;
}

inline void irtkFreeFormTransformation4D::PutOrientation(double *xaxis, double *yaxis, double *zaxis)
{
  _xaxis[0] = xaxis[0];
  _xaxis[1] = xaxis[1];
  _xaxis[2] = xaxis[2];
  _yaxis[0] = yaxis[0];
  _yaxis[1] = yaxis[1];
  _yaxis[2] = yaxis[2];
  _zaxis[0] = zaxis[0];
  _zaxis[1] = zaxis[1];
  _zaxis[2] = zaxis[2];

  this->UpdateMatrix();
}

inline void irtkFreeFormTransformation4D::GetOrientation(double *xaxis, double *yaxis, double *zaxis) const
{
  xaxis[0] = _xaxis[0];
  xaxis[1] = _xaxis[1];
  xaxis[2] = _xaxis[2];
  yaxis[0] = _yaxis[0];
  yaxis[1] = _yaxis[1];
  yaxis[2] = _yaxis[2];
  zaxis[0] = _zaxis[0];
  zaxis[1] = _zaxis[1];
  zaxis[2] = _zaxis[2];
}

inline void irtkFreeFormTransformation4D::WorldToLattice(double &x, double &y, double &z) const
{
  double a, b, c;

  // Pre-multiply point with transformation matrix
  a = _matW2L(0, 0)*x+_matW2L(0, 1)*y+_matW2L(0, 2)*z+_matW2L(0, 3);
  b = _matW2L(1, 0)*x+_matW2L(1, 1)*y+_matW2L(1, 2)*z+_matW2L(1, 3);
  c = _matW2L(2, 0)*x+_matW2L(2, 1)*y+_matW2L(2, 2)*z+_matW2L(2, 3);

  // Copy result back
  x = a;
  y = b;
  z = c;
}

inline void irtkFreeFormTransformation4D::WorldToLattice(irtkPoint &p) const
{
  this->WorldToLattice(p._x, p._y, p._z);
}

inline double irtkFreeFormTransformation4D::TimeToLattice(double t) const
{
  return (t - _tMin)*(_t - 1)/(_tMax - _tMin);
}

inline void irtkFreeFormTransformation4D::LatticeToWorld(double &x, double &y, double &z) const
{
  double a, b, c;

  // Pre-multiply point with transformation matrix
  a = _matL2W(0, 0)*x+_matL2W(0, 1)*y+_matL2W(0, 2)*z+_matL2W(0, 3);
  b = _matL2W(1, 0)*x+_matL2W(1, 1)*y+_matL2W(1, 2)*z+_matL2W(1, 3);
  c = _matL2W(2, 0)*x+_matL2W(2, 1)*y+_matL2W(2, 2)*z+_matL2W(2, 3);

  // Copy result back
  x = a;
  y = b;
  z = c;
}

inline void irtkFreeFormTransformation4D::LatticeToWorld(irtkPoint &p) const
{
  this->LatticeToWorld(p._x, p._y, p._z);
}

inline double irtkFreeFormTransformation4D::LatticeToTime(double t) const
{
  return t*(_tMax - _tMin)/double(_t - 1)+_tMin;
}

inline void irtkFreeFormTransformation4D::IndexToLattice(int index, int& i, int& j, int& k, int& l) const
{
  if (index > _x*_y*_z*_t) {
    index -= _x*_y*_z*_t;
    if (index > _x*_y*_z*_t)
      index -= _x*_y*_z*_t;
  }

  l = index/(_z*_y*_x);
  k = index%(_z*_y*_x)/(_y*_x);
  j = index%(_z*_y*_x)%(_y*_x)/_x;
  i = index%(_z*_y*_x)%(_y*_x)%_x;
}

inline int irtkFreeFormTransformation4D::LatticeToIndex(int i, int j, int k, int l) const
{
  return l*_z*_y*_x + k*_y*_x + j*_x + i;
}

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

#endif

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