itkFourthOrderRungeKuttaVelocityFieldIntegrationFilter.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 itkFourthOrderRungeKuttaVelocityFieldIntegrationFilter_h
#define itkFourthOrderRungeKuttaVelocityFieldIntegrationFilter_h

#include <itkVector.h>
#include <itkImage.h>
#include <itkImageToImageFilter.h>
#include <itkVectorLinearInterpolateImageFunction.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <itkPoint.h>
#include <itkContinuousIndex.h>

namespace itk {

template < typename TScalarType, unsigned int NDimensions = 3>
class ITK_EXPORT FourthOrderRungeKuttaVelocityFieldIntegrationFilter : 
public ImageToImageFilter<
                           Image< Vector<TScalarType, NDimensions>,  NDimensions + 1>, // Input image is time varying velocity field.
                           Image< Vector<TScalarType, NDimensions>,  NDimensions>      // Output image is integrated displacement field.
                         >
{
  
  public:
    
    typedef FourthOrderRungeKuttaVelocityFieldIntegrationFilter                           Self;
    typedef ImageToImageFilter<Image< Vector<TScalarType, NDimensions>,  NDimensions + 1>,
                               Image< Vector<TScalarType, NDimensions>,  NDimensions>
                              >                                                           Superclass;
    typedef SmartPointer<Self>                                                            Pointer;
    typedef SmartPointer<const Self>                                                      ConstPointer;

    itkNewMacro(Self);

    itkTypeMacro(FourthOrderRungeKuttaVelocityFieldIntegrationFilter, ImageToImageFilter);

    itkStaticConstMacro(Dimension, unsigned int, NDimensions);

    typedef Vector< TScalarType, NDimensions >                                            TimeVaryingVelocityPixelType;
    typedef Image< TimeVaryingVelocityPixelType, NDimensions + 1 >                        TimeVaryingVelocityImageType;
    typedef typename TimeVaryingVelocityImageType::RegionType                             TimeVaryingVelocityRegionType;
    typedef typename TimeVaryingVelocityImageType::IndexType                              TimeVaryingVelocityIndexType;
    typedef typename TimeVaryingVelocityImageType::SizeType                               TimeVaryingVelocitySizeType;
    typedef typename TimeVaryingVelocityImageType::PointType                              TimeVaryingVelocityPointType;
    typedef typename TimeVaryingVelocityImageType::SpacingType                            TimeVaryingVelocitySpacingType;
    typedef typename TimeVaryingVelocityImageType::DirectionType                          TimeVaryingVelocityDirectionType;
    typedef TScalarType                                                                   MaskPixelType;
    typedef Image< MaskPixelType, NDimensions>                                            MaskImageType;
    typedef typename MaskImageType::Pointer                                               MaskImagePointer;
    typedef typename MaskImageType::IndexType                                             MaskImageIndexType;
    typedef typename MaskImageType::PointType                                             MaskImagePointType;
    typedef Vector< TScalarType, NDimensions >                                            DisplacementPixelType;
    typedef Image< DisplacementPixelType, NDimensions>                                    DisplacementImageType;
    typedef typename DisplacementImageType::RegionType                                    DisplacementImageRegionType;
    typedef typename DisplacementImageType::IndexType                                     DisplacementImageIndexType;
    typedef typename DisplacementImageType::SizeType                                      DisplacementImageSizeType;
    typedef typename DisplacementImageType::PointType                                     DisplacementImagePointType;
    typedef typename DisplacementImageType::SpacingType                                   DisplacementImageSpacingType;
    typedef typename DisplacementImageType::DirectionType                                 DisplacementImageDirectionType;
    typedef VectorLinearInterpolateImageFunction< TimeVaryingVelocityImageType, 
                                                  TScalarType >                           TimeVaryingVelocityFieldInterpolatorType;
    typedef typename TimeVaryingVelocityFieldInterpolatorType::Pointer                    TimeVaryingVelocityFieldInterpolatorPointer;
    typedef Point<TScalarType, NDimensions + 1>                                           TimeVaryingPointType;
    typedef Image<TScalarType, NDimensions>                                               ThicknessImageType;
    typedef typename ThicknessImageType::PixelType                                        ThicknessImagePixelType;
    typedef typename ThicknessImageType::Pointer                                          ThicknessImagePointer;
    typedef NearestNeighborInterpolateImageFunction<ThicknessImageType, TScalarType>      ThicknessImageInterpolatorType;
    typedef typename ThicknessImageInterpolatorType::Pointer                              ThicknessImageInterpolatorPointer;
    
    itkSetMacro(StartTime, float);
    itkGetMacro(StartTime, float);

    itkSetMacro(FinishTime, float);
    itkGetMacro(FinishTime, float);

    itkSetMacro(DeltaTime, float);
    itkGetMacro(DeltaTime, float);
    
    itkSetMacro(CalculateThickness, bool);
    itkGetMacro(CalculateThickness, bool);

    itkGetMacro(MaxThickness, float);

    itkGetMacro(MaxDisplacement, float);

    itkGetMacro(FieldEnergy, float);

    void SetVoxelsToIntegrateMaskImage(MaskImageType* image) { m_MaskImage = image; }
    
    void SetMaxDistanceMaskImage(ThicknessImageType* maxDistance) { m_MaxDistanceMask = maxDistance; }

    void SetGreyWhiteInterfaceMaskImage(MaskImageType* greyWhiteInterface) { m_GreyWhiteInterface = greyWhiteInterface; }
    
    ThicknessImageType* GetCalculatedThicknessImage() { return m_ThicknessImage; }
    
  protected:
    
    FourthOrderRungeKuttaVelocityFieldIntegrationFilter();
    ~FourthOrderRungeKuttaVelocityFieldIntegrationFilter() {};
    void PrintSelf(std::ostream& os, Indent indent) const;
    
    // Called before threaded bit.
    virtual void BeforeThreadedGenerateData();
    
    // The main method to implement in derived classes, note, its threaded.
    virtual void ThreadedGenerateData(const DisplacementImageRegionType &regionForThread, ThreadIdType threadId);
    
    // Called after threaded bit.
    virtual void AfterThreadedGenerateData();
    
  private:
    
    FourthOrderRungeKuttaVelocityFieldIntegrationFilter(const Self&); 
    void operator=(const Self&); 
    
    float m_StartTime;
    
    float m_FinishTime;
    
    float m_DeltaTime;

    float m_MaxThickness;

    float m_MaxDisplacement;

    float m_FieldEnergy;

    TimeVaryingVelocityFieldInterpolatorPointer m_TimeVaryingVelocityFieldInterpolator;

    ThicknessImageInterpolatorPointer m_MaxDistanceImageInterpolator;

    ThicknessImagePointer m_MaxDistanceMask;
    
    MaskImagePointer m_MaskImage;
    
    MaskImagePointer m_GreyWhiteInterface;
    
    bool m_CalculateThickness;
    
    ThicknessImagePointer m_ThicknessImage;
    
    ThicknessImagePointer m_HitsImage;
    
    virtual void GenerateOutputInformation();

    void IntegrateRegion(const DisplacementImageRegionType &regionForThread, float directionOverride, bool writeToOutput, bool writeToThicknessImage);
    
    void IntegratePoint(const float& startTime, 
        const float& endTime, 
        const float& direction, 
        const unsigned int& numberOfTimePoints,
        const DisplacementImageIndexType& index,
        const TimeVaryingVelocityImageType* velocityField,
        const bool& writeToThicknessImage,
        DisplacementPixelType& displacement);
    
}; // end class

} // end namespace

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

#endif