itkPCADeformationModelTransform.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 itkPCADeformationModelTransform_h
#define itkPCADeformationModelTransform_h

#include <iostream>
#include <itkImage.h>
#include <itkTransform.h>
#include <itkExceptionObject.h>
#include <itkMatrix.h>

#include <itkVectorLinearInterpolateNearestNeighborExtrapolateImageFunction.h>

namespace itk
{

template <
  class TScalarType=float, // Type for coordinate representation type (float or double)
  unsigned int NDimensions = 3 >  // Number of dimensions
class ITK_EXPORT PCADeformationModelTransform : public Transform< TScalarType, NDimensions, NDimensions>
{
public:
  typedef PCADeformationModelTransform Self;
  typedef Transform< TScalarType, NDimensions, NDimensions >  Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  
  typedef itk::Vector< TScalarType, NDimensions >    VectorPixelType; 
  typedef itk::Image< VectorPixelType, NDimensions > FieldType;
  typedef typename FieldType::PixelType              DisplacementType;

  typedef typename FieldType::Pointer           FieldPointer;
  typedef typename FieldType::ConstPointer      FieldConstPointer;
  typedef ImageRegionIterator<FieldType>        FieldIterator;
  typedef ImageRegionConstIterator<FieldType>   FieldConstIterator;

  typedef std::vector<FieldConstPointer>        FieldConstPointerArray;

  typedef std::vector<FieldPointer>        FieldPointerArray;
  typedef std::vector<FieldConstIterator>  FieldIteratorArray;

  typedef itk::ContinuousIndex<TScalarType,NDimensions> ContinuousIndexType;

  typedef typename FieldType::IndexType    FieldIndexType;
  typedef typename FieldType::RegionType   FieldRegionType;
  typedef typename FieldType::SizeType     FieldSizeType;

  typedef VectorLinearInterpolateNearestNeighborExtrapolateImageFunction<FieldType, TScalarType> FieldInterpolatorType;
  typedef typename FieldInterpolatorType::Pointer         FieldInterpolatorPointer;
  typedef std::vector<FieldInterpolatorPointer>           FieldInterpolatorPointerArray;


  itkNewMacro( Self );

  itkTypeMacro( PCADeformationModelTransform, Transform );

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NDimensions);

  virtual void SetNumberOfComponents(unsigned int numberOfParameters);

  void SetFieldArray(unsigned int i, FieldType *field)
  {
    if (this->m_FieldArray[i] != field) {
      this->m_FieldArray[i] = field;
      this->Modified();
    }
  }
  FieldType *GetFieldArray(unsigned int i)
  {
    niftkitkDebugMacro(<<"Returning FieldArray address " << this->m_FieldArray[i] );
    return this->m_FieldArray[i].GetPointer();        
  }

  virtual FieldPointer GetSingleDeformationField();

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);

  typedef typename Superclass::ScalarType  ScalarType;

  typedef typename Superclass::ParametersType  ParametersType;

  typedef typename Superclass::JacobianType  JacobianType;

  typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVectorType;
  typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVectorType;
  
  typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputCovariantVectorType;
  typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputCovariantVectorType;
  
  typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
  
  typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputPointType;
  typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
  
  void SetParameters(const ParametersType & parameters);

  const ParametersType & GetParameters( void ) const;

  virtual void SetFixedParameters( const ParametersType & );

  const ParametersType& GetFixedParameters(void) const;

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

  virtual OutputPointType TransformPoint(const InputPointType  &point ) const;
    

  void SetIdentity( void )
  {
    this->m_Parameters.Fill( 0.0 );
    m_meanCoefficient = 0.0;
  }

  virtual bool IsLinear() const { return false; }

  virtual void Initialize() throw ( ExceptionObject );

protected:
  PCADeformationModelTransform();

  virtual ~PCADeformationModelTransform();

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


  TScalarType      m_meanCoefficient;      // coefficient of mean, 0 if id, 1 otherwise
  unsigned int     m_NumberOfFields;       // number of PCA fields (mean, eigen-fields)

  FieldPointerArray  m_FieldArray;
  FieldPointer       m_SingleField;        // combined field, prepared when requested

  FieldInterpolatorPointerArray          m_Interpolators;


private:
  PCADeformationModelTransform(const Self & other); //purposely not implemented
  const Self & operator=( const Self & ); //purposely not implemented

}; //class PCADeformationModelTransform

}  // namespace itk


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

#endif /* __itkPCADeformationModelTransform_h */