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

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

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

#define _IRTKBSPLINEFREEFORMTRANSFORMATION4D_H

#include <irtkGeometry.h>

class irtkBSplineFreeFormTransformation4D : public irtkFreeFormTransformation4D
{

protected:

  static double B0(double);

  static double B1(double);

  static double B2(double);

  static double B3(double);

  static double B0_I(double);

  static double B1_I(double);

  static double B2_I(double);

  static double B3_I(double);

  static double B0_II(double);

  static double B1_II(double);

  static double B2_II(double);

  static double B3_II(double);

  virtual void Subdivide2D();

  virtual void Subdivide3D();

  static    double LookupTable[FFDLOOKUPTABLESIZE][4];

  /* Memory for lookup table for first derivatives of B-spline basis
   * function values */
  static    double LookupTable_I[FFDLOOKUPTABLESIZE][4];

  /* Memory for lookup table for second derivatives of B-spline basis
   * function values */
  static    double LookupTable_II[FFDLOOKUPTABLESIZE][4];

public:

  static double B (int, double);

  static double B_I(int, double);

  static double B_II(int, double);

  irtkBSplineFreeFormTransformation4D();

  irtkBSplineFreeFormTransformation4D(irtkBaseImage &, double = 1, double = 1, double = 1, double = 1);

  irtkBSplineFreeFormTransformation4D(double x1, double y1, double z1, double t1,
                                      double x2, double y2, double z2, double t2,
                                      double dx, double dy, double dz, double dt,
                                      double* xaxis, double* yaxis, double* zaxis);

  irtkBSplineFreeFormTransformation4D(const class irtkBSplineFreeFormTransformation4D &);

  virtual ~irtkBSplineFreeFormTransformation4D();

  virtual double Approximate(double *, double *, double *, double *,
                             double *, double *, double *, int);

  virtual void Interpolate(double* dxs, double* dys, double* dzs);

  virtual void Subdivide();

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

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

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

  virtual void Transform2(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 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 double Bending(double, double, double, double);

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

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

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

  virtual void Print();

  static int CheckHeader(char *);

  virtual const char *NameOfClass();

  virtual irtkCifstream& Read(irtkCifstream&);

  virtual irtkCofstream& Write(irtkCofstream&);
};

inline double irtkBSplineFreeFormTransformation4D::B(int i, double t)
{
  switch (i) {
  case 0:
    return (1-t)*(1-t)*(1-t)/6.0;
  case 1:
    return (3*t*t*t - 6*t*t + 4)/6.0;
  case 2:
    return (-3*t*t*t + 3*t*t + 3*t + 1)/6.0;
  case 3:
    return (t*t*t)/6.0;
  }
  return 0;
}

inline double irtkBSplineFreeFormTransformation4D::B_I(int i, double t)
{
  switch (i) {
  case 0:
    return -(1-t)*(1-t)/2.0;
  case 1:
    return (9*t*t - 12*t)/6.0;
  case 2:
    return (-9*t*t + 6*t + 3)/6.0;
  case 3:
    return (t*t)/2.0;
  }
  return 0;
}

inline double irtkBSplineFreeFormTransformation4D::B_II(int i, double t)
{
  switch (i) {
  case 0:
    return 1 - t;
  case 1:
    return 3*t - 2;
  case 2:
    return -3*t + 1;
  case 3:
    return t;
  }
  return 0;
}

inline double irtkBSplineFreeFormTransformation4D::B0(double t)
{
  return (1-t)*(1-t)*(1-t)/6.0;
}

inline double irtkBSplineFreeFormTransformation4D::B1(double t)
{
  return (3*t*t*t - 6*t*t + 4)/6.0;
}

inline double irtkBSplineFreeFormTransformation4D::B2(double t)
{
  return (-3*t*t*t + 3*t*t + 3*t + 1)/6.0;
}

inline double irtkBSplineFreeFormTransformation4D::B3(double t)
{
  return (t*t*t)/6.0;
}

inline double irtkBSplineFreeFormTransformation4D::B0_I(double t)
{
  return -(1-t)*(1-t)/2.0;
}

inline double irtkBSplineFreeFormTransformation4D::B1_I(double t)
{
  return (9*t*t - 12*t)/6.0;
}

inline double irtkBSplineFreeFormTransformation4D::B2_I(double t)
{
  return (-9*t*t + 6*t + 3)/6.0;
}

inline double irtkBSplineFreeFormTransformation4D::B3_I(double t)
{
  return (t*t)/2.0;
}

inline double irtkBSplineFreeFormTransformation4D::B0_II(double t)
{
  return 1 - t;
}

inline double irtkBSplineFreeFormTransformation4D::B1_II(double t)
{
  return 3*t - 2;
}

inline double irtkBSplineFreeFormTransformation4D::B2_II(double t)
{
  return -3*t + 1;
}

inline double irtkBSplineFreeFormTransformation4D::B3_II(double t)
{
  return t;
}

inline void irtkBSplineFreeFormTransformation4D::Transform(double &x, double &y, double &z, double t)
{
  double u, v, w;

  u = x;
  v = y;
  w = z;

  // Convert world coordinates in to FFD coordinates
  this->WorldToLattice(u, v, w);

  // Calculate FFD
  this->FFD1(u, v, w, this->TimeToLattice(t));

  // Add FFD to world coordinates
  x += u;
  y += v;
  z += w;
}

inline void irtkBSplineFreeFormTransformation4D::Transform2(double &x, double &y, double &z, double t)
{
  double u, v, w;

  u = x;
  v = y;
  w = z;

  // Convert world coordinates in to FFD coordinates
  this->WorldToLattice(u, v, w);

  // Calculate FFD
  this->FFD2(u, v, w, this->TimeToLattice(t));

  // Add FFD to world coordinates
  x += u;
  y += v;
  z += w;
}

inline void irtkBSplineFreeFormTransformation4D::GlobalTransform(double &x, double &y, double &z, double t)
{}

inline void irtkBSplineFreeFormTransformation4D::LocalTransform(double &x, double &y, double &z, double t)
{
  double u, v, w;

  u = x;
  v = y;
  w = z;

  // calculate displacement
  this->LocalDisplacement(u, v, w, this->TimeToLattice(t));

  // Add displacement
  x += u;
  y += v;
  z += w;
}

inline void irtkBSplineFreeFormTransformation4D::GlobalDisplacement(double &x, double &y, double &z, double t)
{
  x = 0;
  y = 0;
  z = 0;
}

inline void irtkBSplineFreeFormTransformation4D::LocalDisplacement(double &x, double &y, double &z, double t)
{
  // Convert world coordinates in to FFD coordinates
  this->WorldToLattice(x, y, z);

  // Calculate FFD
  this->FFD1(x, y, z, this->TimeToLattice(t));
}

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

#endif

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