mitkMAPRegistrationWrapper.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
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 or http://www.mitk.org for details.

===================================================================*/


#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 );

  itkNewMacro( Self );

  virtual void SetRequestedRegionToLargestPossibleRegion();

  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();

  virtual bool VerifyRequestedRegion();

  virtual void SetRequestedRegion(const itk::DataObject*);

  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 ::itk::Point<mitk::ScalarType,VMovingDim> MITKMovingPointType;
    typedef ::itk::Point<mitk::ScalarType,VTargetDim> MITKTargetPointType;
    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 (NULL). 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 ::itk::Point<mitk::ScalarType,VMovingDim> MITKMovingPointType;
  typedef ::itk::Point<mitk::ScalarType,VTargetDim> MITKTargetPointType;
  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 (NULL). 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;

  void SetRegistration(map::core::RegistrationBase* pReg);

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

    MAPRegistrationWrapper();
    virtual ~MAPRegistrationWrapper();

    map::core::RegistrationBase::Pointer m_spRegistration;

private:

    MAPRegistrationWrapper& operator = (const MAPRegistrationWrapper&);
    MAPRegistrationWrapper(const MAPRegistrationWrapper&);

};

}

#endif