itkScalarImageToNormalizedGradientVectorImageFilter.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 itkScalarImageToNormalizedGradientVectorImageFilter_h
#define itkScalarImageToNormalizedGradientVectorImageFilter_h

#include <itkImageToImageFilter.h>
#include <itkVector.h>
#include <itkImage.h>
#include <itkGradientImageFilter.h>
#include <itkGradientRecursiveGaussianImageFilter.h>
#include <itkCovariantVector.h>
#include "itkNormaliseVectorFilter.h"
#include <itkGaussianSmoothVectorFieldFilter.h>

namespace itk {

template< class TInputImage, typename TScalarType >
class ITK_EXPORT ScalarImageToNormalizedGradientVectorImageFilter :
  public ImageToImageFilter<TInputImage, 
                            Image< Vector< TScalarType, 
                                           TInputImage::ImageDimension >, 
                                   TInputImage::ImageDimension > >
{
public:

  typedef TScalarType                                                                   VectorDataType;
  typedef ScalarImageToNormalizedGradientVectorImageFilter                              Self;
  typedef ImageToImageFilter<TInputImage, 
                             Image< Vector< VectorDataType, 
                                             TInputImage::ImageDimension >, 
                                    TInputImage::ImageDimension > > Superclass;
  typedef SmartPointer<Self>                                                            Pointer;
  typedef SmartPointer<const Self>                                                      ConstPointer;
  
  typedef enum {CENTRAL_DIFFERENCES, DERIVATIVE_OPERATOR, DERIVATIVE_OF_GAUSSIAN} DerivativeType;
  
  itkNewMacro(Self);
  
  itkTypeMacro(ScalarImageToNormalizedGradientVectorImageFilter, ImageToImageFilter);

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

  typedef Vector< VectorDataType, itkGetStaticConstMacro(Dimension) >                 OutputPixelType;
  typedef CovariantVector< VectorDataType, itkGetStaticConstMacro(Dimension) >        CovariantVectorType;
  typedef Image< OutputPixelType, itkGetStaticConstMacro(Dimension) >                 OutputImageType;
  typedef Image< CovariantVectorType, itkGetStaticConstMacro(Dimension) >             CovariantVectorImageType;
  typedef typename CovariantVectorImageType::Pointer                                  CovariantVectorImagePointer;
  typedef typename Superclass::InputImageType                                         InputImageType;
  typedef typename InputImageType::PixelType                                          InputPixelType;
  typedef typename InputImageType::RegionType                                         InputRegionType;
  typedef GradientImageFilter<TInputImage, VectorDataType, VectorDataType>            GradientImageFilterType;
  typedef typename GradientImageFilterType::Pointer                                   GradientImageFilterPointer;
  typedef GradientRecursiveGaussianImageFilter<TInputImage, CovariantVectorImageType> GradientRecursiveGaussianImageFilterType;
  typedef typename GradientRecursiveGaussianImageFilterType::Pointer                  GradientRecursiveGaussianImageFilterPointer;
  typedef GaussianSmoothVectorFieldFilter<VectorDataType, itkGetStaticConstMacro(Dimension), itkGetStaticConstMacro(Dimension)> GaussianSmoothFilterType;
  typedef typename GaussianSmoothFilterType::Pointer                                          GaussianSmoothFilterPointer;
  typedef NormaliseVectorFilter<VectorDataType, itkGetStaticConstMacro(Dimension) >           NormaliseFilterType;
  typedef typename NormaliseFilterType::Pointer                                               NormaliseFilterPointer;
  
  void SetScalarImage(const InputImageType *image) {this->SetNthInput(0, const_cast<InputImageType *>(image)); }

  itkSetMacro(UseMillimetreScaling, bool);
  itkGetMacro(UseMillimetreScaling, bool);

  itkSetMacro(DivideByTwo, bool);
  itkGetMacro(DivideByTwo, bool);

  itkSetMacro(Normalize, bool);
  itkGetMacro(Normalize, bool);

  itkSetMacro(PadValue, InputPixelType);
  itkGetMacro(PadValue, InputPixelType);

  itkSetMacro(DerivativeType, DerivativeType);
  itkGetMacro(DerivativeType, DerivativeType);
  
  itkSetMacro(Sigma, double);
  itkGetMacro(Sigma, double);
  
protected:
  
  ScalarImageToNormalizedGradientVectorImageFilter();
  ~ScalarImageToNormalizedGradientVectorImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  // The main method to implement in derived classes.
  virtual void GenerateData();
    
private:
  
  ScalarImageToNormalizedGradientVectorImageFilter(const Self&); 
  void operator=(const Self&); 

  bool m_UseMillimetreScaling;

  bool m_DivideByTwo;
  
  bool m_Normalize;
  
  double m_Sigma;
  
  InputPixelType m_PadValue;
  
  DerivativeType m_DerivativeType;
  
  GradientImageFilterPointer m_GradientImageFilter;
  
  GradientRecursiveGaussianImageFilterPointer m_GradientRecursiveGaussianImageFilter;
  
  GaussianSmoothFilterPointer m_GaussianSmoothFilter;
  
  NormaliseFilterPointer m_NormalizeFilter;
  
};

}

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

#endif