animaResampleImageFilter.h

Go to the documentation of this file.

#pragma once

#include <itkFixedArray.h>
#include <itkTransform.h>
#include <itkImageFunction.h>
#include <itkImageRegionIterator.h>
#include <itkImageToImageFilter.h>
#include <itkInterpolateImageFunction.h>
#include <itkMatrixOffsetTransformBase.h>
#include <itkSize.h>

namespace anima
{

template <class TInputImage, class TOutputImage, class TInterpolatorPrecisionType=double>
class ResampleImageFilter : public itk::ImageToImageFilter<TInputImage, TOutputImage>
{
public:
    typedef ResampleImageFilter                           Self;
    typedef itk::ImageToImageFilter<TInputImage,TOutputImage>  Superclass;
    typedef itk::SmartPointer<Self>                            Pointer;
    typedef itk::SmartPointer<const Self>                      ConstPointer;

    typedef TInputImage                             InputImageType;
    typedef TOutputImage                            OutputImageType;
    typedef typename InputImageType::Pointer        InputImagePointer;
    typedef typename InputImageType::ConstPointer   InputImageConstPointer;
    typedef typename OutputImageType::Pointer       OutputImagePointer;
    typedef typename InputImageType::RegionType     InputImageRegionType;
    typedef typename InputImageType::IndexType InputIndexType;

    itkNewMacro(Self)

    
    itkTypeMacro(ResampleImageFilter, itk::ImageToImageFilter)

    
    itkStaticConstMacro(ImageDimension, unsigned int,
                        TOutputImage::ImageDimension);
    itkStaticConstMacro(InputImageDimension, unsigned int,
                        TInputImage::ImageDimension);

    typedef itk::Transform<TInterpolatorPrecisionType,
    itkGetStaticConstMacro(ImageDimension),
    itkGetStaticConstMacro(ImageDimension)> TransformType;
    typedef typename TransformType::ConstPointer TransformPointerType;

    typedef itk::MatrixOffsetTransformBase <TInterpolatorPrecisionType,
    itkGetStaticConstMacro(ImageDimension),
    itkGetStaticConstMacro(ImageDimension)> MatrixTransformType;

    typedef itk::InterpolateImageFunction<InputImageType, TInterpolatorPrecisionType> InterpolatorType;
    typedef typename InterpolatorType::Pointer  InterpolatorPointerType;

    typedef itk::Size<itkGetStaticConstMacro(ImageDimension)> SizeType;

    typedef typename TOutputImage::IndexType IndexType;

    typedef typename InterpolatorType::PointType    PointType;
    //typedef typename TOutputImage::PointType    PointType;

    typedef typename TOutputImage::PixelType   PixelType;
    typedef typename TInputImage::PixelType    InputPixelType;

    typedef typename TOutputImage::RegionType OutputImageRegionType;

    typedef typename TOutputImage::SpacingType   SpacingType;
    typedef typename TOutputImage::PointType     OriginPointType;
    typedef typename TOutputImage::DirectionType DirectionType;

    typedef itk::ImageBase<itkGetStaticConstMacro(ImageDimension)> ImageBaseType;

    void SetTransform(TransformType *transform);

    itkGetConstObjectMacro(Transform, TransformType)

    
    itkSetObjectMacro(Interpolator, InterpolatorType)

    
    itkGetConstObjectMacro(Interpolator, InterpolatorType)

    
    itkSetMacro(Size, SizeType)

    
    itkGetConstReferenceMacro(Size, SizeType)

    
    itkSetMacro(DefaultPixelValue, PixelType)

    
    itkGetConstReferenceMacro(DefaultPixelValue, PixelType)

    
    itkSetMacro(OutputSpacing, SpacingType)
    virtual void SetOutputSpacing(const double* values);

    itkGetConstReferenceMacro(OutputSpacing, SpacingType)

    
    itkSetMacro(OutputOrigin, OriginPointType)
    virtual void SetOutputOrigin(const double* values);

    itkGetConstReferenceMacro(OutputOrigin, OriginPointType)

    
    itkSetMacro(OutputDirection, DirectionType)
    itkGetConstReferenceMacro(OutputDirection, DirectionType)

    
    void SetOutputParametersFromImage ( const ImageBaseType * image );

    itkSetMacro(OutputStartIndex, IndexType)

    
    itkGetConstReferenceMacro(OutputStartIndex, IndexType)

    
    void SetReferenceImage (const TOutputImage *image);
    const TOutputImage * GetReferenceImage() const;

    itkSetMacro(UseReferenceImage, bool)
    itkBooleanMacro(UseReferenceImage)
    itkGetConstMacro(UseReferenceImage, bool)

    
    virtual void GenerateOutputInformation() ITK_OVERRIDE;

    virtual void GenerateInputRequestedRegion() ITK_OVERRIDE;

    virtual void BeforeThreadedGenerateData() ITK_OVERRIDE;

    virtual void AfterThreadedGenerateData() ITK_OVERRIDE;

    itk::ModifiedTimeType GetMTime() const ITK_OVERRIDE;

    void SetScaleIntensitiesWithJacobian(bool scale) {m_ScaleIntensitiesWithJacobian = scale;}

protected:
    ResampleImageFilter();
    virtual ~ResampleImageFilter() {}

    void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE;

    void DynamicThreadedGenerateData(const OutputImageRegionType& outputRegionForThread) ITK_OVERRIDE;

    double ComputeLinearJacobianValue();
    double ComputeLocalJacobianValue(const InputIndexType &index);

    virtual itk::LightObject::Pointer InternalClone() const ITK_OVERRIDE;

private:
    ITK_DISALLOW_COPY_AND_ASSIGN(ResampleImageFilter);

    SizeType                m_Size;              // Size of the output image
    TransformPointerType    m_Transform;         // Coordinate transform to use
    InterpolatorPointerType m_Interpolator;      // Image function for interpolation
    PixelType               m_DefaultPixelValue; // default pixel value if the point is outside the image
    SpacingType             m_OutputSpacing;     // output image spacing
    OriginPointType         m_OutputOrigin;      // output image origin
    DirectionType           m_OutputDirection;   // output image direction cosines
    IndexType               m_OutputStartIndex;  // output image start index
    bool                    m_UseReferenceImage;

    bool                    m_ScaleIntensitiesWithJacobian;
    bool                    m_LinearTransform;
};

} // end namespace anima

#include "animaResampleImageFilter.hxx"