itkFluidVelocityToDeformationFilter.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 itkFluidVelocityToDeformationFilter_h
#define itkFluidVelocityToDeformationFilter_h

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


class FluidVelocityToDeformationFilterUnitTest;

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

  typedef FluidVelocityToDeformationFilter                                                 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(FluidVelocityToDeformationFilter, ImageToImageFilter);

  itkStaticConstMacro(Dimension, unsigned int, NDimensions);

  typedef Vector< TScalarType, itkGetStaticConstMacro(Dimension) >                    OutputPixelType;
  typedef Image< OutputPixelType, itkGetStaticConstMacro(Dimension) >                 OutputImageType;
  typedef typename Superclass::InputImageType                                         InputImageType;
  typedef typename Superclass::InputImagePointer                                      InputImagePointer;
  typedef typename Superclass::InputImageRegionType                                   InputImageRegionType;
  typedef Image<float, Dimension>                                                     InputImageMaskType; 

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

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

  virtual void SetNthInput(unsigned int idx, const InputImageType *);
  
  virtual void SetInputMask(const InputImageMaskType* inputImageMask) { this->m_InputMask = inputImageMask; } 
  
  itkGetMacro(MaxDeformation, double);
  
  itkSetMacro(IsNegativeVelocity, bool); 
  itkGetMacro(IsNegativeVelocity, bool); 
  itkSetMacro(IsTakeDerivative, bool); 

protected:
  FluidVelocityToDeformationFilter();
  virtual ~FluidVelocityToDeformationFilter() {}
  void PrintSelf(std::ostream& os, Indent indent) const;
  
  // Check before we start.
  virtual void BeforeThreadedGenerateData();
  
  // The main method to implement in derived classes, note, its threaded.
  virtual void ThreadedGenerateData( const InputImageRegionType &outputRegionForThread, ThreadIdType threadId);
  
  virtual void AfterThreadedGenerateData(); 
  
  double m_MaxDeformation;
  
  bool m_IsNegativeVelocity; 
  
  const InputImageMaskType* m_InputMask; 
  
  bool m_IsTakeDerivative; 
  
private:
  
  FluidVelocityToDeformationFilter(const Self&); 
  void operator=(const Self&); 

  friend class ::FluidVelocityToDeformationFilterUnitTest;
  
};

} // end namespace

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

#endif