itkLinearlyInterpolatedDerivativeFilter.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 itkLinearlyInterpolatedDerivativeFilter_h
#define itkLinearlyInterpolatedDerivativeFilter_h
#include <itkImage.h>
#include <itkVector.h>
#include <itkImageToImageFilter.h>

namespace itk {
template< class TFixedImage, class TMovingImage, class TScalarType, class TDeformationScalar>
class ITK_EXPORT LinearlyInterpolatedDerivativeFilter :
  public ImageToImageFilter<TFixedImage, 
                            Image<  
                              Vector< TDeformationScalar, TFixedImage::ImageDimension>, 
                              TFixedImage::ImageDimension> >
{
public:

  typedef LinearlyInterpolatedDerivativeFilter                                          Self;
  typedef ImageToImageFilter<TFixedImage, 
                             Image<  
                               Vector< TDeformationScalar, TFixedImage::ImageDimension>, 
                               TFixedImage::ImageDimension> > Superclass;
  typedef SmartPointer<Self>                                                            Pointer;
  typedef SmartPointer<const Self>                                                      ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(LinearlyInterpolatedDerivativeFilter, ImageToImageFilter);

  itkStaticConstMacro(Dimension, unsigned int, TFixedImage::ImageDimension);

  typedef TDeformationScalar                                                          OutputDataType;
  typedef Vector< OutputDataType, itkGetStaticConstMacro(Dimension) >                 OutputPixelType;
  typedef Image< OutputPixelType, itkGetStaticConstMacro(Dimension) >                 OutputImageType;
  typedef typename OutputImageType::Pointer                                           OutputImagePointer;
  typedef typename OutputImageType::RegionType                                        OutputImageRegionType; 
  typedef typename OutputImageType::IndexType                                         OutputImageIndexType;
  typedef typename OutputImageType::SizeType                                          OutputImageSizeType;
  typedef typename OutputImageType::SpacingType                                       OutputImageSpacingType;
  typedef typename OutputImageType::PointType                                         OutputImageOriginType;
  typedef typename OutputImageType::DirectionType                                     OutputImageDirectionType;
  typedef TFixedImage                                                                 FixedImageType;
  typedef typename FixedImageType::Pointer                                            FixedImagePointer;
  typedef typename FixedImageType::PixelType                                          FixedImagePixelType;
  typedef typename FixedImageType::RegionType                                         FixedImageRegionType; 
  typedef typename FixedImageType::IndexType                                          FixedImageIndexType;
  typedef typename FixedImageType::SizeType                                           FixedImageSizeType;
  typedef typename FixedImageType::SpacingType                                        FixedImageSpacingType;
  typedef typename FixedImageType::PointType                                          FixedImageOriginType;
  typedef typename FixedImageType::DirectionType                                      FixedImageDirectionType;
  typedef TMovingImage                                                                MovingImageType;
  typedef typename MovingImageType::SizeType                                          MovingImageSizeType;
  typedef typename MovingImageType::Pointer                                           MovingImagePointer;
  typedef typename MovingImageType::PixelType                                         MovingImagePixelType;
  typedef typename MovingImageType::RegionType                                        MovingImageRegionType;
  typedef typename MovingImageType::IndexType                                         MovingImageIndexType;
  
  typedef Transform<TScalarType, itkGetStaticConstMacro(Dimension), 
                                 itkGetStaticConstMacro(Dimension)>                   TransformType;
  typedef typename TransformType::ConstPointer                                        TransformPointerType;

  typedef Size<itkGetStaticConstMacro(Dimension)> SizeType;

  typedef typename OutputImageType::IndexType IndexType;

  typedef typename MovingImageType::PointType MovingImagePointType;
  
  virtual void SetFixedImage(const FixedImageType *image);

  virtual void SetMovingImage(const MovingImageType *image);

  itkSetMacro( DefaultPixelValue, OutputPixelType );

  itkGetConstReferenceMacro( DefaultPixelValue, OutputPixelType );

  void WriteDerivativeImage(std::string filename);
  
  itkSetObjectMacro( Transform, TransformType );

  itkGetConstObjectMacro( Transform, TransformType );
  
  itkSetMacro(MovingImageLowerPixelValue, MovingImagePixelType);
  itkGetMacro(MovingImageLowerPixelValue, MovingImagePixelType);

  itkSetMacro(MovingImageUpperPixelValue, MovingImagePixelType);
  itkGetMacro(MovingImageUpperPixelValue, MovingImagePixelType);

protected:
  LinearlyInterpolatedDerivativeFilter();
  ~LinearlyInterpolatedDerivativeFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void GenerateOutputInformation( void );

  virtual void GenerateInputRequestedRegion( void );

  virtual void BeforeThreadedGenerateData();

  void ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, ThreadIdType threadId );

  virtual void AfterThreadedGenerateData();

  unsigned long GetMTime( void ) const;

private:
  
  LinearlyInterpolatedDerivativeFilter(const Self&); 
  void operator=(const Self&); 
  
  TransformPointerType m_Transform;
  
  OutputPixelType m_DefaultPixelValue;
  
  MovingImagePixelType m_MovingImageLowerPixelValue;
  
  MovingImagePixelType m_MovingImageUpperPixelValue;
  
}; /* End class */

} /* End namespace */

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

#endif