itkBSplineDeformableTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBSplineDeformableTransform.h,v $
  Language:  C++
  Date:      $Date: 2010-03-05 15:26:30 $
  Version:   $Revision: 1.42 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

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

#ifndef __itkBSplineDeformableTransform_h
#define __itkBSplineDeformableTransform_h

#include <iostream>
#include "itkTransform.h"
#include "itkImage.h"
#include "itkImageRegion.h"
#include "itkBSplineInterpolationWeightFunction.h"

namespace itk
{

template <
    class TScalarType = double,          // Data type for scalars
    unsigned int NDimensions = 3,        // Number of dimensions
    unsigned int VSplineOrder = 3 >      // Spline order
class ITK_EXPORT BSplineDeformableTransform : 
          public Transform< TScalarType, NDimensions, NDimensions >
{
public:
  typedef BSplineDeformableTransform                         Self;
  typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
  typedef SmartPointer<Self>                                 Pointer;
  typedef SmartPointer<const Self>                           ConstPointer;

  static Pointer New(void);

  virtual ::itk::LightObject::Pointer CreateAnother(void) const;

  itkTypeMacro( BSplineDeformableTransform, Transform );

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);

  itkStaticConstMacro(SplineOrder, unsigned int, VSplineOrder);

  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);

  void SetFixedParameters(const ParametersType & parameters);

  void SetParametersByValue(const ParametersType & parameters);

  void SetIdentity();

  virtual const ParametersType& GetParameters(void) const;

  virtual const ParametersType& GetFixedParameters(void) const;

  typedef typename ParametersType::ValueType                      PixelType;
  typedef Image<PixelType,itkGetStaticConstMacro(SpaceDimension)> ImageType;
  typedef typename ImageType::Pointer                             ImagePointer;

  virtual ImagePointer * GetCoefficientImage()
    { return m_CoefficientImage; }
  virtual const ImagePointer * GetCoefficientImage() const
    { return m_CoefficientImage; }

  virtual void SetCoefficientImage( ImagePointer images[] );  

  typedef ImageRegion<itkGetStaticConstMacro(SpaceDimension)>    RegionType;

  typedef typename RegionType::IndexType    IndexType;
  typedef typename RegionType::SizeType     SizeType;
  typedef typename ImageType::SpacingType   SpacingType;
  typedef typename ImageType::DirectionType DirectionType;
  typedef typename ImageType::PointType     OriginType;

  virtual void SetGridRegion( const RegionType& region );
  itkGetConstMacro( GridRegion, RegionType );

  virtual void SetGridSpacing( const SpacingType& spacing );
  itkGetConstMacro( GridSpacing, SpacingType );

  virtual void SetGridDirection( const DirectionType & spacing );
  itkGetConstMacro( GridDirection, DirectionType );

  virtual void SetGridOrigin( const OriginType& origin );
  itkGetConstMacro( GridOrigin, OriginType );

  typedef Transform<ScalarType,itkGetStaticConstMacro(SpaceDimension),
                    itkGetStaticConstMacro(SpaceDimension)> BulkTransformType;
  typedef typename BulkTransformType::ConstPointer       BulkTransformPointer;

  itkSetConstObjectMacro( BulkTransform, BulkTransformType );
  itkGetConstObjectMacro( BulkTransform, BulkTransformType );

  OutputPointType  TransformPoint(const InputPointType  &point ) const;

  typedef BSplineInterpolationWeightFunction<ScalarType,
                     itkGetStaticConstMacro(SpaceDimension),
                     itkGetStaticConstMacro(SplineOrder)> WeightsFunctionType;
  typedef typename WeightsFunctionType::WeightsType       WeightsType;
  typedef typename WeightsFunctionType::ContinuousIndexType 
                                                          ContinuousIndexType;

  typedef Array<unsigned long> ParameterIndexArrayType;

  virtual void TransformPoint( const InputPointType & inputPoint,
                       OutputPointType & outputPoint,
                       WeightsType & weights,
                       ParameterIndexArrayType & indices, 
                       bool & inside ) const;

  virtual void GetJacobian( const InputPointType & inputPoint,
                       WeightsType & weights,
                       ParameterIndexArrayType & indices
                       ) const;


  unsigned long GetNumberOfWeights() const
    { return m_WeightsFunction->GetNumberOfWeights(); }

  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 const JacobianType& GetJacobian(const InputPointType  &point ) const;

  virtual unsigned int GetNumberOfParameters(void) const;

  unsigned int GetNumberOfParametersPerDimension(void) const;

  itkGetConstReferenceMacro( ValidRegion, RegionType );

  virtual bool IsLinear() const { return false; }

  unsigned int GetNumberOfAffectedWeights() const;

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


  BSplineDeformableTransform();
  virtual ~BSplineDeformableTransform();

  itkSetObjectMacro( WeightsFunction, WeightsFunctionType );
  itkGetObjectMacro( WeightsFunction, WeightsFunctionType );

  void WrapAsImages();

  void TransformPointToContinuousIndex( 
   const InputPointType & point, ContinuousIndexType & index ) const;

private:
  BSplineDeformableTransform(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  BulkTransformPointer  m_BulkTransform;

  RegionType    m_GridRegion;
  SpacingType   m_GridSpacing;
  DirectionType m_GridDirection;
  OriginType    m_GridOrigin;

  DirectionType m_PointToIndex;
  DirectionType m_IndexToPoint;
  
  RegionType    m_ValidRegion;

  unsigned long m_Offset;
  bool          m_SplineOrderOdd;
  SizeType      m_SupportSize;
  IndexType     m_ValidRegionLast;
  IndexType     m_ValidRegionFirst;

  ImagePointer   m_WrappedImage[NDimensions];

  ImagePointer   m_CoefficientImage[NDimensions];

  typedef typename JacobianType::ValueType JacobianPixelType;
  typedef Image<JacobianPixelType,
                itkGetStaticConstMacro(SpaceDimension)> JacobianImageType;

  typename JacobianImageType::Pointer m_JacobianImage[NDimensions];

  mutable IndexType m_LastJacobianIndex;

  const ParametersType *  m_InputParametersPointer;

  ParametersType          m_InternalParametersBuffer;

  typename WeightsFunctionType::Pointer  m_WeightsFunction;

  bool InsideValidRegion( const ContinuousIndexType& index ) const;


}; //class BSplineDeformableTransform


}  // namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_BSplineDeformableTransform(_, EXPORT, x, y) namespace itk { \
  _(3(class EXPORT BSplineDeformableTransform< ITK_TEMPLATE_3 x >)) \
  namespace Templates { typedef BSplineDeformableTransform< ITK_TEMPLATE_3 x > \
                                                   BSplineDeformableTransform##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkBSplineDeformableTransform+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkBSplineDeformableTransform.txx"
#endif

#endif /* __itkBSplineDeformableTransform_h */