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 __MITK_TIME_FRAMES_REGISTRATION_HELPER_H_
#define __MITK_TIME_FRAMES_REGISTRATION_HELPER_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 // __MITK_PARAMETER_FIT_IMAGE_GENERATOR_H_