itkDeformableTransform.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 itkDeformableTransform_h
#define itkDeformableTransform_h

#include <itkTransform.h>
#include <itkImage.h>
#include <itkVector.h>
#include <itkImageRegionIterator.h>
#include <itkDisplacementFieldJacobianDeterminantFilter.h>
#include "itkForwardDifferenceDisplacementFieldJacobianDeterminantFilter.h"

namespace itk
{
  
template <
    class TFixedImage,                   // Templated over the image type.
    class TScalarType,                   // Data type for scalars
    unsigned int NDimensions,            // Number of Dimensions i.e. 2D or 3D
    class TDeformationScalar>            // Data type in the deformation field.       
class ITK_EXPORT DeformableTransform : public Transform< TScalarType, NDimensions, NDimensions >
{
public:
  
  typedef DeformableTransform                                Self;
  typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
  typedef SmartPointer<Self>                                 Pointer;
  typedef SmartPointer<const Self>                           ConstPointer;
  
  itkTypeMacro( DeformableTransform, Transform );

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
  
  typedef typename Superclass::ScalarType                     ScalarType;
  
  typedef typename Superclass::NumberOfParametersType         NumberOfParametersType;
  typedef typename Superclass::ParametersType                 ParametersType;
  typedef typename Superclass::ParametersValueType            ParametersValueType;
  typedef Array<ParametersValueType>                          DerivativeType;
  
  typedef typename Superclass::OutputPointType                OutputPointType;
  typedef typename Superclass::InputPointType                 InputPointType;

  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 Vector< TDeformationScalar, NDimensions >           VectorFieldPixelType;
  typedef Image< VectorFieldPixelType, NDimensions >          VectorFieldImageType;
  typedef typename VectorFieldImageType::Pointer              VectorFieldImagePointer;
  typedef typename VectorFieldImageType::SizeType             VectorFieldSizeType;
  typedef ImageRegionIterator<VectorFieldImageType>           VectorFieldIteratorType;
  typedef ImageRegionConstIterator<VectorFieldImageType>      VectorFieldConstIteratorType;
  typedef VectorFieldPixelType                                DeformationFieldPixelType;
  typedef VectorFieldImageType                                DeformationFieldType;
  typedef typename DeformationFieldType::Pointer              DeformationFieldPointer;
  typedef ImageRegion<NDimensions>                            DeformationFieldRegionType;
  typedef typename DeformationFieldRegionType::IndexType      DeformationFieldIndexType;
  typedef typename DeformationFieldRegionType::SizeType       DeformationFieldSizeType;
  typedef typename DeformationFieldType::SpacingType          DeformationFieldSpacingType;
  typedef typename DeformationFieldType::DirectionType        DeformationFieldDirectionType;
  typedef typename DeformationFieldType::PointType            DeformationFieldOriginType;
  typedef Image<TDeformationScalar, NDimensions>              DeformationFieldComponentImageType; 
  
  typedef TFixedImage                                         FixedImageType;
  typedef typename FixedImageType::ConstPointer               FixedImagePointer;

  typedef Transform<TScalarType,
                    itkGetStaticConstMacro(SpaceDimension),
                    itkGetStaticConstMacro(SpaceDimension)>   GlobalTransformType;
  typedef typename GlobalTransformType::ConstPointer          GlobalTransformPointer;

  typedef DisplacementFieldJacobianDeterminantFilter< 
                    DeformationFieldType, 
                    TScalarType >                             JacobianDeterminantFilterType;
  typedef typename JacobianDeterminantFilterType::Pointer     JacobianDeterminantFilterPointer;
  
  typedef typename Superclass::JacobianType                   JacobianType;

  itkSetConstObjectMacro( GlobalTransform, GlobalTransformType );
  itkGetConstObjectMacro( GlobalTransform, GlobalTransformType );
  
  itkSetMacro(InverseSearchRadius, double); 
  itkGetMacro(InverseSearchRadius, double); 

  virtual const ParametersType& GetParameters(void) const { return this->m_Parameters; }

  virtual void SetParameters(const ParametersType& parameters) { this->m_Parameters = parameters; }

  virtual NumberOfParametersType GetNumberOfParameters(void) const { return this->m_Parameters.Size(); }

  virtual void SetParametersFromField(const VectorFieldImagePointer& image, bool force=false);
  
  virtual DeformationFieldType* GetDeformationField() const { return this->m_DeformationField.GetPointer(); }

  TScalarType ComputeMaxDeformation();
  
  TScalarType ComputeMinDeformation();
  
  TScalarType ComputeMaxJacobian();
  
  TScalarType ComputeMinJacobian();
  
  TScalarType GetSumLogJacobianDeterminant();
  
  virtual void WriteTransform(std::string filename) { this->WriteVectorImage(filename); }
  
  virtual void WriteParameters(std::string filename) { this->WriteVectorImage(filename); }
  
  void WriteJacobianImage(std::string filename);
  
  void WriteMidasStrImage(std::string filename,  int origin[NDimensions], typename TFixedImage::RegionType paddedDesiredRegion, const typename JacobianDeterminantFilterType::OutputImageType* jacobianImage);
  
  void ReadMidasStrImage(std::string filename,  int origin[NDimensions], typename TFixedImage::RegionType paddedDesiredRegion, typename JacobianDeterminantFilterType::OutputImageType* jacobianImage);
  
  void WriteMidasVecImage(std::string filename,  int origin[NDimensions], typename TFixedImage::RegionType paddedDesiredRegion);

  void WriteVectorImage(std::string filename);

  virtual void SetIdentity();

  void Initialize(FixedImagePointer image);
  
  virtual OutputPointType  TransformPoint(const InputPointType  &point ) const;

  virtual OutputVectorType TransformVector(const InputVectorType &) const
    { 
      itkExceptionMacro( << "Method not applicable for deformable transform." );
      return OutputVectorType(); 
    }

  virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const
    { 
      itkExceptionMacro(<< "Method not applicable for deformable transform. ");
      return OutputVnlVectorType(); 
    }

  virtual OutputCovariantVectorType TransformCovariantVector(const InputCovariantVectorType &) const
    { 
      itkExceptionMacro(<< "Method not applicable for deformable transfrom. ");
      return OutputCovariantVectorType(); 
    } 

  virtual bool IsLinear() const { return false; }

  virtual bool IsIdentity();
  
  virtual const ParametersType& GetFixedParameters(void) const;
  
  virtual void SetFixedParameters(const ParametersType& parameters);
  
  bool GetInverse(Self* inverse) const; 
  void ConcatenateAfterGivenTransform(Self* givenTransform); 
  virtual bool IsRegridable() const { return false; }
  virtual void UpdateRegriddedDeformationParameters(ParametersType& regriddedParameters, const ParametersType& currentPosition)
  { 
    itkExceptionMacro( << "Method Regrid not implemented for deformable transform." );
  }
  void SetUseForwardDifferenceJacobianCalculation()
  {
    typedef ForwardDifferenceDisplacementFieldJacobianDeterminantFilter<DeformationFieldType, TScalarType, typename JacobianDeterminantFilterType::OutputImageType> FilterType; 
    this->m_JacobianFilter = FilterType::New(); 
    this->m_JacobianFilter->SetInput(this->m_DeformationField);
    this->m_JacobianFilter->SetUseImageSpacingOff();
  }
  void InitialiseGlobalTransformation();
  
  typename JacobianDeterminantFilterType::OutputImageType* GetJacobianImage() const { return m_JacobianFilter->GetOutput(); }
  
  void ExtractComponents(); 
  
  void InvertUsingIterativeFixedPoint(typename Self::Pointer invertedTransform, int maxIterations, int maxOuterIterations, double tol); 
  
  virtual void ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType &) const
  {
    // TODO
    itkExceptionMacro( << "Not Implemented" );
  }

protected:
  
  DeformableTransform();
  virtual ~DeformableTransform();

  void PrintSelf(std::ostream &os, Indent indent) const;

  unsigned long int GetNumberOfParametersImpliedByImage(const VectorFieldImagePointer image);

  void ResizeParametersArray(const VectorFieldImagePointer image);
  
  void MarshallParametersToImage(VectorFieldImagePointer image);
  
  void MarshallImageToParameters(const VectorFieldImagePointer image, ParametersType& parameters);
  
  virtual typename JacobianDeterminantFilterType::OutputImageRegionType GetValidJacobianRegion() const { return this->m_JacobianFilter->GetOutput()->GetLargestPossibleRegion(); } 
  
  typename DeformationFieldType::Pointer m_DeformationField;

  GlobalTransformPointer  m_GlobalTransform;

  JacobianDeterminantFilterPointer m_JacobianFilter;
  
  double m_InverseSearchRadius; 
  
  double m_InverseVoxelTolerance; 
  
  double m_InverseIterationTolerance; 
  
  double m_MaxNumberOfInverseIterations; 
  
  typename DeformationFieldComponentImageType::Pointer m_DeformationFieldComponent[NDimensions]; 
  
private:
  
  DeformableTransform(const Self&); // purposefully not implemented
  void operator=(const Self&);      // purposefully not implemented
  
  mutable DeformationFieldIndexType m_TemporaryIndex;

  void ForceJacobianUpdate();
  
};  

} // namespace itk.

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

#endif /*ITKDEFORMABLETRANSFORM_H_*/