mitkMAPRegistrationWrapper.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 mitkMAPRegistrationWrapper_h
#define mitkMAPRegistrationWrapper_h
 
//MITK
#include <mitkBaseData.h>
#include <mitkGeometry3D.h>
 
//MatchPoint
#include <mapRegistrationBase.h>
#include <mapRegistration.h>
#include <mapExceptionObjectMacros.h>
#include <mapContinuousElements.h>
 
//MITK
#include <MitkMatchPointRegistrationExports.h>
 
namespace mitk
{
class MITKMATCHPOINTREGISTRATION_EXPORT MAPRegistrationWrapper: public mitk::BaseData
{
public:
 
  mitkClassMacro( MAPRegistrationWrapper, BaseData );
 
  mitkNewMacro1Param( Self, ::map::core::RegistrationBase*);
 
  Identifiable::UIDType GetUID() const override;
 
  bool IsEmptyTimeStep(unsigned int t) const override;
 
  bool IsEmpty() const override;
 
  void SetRequestedRegionToLargestPossibleRegion() override;
 
  bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
  bool VerifyRequestedRegion() override;
 
  void SetRequestedRegion(const itk::DataObject*) override;
 
  virtual unsigned int GetMovingDimensions() const;
 
  virtual unsigned int GetTargetDimensions() const;
 
  typedef ::map::core::RegistrationBase::TagType TagType;
  typedef ::map::core::RegistrationBase::ValueType ValueType;
  typedef ::map::core::RegistrationBase::TagMapType TagMapType;
 
  const TagMapType& GetTags() const;
 
  bool GetTagValue(const TagType & tag, ValueType & value) const;
 
  bool HasLimitedTargetRepresentation() const;
 
  bool HasLimitedMovingRepresentation() const;
 
  template <unsigned int VMovingDim, unsigned int VTargetDim>
  bool MapPoint(const ::itk::Point<mitk::ScalarType,VMovingDim>& inPoint, ::itk::Point<mitk::ScalarType,VTargetDim>& outPoint) const
  {
    typedef typename ::map::core::continuous::Elements<VMovingDim>::PointType MAPMovingPointType;
    typedef typename ::map::core::continuous::Elements<VTargetDim>::PointType MAPTargetPointType;
 
    if (m_spRegistration.IsNull())
    {
        mapDefaultExceptionMacro(<< "Error. Cannot map point. Wrapper points to invalid registration (nullptr). Point: " << inPoint);
    }
 
    bool result = false;
 
    if ((this->GetMovingDimensions() == VMovingDim)&&(this->GetTargetDimensions() == VTargetDim))
      {
        MAPMovingPointType tempInP;
        MAPTargetPointType tempOutP;
        tempInP.CastFrom(inPoint);
 
        typedef ::map::core::Registration<VMovingDim,VTargetDim> CastedRegType;
        const CastedRegType* pCastedReg = dynamic_cast<const CastedRegType*>(m_spRegistration.GetPointer());
 
        if (!pCastedReg)
        {
            mapDefaultExceptionMacro(<< "Error. Cannot map point. Registration has invalid dimension. Point: " << inPoint);
        }
 
        result = pCastedReg->mapPoint(tempInP,tempOutP);
        if (result)
          {
            outPoint.CastFrom(tempOutP);
          }
 
      }
 
    return result;
  };
 
  template <unsigned int VMovingDim, unsigned int VTargetDim>
  bool MapPointInverse(const ::itk::Point<mitk::ScalarType,VTargetDim> & inPoint, ::itk::Point<mitk::ScalarType,VMovingDim> & outPoint) const
{
  typedef typename ::map::core::continuous::Elements<VMovingDim>::PointType MAPMovingPointType;
  typedef typename ::map::core::continuous::Elements<VTargetDim>::PointType MAPTargetPointType;
 
  if (m_spRegistration.IsNull())
  {
      mapDefaultExceptionMacro(<< "Error. Cannot map point. Wrapper points to invalid registration (nullptr). Point: " << inPoint);
  }
 
  bool result = false;
 
  if ((this->GetMovingDimensions() == VMovingDim)&&(this->GetTargetDimensions() == VTargetDim))
    {
      MAPTargetPointType tempInP;
      MAPMovingPointType tempOutP;
      tempInP.CastFrom(inPoint);
 
      typedef ::map::core::Registration<VMovingDim,VTargetDim> CastedRegType;
      const CastedRegType* pCastedReg = dynamic_cast<const CastedRegType*>(m_spRegistration.GetPointer());
 
      if (!pCastedReg)
      {
          mapDefaultExceptionMacro(<< "Error. Cannot map point. Registration has invalid dimension. Point: " << inPoint);
      }
 
      result = pCastedReg->mapPointInverse(tempInP,tempOutP);
      if (result)
        {
          outPoint.CastFrom(tempOutP);
        }
 
    }
 
  return result;
};
 
  mitk::Geometry3D GetDirectFieldRepresentation() const;
 
  mitk::Geometry3D GetInverseFieldRepresentation() const;
 
  void PrecomputeDirectMapping();
 
  void PrecomputeInverseMapping();
 
  ::map::core::RegistrationBase* GetRegistration();
 
  const ::map::core::RegistrationBase* GetRegistration() const;
 
protected:
    void PrintSelf (std::ostream &os, itk::Indent indent) const override;
 
    MAPRegistrationWrapper(::map::core::RegistrationBase* registration);
    ~MAPRegistrationWrapper() override;
 
    void SetUID(const UIDType& uid) override;
 
    ::map::core::RegistrationBase::Pointer m_spRegistration;
 
private:
 
    MAPRegistrationWrapper& operator = (const MAPRegistrationWrapper&);
    MAPRegistrationWrapper(const MAPRegistrationWrapper&);
 
};
 
}
 
#endif