itkEulerAffineTransform.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef itkEulerAffineTransform_h
#define itkEulerAffineTransform_h

#include "itkSwitchableAffineTransform.h"
#include <itkMacro.h>


namespace itk
{

template <
  class TScalarType=double,         // Data type for scalars 
  unsigned int NInputDimensions=3,  // Number of dimensions in the input space
  unsigned int NOutputDimensions=3> // Number of dimensions in the output space
class ITK_EXPORT EulerAffineTransform 
  : public SwitchableAffineTransform< TScalarType, NInputDimensions, NOutputDimensions >
{
public:
  typedef EulerAffineTransform <TScalarType,
                     NInputDimensions,
                     NOutputDimensions >             Self;
  typedef SwitchableAffineTransform< TScalarType,
                     NInputDimensions,
                     NOutputDimensions >             Superclass;
  typedef SmartPointer<Self>                         Pointer;
  typedef SmartPointer<const Self>                   ConstPointer;
  typedef typename Superclass::RotationType          RotationType;
  typedef typename Superclass::TranslationType       TranslationType;
  
  itkTypeMacro( EulerAffineTransform, SwitchableAffineTransform );

  itkNewMacro( Self );

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions);
  itkStaticConstMacro(ParametersDimension, unsigned int, 15);

  typedef typename Superclass::ParametersType       ParametersType;

  typedef typename Superclass::JacobianType         JacobianType;

  typedef typename Superclass::ScalarType           ScalarType;

  typedef typename Superclass::InputVectorType      InputVectorType;
  
  typedef typename Superclass::OutputVectorType     OutputVectorType;
  
  typedef typename Superclass::InputCovariantVectorType InputCovariantVectorType;
  
  typedef typename Superclass::OutputCovariantVectorType OutputCovariantVectorType;
  
  typedef typename Superclass::InputVnlVectorType InputVnlVectorType;
  
  typedef typename Superclass::OutputVnlVectorType OutputVnlVectorType;
  
  typedef typename Superclass::InputPointType       InputPointType;
  
  typedef typename Superclass::OutputPointType      OutputPointType;
  
  typedef typename Superclass::MatrixType           MatrixType;

  typedef typename Superclass::InverseMatrixType    InverseMatrixType;

  typedef typename Superclass::InputPointType       CenterType;

  typedef typename Superclass::ScaleType            ScaleType;
                                                      
  typedef typename Superclass::OutputVectorType     SkewMajorType;                     

  typedef typename Superclass::OutputVectorType     SkewMinorType; 

  typedef typename Superclass::FullAffineTransformType    FullAffineTransformType;
  typedef typename Superclass::FullAffineTransformPointer FullAffineTransformPointer;
  
  typedef Vector<TScalarType,NInputDimensions>      COGVectorType;

  virtual const JacobianType GetJacobian(const InputPointType & point ) const;

  virtual void ComputeJacobianWithRespectToParameters(const InputPointType & point,
                                                      JacobianType & jacobian ) const;
  


  virtual void ComputeJacobianWithRespectToPosition(const InputPointType &x, JacobianType &jac) const;

  virtual void ComputeInverseJacobianWithRespectToPosition(const InputPointType &x, JacobianType &jac) const;


  virtual bool GetInv(UCLBaseTransform< TScalarType, NInputDimensions, NOutputDimensions >* inverse) const;
  
  virtual void InverseTransformPoint(const InputPointType & point, InputPointType& out);

  void InvertTransformationMatrix()
  {
    typename Self::Pointer inverse = Self::New(); 
    
    GetInv(inverse); 
    this->m_Matrix = inverse->m_Matrix; 
    this->m_Offset = inverse->m_Offset; 
  }

  void SetParametersFromTransform( const FullAffineTransformType* fullAffine );

  bool SaveFullAffineMatrix(std::string filename);

  bool LoadFullAffineMatrix(std::string filename);

  bool SaveNiftyRegAffineMatrix(std::string filename);
  
  void InitialiseUsingCenterOfMass(const COGVectorType& fixedCOM, const COGVectorType& movingCOM)
  {
    TranslationType translation; 
    
    translation.SetSize(NInputDimensions); 
    for (unsigned int i = 0; i < NInputDimensions; i++)
    {
      translation[i] = movingCOM[i] - fixedCOM[i]; 
    }
    this->SetTranslation(translation); 
  }

protected:

  EulerAffineTransform(unsigned int outputDims,
           unsigned int paramDims);
  EulerAffineTransform();      
  
  virtual ~EulerAffineTransform();

  void ComputeMatrixAndOffset(void);
  
  void ComputeParametersFromMatrixAndOffset(void);

  void ComputeComponentMatrices() const;
  
private:

  EulerAffineTransform(const Self & other); // Purposely not implemented
  const Self & operator=( const Self & ); // Purposely not implemented
  
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_ChangeOrigin;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_Rx;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_Ry;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_Rz;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_Trans;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_Scale;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_Skew;
  mutable Matrix<TScalarType,NInputDimensions+1,NInputDimensions+1> m_UnChangeOrigin;

}; // class EulerAffineTransform

}  // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkEulerAffineTransform.txx"
#endif

#endif /* __itkEulerAffineTransform_h */