itkVelocityFieldLieBracketFilter.h

Go to the documentation of this file.

#ifndef __itkVelocityFieldLieBracketFilter_h
#define __itkVelocityFieldLieBracketFilter_h

#include <itkImageToImageFilter.h>
#include <itkVectorCentralDifferenceImageFunction.h>
#include <itkImageRegionConstIteratorWithIndex.h>

namespace itk
{
template< class TInputImage, class TOutputImage >
class ITK_EXPORT VelocityFieldLieBracketFilter:
  public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
  typedef VelocityFieldLieBracketFilter                   Self;
  typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass;
  typedef SmartPointer< Self >                            Pointer;
  typedef SmartPointer< const Self >                      ConstPointer;

  typedef TInputImage                           InputFieldType;
  typedef typename InputFieldType::PixelType    InputFieldPixelType;
  typedef typename InputFieldType::Pointer      InputFieldPointer;
  typedef typename InputFieldType::ConstPointer InputFieldConstPointer;
  typedef typename InputFieldType::RegionType   InputFieldRegionType;

  typedef TOutputImage                           OutputFieldType;
  typedef typename OutputFieldType::PixelType    OutputFieldPixelType;
  typedef typename OutputFieldType::Pointer      OutputFieldPointer;
  typedef typename OutputFieldType::ConstPointer OutputFieldConstPointer;
  typedef typename OutputFieldType::RegionType   OutputFieldRegionType;

  itkNewMacro(Self);

  itkTypeMacro(VelocityFieldLieBracketFilter, ImageToImageFilter);

  typedef itk::VectorCentralDifferenceImageFunction< InputFieldType >
  InputFieldGradientCalculatorType;

  typedef typename InputFieldGradientCalculatorType::OutputType
  InputFieldGradientType;

  virtual void GenerateInputRequestedRegion()
  throw( InvalidRequestedRegionError );

  itkStaticConstMacro(InputFieldDimension, unsigned int,
                      TInputImage::ImageDimension);
  itkStaticConstMacro(OutputFieldDimension, unsigned int,
                      TOutputImage::ImageDimension);
  itkStaticConstMacro(InputFieldPixelDimension, unsigned int,
                      InputFieldPixelType::Dimension);
  itkStaticConstMacro(OutputFieldPixelDimension, unsigned int,
                      OutputFieldPixelType::Dimension);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro( SameDimensionCheck1,
                   ( Concept::SameDimension< InputFieldDimension, OutputFieldDimension > ) );
  itkConceptMacro( SameDimensionCheck2,
                   ( Concept::SameDimension< InputFieldDimension, InputFieldPixelDimension > ) );
  itkConceptMacro( SameDimensionCheck3,
                   ( Concept::SameDimension< OutputFieldDimension, OutputFieldPixelDimension > ) );
#endif
protected:
  VelocityFieldLieBracketFilter();
  ~VelocityFieldLieBracketFilter() {}
  void PrintSelf(std::ostream & os, Indent indent) const;

  void ThreadedGenerateData(const OutputFieldRegionType & outputRegionForThread,
                            int threadId);

  void BeforeThreadedGenerateData();

  itkSetObjectMacro(RightGradientCalculator, InputFieldGradientCalculatorType);
  itkSetObjectMacro(LeftGradientCalculator,  InputFieldGradientCalculatorType);

  itkGetObjectMacro(RightGradientCalculator, InputFieldGradientCalculatorType);
  itkGetObjectMacro(LeftGradientCalculator,  InputFieldGradientCalculatorType);
private:
  // purposely not implemented
  VelocityFieldLieBracketFilter(const Self &);
  void operator=(const Self &);

  typename InputFieldGradientCalculatorType::Pointer m_RightGradientCalculator;
  typename InputFieldGradientCalculatorType::Pointer m_LeftGradientCalculator;
};
} // end namespace itk

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

#endif