mitkTimeFramesRegistrationHelper.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkTimeFramesRegistrationHelper_h
#define mitkTimeFramesRegistrationHelper_h
 
 
#include <mitkImage.h>
#include <mitkTimeGeometry.h>
#include <mitkImageMappingHelper.h>
 
#include <mapRegistrationAlgorithmBase.h>
#include <mapRegistrationBase.h>
#include <mapEvents.h>
 
#include "MitkMatchPointRegistrationExports.h"
 
namespace mitk
{
 
  mapEventMacro(FrameRegistrationEvent, ::map::events::TaskBatchEvent, MITKMATCHPOINTREGISTRATION_EXPORT);
  mapEventMacro(FrameMappingEvent, ::map::events::TaskBatchEvent, MITKMATCHPOINTREGISTRATION_EXPORT);
 
  class MITKMATCHPOINTREGISTRATION_EXPORT TimeFramesRegistrationHelper : public itk::Object
  {
  public:
    mitkClassMacroItkParent(TimeFramesRegistrationHelper, itk::Object);
 
    itkNewMacro(Self);
 
    typedef ::map::algorithm::RegistrationAlgorithmBase RegistrationAlgorithmBaseType;
    typedef RegistrationAlgorithmBaseType::Pointer RegistrationAlgorithmPointer;
    typedef ::map::core::RegistrationBase RegistrationType;
    typedef RegistrationType::Pointer RegistrationPointer;
 
    typedef std::vector<mitk::TimeStepType> IgnoreListType;
 
    itkSetConstObjectMacro(4DImage, Image);
    itkGetConstObjectMacro(4DImage, Image);
 
    itkSetConstObjectMacro(TargetMask, Image);
    itkGetConstObjectMacro(TargetMask, Image);
 
    itkSetObjectMacro(Algorithm, RegistrationAlgorithmBaseType);
    itkGetObjectMacro(Algorithm, RegistrationAlgorithmBaseType);
 
    itkSetMacro(AllowUndefPixels, bool);
    itkGetConstMacro(AllowUndefPixels, bool);
 
    itkSetMacro(PaddingValue, double);
    itkGetConstMacro(PaddingValue, double);
 
    itkSetMacro(AllowUnregPixels, bool);
    itkGetConstMacro(AllowUnregPixels, bool);
 
    itkSetMacro(ErrorValue, double);
    itkGetConstMacro(ErrorValue, double);
 
    itkSetMacro(InterpolatorType, mitk::ImageMappingInterpolator::Type);
    itkGetConstMacro(InterpolatorType, mitk::ImageMappingInterpolator::Type);
 
    void ClearIgnoreList();
    void SetIgnoreList(const IgnoreListType& il);
    itkGetConstMacro(IgnoreList, IgnoreListType);
 
    virtual double GetProgress() const;
 
    void Generate();
 
    Image::Pointer GetRegisteredImage();
 
  protected:
    TimeFramesRegistrationHelper() :
      m_AllowUndefPixels(true),
      m_PaddingValue(0),
      m_AllowUnregPixels(true),
      m_ErrorValue(0),
      m_InterpolatorType(mitk::ImageMappingInterpolator::Linear),
      m_Progress(0)
    {
      m_4DImage = nullptr;
      m_TargetMask = nullptr;
      m_Registered4DImage = nullptr;
    };
 
    ~TimeFramesRegistrationHelper() override {};
 
    RegistrationPointer DoFrameRegistration(const mitk::Image* movingFrame,
                                            const mitk::Image* targetFrame, const mitk::Image* targetMask) const;
 
    mitk::Image::Pointer DoFrameMapping(const mitk::Image* movingFrame, const RegistrationType* reg,
                                        const mitk::Image* targetFrame) const;
 
    bool HasOutdatedResult() const;
    void CheckValidInputs() const;
 
    mitk::Image::Pointer GetFrameImage(const mitk::Image* image, mitk::TimePointType timePoint) const;
 
    RegistrationAlgorithmPointer m_Algorithm;
 
  private:
    Image::ConstPointer m_4DImage;
    Image::ConstPointer m_TargetMask;
    Image::Pointer m_Registered4DImage;
 
    IgnoreListType m_IgnoreList;
 
    bool m_AllowUndefPixels;
    double m_PaddingValue;
    bool m_AllowUnregPixels;
    double m_ErrorValue;
    mitk::ImageMappingInterpolator::Type m_InterpolatorType;
 
    double m_Progress;
  };
 
}
 
#endif