itkInterpolateVectorFieldFilter.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 itkInterpolateVectorFieldFilter_h
#define itkInterpolateVectorFieldFilter_h

#include <itkImage.h>
#include <itkVector.h>
#include <itkImageToImageFilter.h>
#include <itkVectorInterpolateImageFunction.h>


namespace itk {
template <
    class TScalarType,                   // Data type for scalars
    unsigned int NDimensions = 3>        // Number of Dimensions i.e. 2D or 3D
class ITK_EXPORT InterpolateVectorFieldFilter :
  public ImageToImageFilter< Image< Vector<TScalarType, NDimensions>,  NDimensions>, // Input image
                             Image< Vector<TScalarType, NDimensions>,  NDimensions>  // Output image
                           >
{
public:

  typedef InterpolateVectorFieldFilter                                                  Self;
  typedef ImageToImageFilter< Image< Vector<TScalarType, NDimensions>,  NDimensions>,
                              Image< Vector<TScalarType, NDimensions>,  NDimensions>
                            >                                                           Superclass;
  typedef SmartPointer<Self>                                                            Pointer;
  typedef SmartPointer<const Self>                                                      ConstPointer;
  
  itkNewMacro(Self);

  itkTypeMacro(InterpolateVectorFieldFilter, ImageToImageFilter);

  itkStaticConstMacro(Dimension, unsigned int, NDimensions);

  typedef Vector<TScalarType, NDimensions>                                            OutputPixelType;
  typedef typename OutputPixelType::ValueType                                         OutputPixelComponentType;
  typedef Image< OutputPixelType, NDimensions >                                       OutputImageType;
  typedef typename OutputImageType::Pointer                                           OutputImagePointer;
  typedef typename OutputImageType::ConstPointer                                      OutputImageConstPointer;
  typedef typename OutputImageType::RegionType                                        OutputImageRegionType;
  typedef typename OutputImageType::SpacingType                                       OutputImageSpacingType;
  typedef typename OutputImageType::PointType                                         OutputImageOriginType;
  typedef typename OutputImageRegionType::SizeType                                    OutputImageSizeType;
  typedef typename OutputImageRegionType::IndexType                                   OutputImageIndexType;
  typedef typename Superclass::InputImageType                                         InputImageType;
  typedef typename InputImageType::Pointer                                            InputImagePointer;
  typedef typename InputImageType::ConstPointer                                       InputImageConstPointer;
  typedef typename InputImageType::RegionType                                         InputImageRegionType;
  typedef VectorInterpolateImageFunction<
                                         Image< 
                                               Vector<TScalarType, NDimensions>,  
                                               NDimensions
                                              >, 
                                         TScalarType>                                 InterpolatorType;
  typedef typename InterpolatorType::Pointer                                          InterpolatorPointer;
  typedef typename InterpolatorType::PointType                                        PointType;
  
  virtual void SetInterpolatedField(const InputImageType *image) { this->SetNthInput(0, image); }

  virtual void SetInterpolatingField(const InputImageType *image) { this->SetNthInput(1, image); }

  virtual void SetNthInput(unsigned int idx, const InputImageType *);

  itkSetObjectMacro( Interpolator, InterpolatorType );

  itkGetConstObjectMacro( Interpolator, InterpolatorType );

  itkSetMacro(DefaultPixelValue, OutputPixelType);

  itkGetMacro(DefaultPixelValue, OutputPixelType);

  unsigned long GetMTime( void ) const;

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

  virtual void BeforeThreadedGenerateData();

  virtual void AfterThreadedGenerateData();

  virtual void GenerateInputRequestedRegion();

  virtual void GenerateOutputInformation();

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

  virtual void VerifyInputInformation();

private:
  
  InterpolateVectorFieldFilter(const Self&); 
  void operator=(const Self&); 

  InterpolatorPointer m_Interpolator;
  
  OutputPixelType m_DefaultPixelValue;
  
};

} // end namespace

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

#endif