freClosedFormRegistrationControllerBase.txx

Go to the documentation of this file.

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

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freClosedFormRegistrationControllerBase.txx,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

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

#ifndef __freClosedFormRegistrationControllerBase_txx
#define __freClosedFormRegistrationControllerBase_txx

#include "freClosedFormRegistrationControllerBase.h"

#include "freRegistrationProcessEventHandler.h"
#include "freIntensityImageMediaController.h"
#include "freTransformFieldMediaController.h"
#include "frePointSetMediaController.h"
#include "freRigid2DTransformController.h"
#include "freVersorRigid3DTransformController.h"
#include "freTransformFunctionMediaController.h"

namespace FREE
{
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: cParam_PersistentFinalField = "PersistentFinalField";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: cParamDsc_PersistentFinalField = "Indicates if the final field should be stored internally and only will be recomputed if registration is outdated. Keeping the image persistent accelerates the processing, but requires more memory.";

template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaID_finalField = "finalField";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaIDDsc_finalField = "Transformation field generated by using the current/final transform of the registration.";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaID_fieldReference = "fieldReference";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaIDDsc_fieldReference = "Image that is reference for origin, size and spacing of the final field.";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaID_finalTransform = "finalTransform";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaIDDsc_finalTransform = "Transformation function of the current/final transform of the registration.";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaID_finalInverseTransform = "finalInverseTransform";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaIDDsc_finalInverseTransform = "Transformation function of the current/final transform of the registration. This media is only valid if the transform can be inverted";

template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaID_fixedPointSet = "fixedPointSet";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaIDDsc_fixedPointSet = "Fixed point set of the registration.";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaID_movingPointSet = "movingPointSet";
template <class ComponentType>
const char* const ClosedFormRegistrationControllerBase<ComponentType> :: MediaIDDsc_movingPointSet = "Moving point set of the registration.";


template <class ComponentType>
typename ClosedFormRegistrationControllerBase<ComponentType>::ComponentPointer
ClosedFormRegistrationControllerBase<ComponentType>::
BuildMainComponent(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
{
  ComponentPointer mainComponent = Superclass::BuildMainComponent(pComponentSetup,pComponentCache);
  DirectSessionComponentAccessor::SetRepositoryElement(SessionComponentRepositoryKeys::Validity("Registration"),ValidityTag::NewNull(),pComponentCache);
  return mainComponent;
};

template <class ComponentType>
void
ClosedFormRegistrationControllerBase<ComponentType>::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache,
                       SessionInfo* pSessionInfo,
                       const unsigned int& iActLevel) const
{
  Superclass::ActualizeMainComponent(pMainComponent,pComponentCache, pSessionInfo, iActLevel);
  
  //prepare registration processor
  pMainComponent->SetSessionInfo(pSessionInfo);
  pMainComponent->SetComponentCache(pComponentCache);
}

template <class ComponentType>
ValidityTag::Pointer
ClosedFormRegistrationControllerBase<ComponentType>::
GetMediaValidityTagRequirement(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
        if ((mediaID == MediaID_finalField) || (mediaID == MediaID_finalTransform) || (mediaID == MediaID_finalInverseTransform))
  {
    ValidityTag::Pointer smpReq = ValidityTag::New(this->GetMediaValidityTag(mediaID,pComponentCache)->GetTimeStamp());

    //check registration
    ValidityTag::Pointer smpRegistrationReq = this->GetValidityTagRequirement("Registration",pComponentCache);
    if (smpReq->IsOutdated(smpRegistrationReq))
    { //Registration is newer then final result, so there is a requirement.
        smpReq->SetTag(smpRegistrationReq);
    }
    return smpReq;
  }

  return Superclass::GetMediaValidityTagRequirement(mediaID, pComponentCache);
}

template <class ComponentType>
ValidityTag::Pointer
ClosedFormRegistrationControllerBase<ComponentType>::
GetValidityTagRequirement(const std::string& id, SessionComponentCache* pComponentCache) const
{
  if (id == "Registration")
  {
    ValidityTag::Pointer smpReq = ValidityTag::New(this->GetValidityTag(id,pComponentCache)->GetTimeStamp());

    //check moving image 
    this->CompareValidityTagRequirement(MediaID_movingPointSet,smpReq,pComponentCache);
    this->CompareValidityTagRequirement(MediaID_fixedPointSet,smpReq,pComponentCache);

    return smpReq;
  }

  return Superclass::GetMediaValidityTagRequirement(id, pComponentCache);
}

template <class ComponentType>
ClosedFormRegistrationControllerBase<ComponentType>::
ClosedFormRegistrationControllerBase()
{       
  //Profile settings
  this->UpdateControllerID(ControllerID::ClosedFormRegistrationControllerBase);
  this->m_Description = "Realizes a rigid registration via closed form solution using reference point sets.";
};

template <class ComponentType>
void
ClosedFormRegistrationControllerBase<ComponentType>::
GenerateProfile(CtrlProfile::ControllerProfile& profile,
                const SessionComponentCache* pComponentCache,
                bool bRegardOldSetup) const
{
  Superclass::GenerateProfile(profile,pComponentCache,bRegardOldSetup);

  //Parameters
  profile.Parameters().AddParameter(cParam_PersistentFinalField,Parameter::PVTBool,cParamDsc_PersistentFinalField,1,"true");

  //Subcomponents
  profile.SubComponents().AddSubComponent(cComp_MainTransform,1,csUndefinedController,cCompDsc_MainTransform);

  //Media
  if (ComponentType::ImageDimension == 2)
  {
    profile.MediaMap().AddMedia(MediaID_finalField,ControllerID::TransformField2DMediaController,DAGet,ComponentType::ImageDimension);
  
    profile.MediaMap().AddMedia(MediaID_movingPointSet,ControllerID::PointSet2DMediaController,DAGet,ComponentType::ImageDimension);
    profile.MediaMap().AddMedia(MediaID_fixedPointSet,ControllerID::PointSet2DMediaController,DAGet,ComponentType::ImageDimension);
  }
  else
  {
    profile.MediaMap().AddMedia(MediaID_finalField,ControllerID::TransformField3DMediaController,DAGet,ComponentType::ImageDimension);
  
    profile.MediaMap().AddMedia(MediaID_movingPointSet,ControllerID::PointSet3DMediaController,DAGet,ComponentType::ImageDimension);
    profile.MediaMap().AddMedia(MediaID_fixedPointSet,ControllerID::PointSet3DMediaController,DAGet,ComponentType::ImageDimension);
  }
    
  profile.MediaMap().AddMedia(MediaID_fieldReference,ControllerID::ImageMediaControllerBase, DASet,ComponentType::ImageDimension,0);

  profile.MediaMap().AddMedia(MediaID_finalTransform,ControllerID::TransformFunctionMediaControllerBase, DAGet,ComponentType::ImageDimension);
  profile.MediaMap().AddMedia(MediaID_finalInverseTransform,ControllerID::TransformFunctionMediaControllerBase, DAGet,ComponentType::ImageDimension);

    //Profile setting
        CtrlProfile::ProfileOption* pOption;

                //transform
        pOption = profile.Requirements().AddRequirement(cComp_MainTransform)->AddProfileOption();
  if (ComponentType::ImageDimension == 2)
  {
    pOption->Inheritance().AddAncestor(ControllerID::Rigid2DTransformController);
  }
  else
  {
    pOption->Inheritance().AddAncestor(ControllerID::VersorRigid3DTransformController);
  }     
        pOption->CheckForInheritance();
        pOption->CheckForIO();
};

template <class ComponentType>
typename ClosedFormRegistrationControllerBase<ComponentType>::GenericComponentType*
ClosedFormRegistrationControllerBase<ComponentType>::
GetSubComponentCasted(ComponentType* pMainComponent, const ComponentID& compID,
                      SessionComponentCache* pMainComponentCache) const
{
        if (compID == cComp_MainTransform) return pMainComponent->GetTransform();

        return Superclass::GetSubComponentCasted(pMainComponent, compID, pMainComponentCache);
}; 

template <class ComponentType>
void
ClosedFormRegistrationControllerBase<ComponentType>::
SetSubComponentCasted(GenericComponentType* pSubComponent, ComponentType* pMainComponent,
                               const ComponentID compID, SessionComponentCache* pMainComponentCache) const
{
        if (compID == cComp_MainTransform) pMainComponent->SetTransform(dynamic_cast<typename ComponentType::TransformType*>(pSubComponent));
  else Superclass::SetSubComponentCasted(pSubComponent, pMainComponent, compID, pMainComponentCache);
}; 

template <class ComponentType>
typename ClosedFormRegistrationControllerBase<ComponentType>::GenericMediaPointer
ClosedFormRegistrationControllerBase<ComponentType>::
GetMediaCasted(const MediaID& mediaID,ComponentType* pComponent, SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  GenericMediaPointer smpMedia;

        if ((mediaID == MediaID_finalField) || (mediaID == MediaID_finalTransform) || (mediaID == MediaID_finalInverseTransform))
  { //Both are based on the registration so check first if registration needed
    typename ValidityTag::Pointer smpRegistrationValidity = this->GetValidityTag("Registration",pComponentCache);
    typename ValidityTag::Pointer smpRegistrationValidityReq = this->GetValidityTagRequirement("Registration",pComponentCache);

    if (smpRegistrationValidity->IsOutdated(smpRegistrationValidityReq))
    { //registration is outdated -> compute new registration
      this->NotifyProgress(1,"Registration outdated -> actualize",pComponentCache);
      SessionBuilder::LinkMediaToComponent(pComponentCache, pSessionInfo);
      SessionBuilder::ActualizeComponent(pComponentCache, pSessionInfo);

      StatisticEntry* pRegistrationEntry = Superclass::AddStatisticEntry(pComponentCache, pSessionInfo, "Registration", "a closed form registration");

      pComponent->StartRegistration();

      if (pRegistrationEntry) pRegistrationEntry->CloseEntry();

      this->ResetComponent(pComponentCache, pSessionInfo);

      this->ActualizeValidityTag("Registration",pComponentCache);
      this->NotifyProgress(1,"Registration updated",pComponentCache);
    }

        if (mediaID == MediaID_finalField)
    {
      ValidityTag::Pointer smpVal = this->GetMediaValidityTag(mediaID,pComponentCache);
      ValidityTag::Pointer smpValReq = this->GetMediaValidityTagRequirement(mediaID,pComponentCache);

      bool bKeep = true;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_PersistentFinalField,bKeep);

      if (smpVal->IsOutdated(smpValReq) || (!bKeep))
      { //final field is outdated -> compute new final field
        this->NotifyProgress(1,"Final field outdated -> actualize",pComponentCache);

        StatisticEntry* pRegistrationFieldEntry = Superclass::AddStatisticEntry(pComponentCache, pSessionInfo, "ComputeDeformationField", "Computation of a deformation field");
    
        try
        {
          typename ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(MediaID_fieldReference);
          if (smpLink.IsNull())
          {
            throwCtrlExceptionMacro("","Error. Cannot generate transformation field. No field reference set for closed form registration.");
          }
          else
          { 
            GenericMediaPointer smpFieldRef = SessionAccessor::GetMedia(smpLink->GetSourceIDPath(), pSessionInfo);

            typedef typename ComponentType::ImageType::Superclass ComponentImageBaseType;
            ComponentImageBaseType* pFieldRef = dynamic_cast<ComponentImageBaseType*>(smpFieldRef.GetPointer());
            if (!pFieldRef) throwCtrlExceptionMacro("","Error. Link for field reference found, but field seems to have wrong type.");
            //compute field by the characteristics of the reference
            smpMedia = pComponent->GetTransformationField(pFieldRef->GetOrigin(),pFieldRef->GetLargestPossibleRegion(),pFieldRef->GetSpacing());
          }
        }
        catchAllNPassMacro("Unkown error while computing transormation field.");

        if (pRegistrationFieldEntry) pRegistrationFieldEntry->CloseEntry();

        if (bKeep) DirectSessionComponentAccessor::SetRepositoryElement(mediaID,smpMedia,pComponentCache);
        this->ActualizeMediaValidityTag(mediaID,pComponentCache);
      }
      else
      {
        smpMedia = DirectSessionComponentAccessor::GetRepositoryElement(mediaID,pComponentCache);
      }
    }
    else
    { // (mediaID == MediaID_finalTransform) || (mediaID == MediaID_finalInverseTransform)
      try
      {
        ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(MediaID_fieldReference);
        if (smpLink.IsNull())
        { //no field reference is linked, so calculate normal final transformation function
          if (mediaID == MediaID_finalTransform)
          {
            smpMedia = pComponent->GetTransformationFunction();
          }
          else
          {
            smpMedia = pComponent->GetInverseTransformationFunction();
          }
        }
        else
        { 
          GenericMediaPointer smpFieldRef = SessionAccessor::GetMedia(smpLink->GetSourceIDPath(), pSessionInfo);

          typedef typename ComponentType::ImageType::Superclass ComponentImageBaseType;
          ComponentImageBaseType* pFieldRef = dynamic_cast<ComponentImageBaseType*>(smpFieldRef.GetPointer());
          if (!pFieldRef) throwCtrlExceptionMacro("","Error. Link for field reference found, but field seems to have wrong type.");
          //get the transform function
          if (mediaID == MediaID_finalTransform)
          {
            smpMedia = pComponent->GetTransformationFunction(pFieldRef->GetOrigin(),pFieldRef->GetLargestPossibleRegion(),pFieldRef->GetSpacing());
          }
          else
          {
            smpMedia = pComponent->GetInverseTransformationFunction(pFieldRef->GetOrigin(),pFieldRef->GetLargestPossibleRegion(),pFieldRef->GetSpacing());
          }
        }
      }
      catchAllNPassMacro("Unkown error while computing transormation function.");

      this->ActualizeMediaValidityTag(mediaID,pComponentCache);
    }
    return smpMedia;
  }

  return Superclass::GetMediaCasted(mediaID, pComponent, pComponentCache, pSessionInfo);
}; 


template <class ComponentType>
void
ClosedFormRegistrationControllerBase<ComponentType>::
SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia, ComponentType* pComponent, SessionComponentCache* pComponentCache,
               SessionInfo* pSessionInfo) const
{
  if (mediaID == MediaID_movingPointSet)
  {
    pComponent->SetMovingPointSet(dynamic_cast<typename ComponentType::PointSetType*>(pMedia));
    this->ActualizeMediaValidityTag(MediaID_movingPointSet,pComponentCache);
  }
        else if (mediaID == MediaID_fixedPointSet)
  {
    pComponent->SetFixedPointSet(dynamic_cast<typename ComponentType::PointSetType*>(pMedia));
    this->ActualizeMediaValidityTag(MediaID_fixedPointSet,pComponentCache);
  }
  else if (mediaID == MediaID_fieldReference)
  { //its a legal media, so prevent exception. But do nothing else, because the reference
    //will not be stored. Instead it will be linked directly in GetMediaCasted if needed.
  }
  else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
}; 

template <class ComponentType>
void
ClosedFormRegistrationControllerBase<ComponentType>::
ResetSubComponents(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
};

template <class ComponentType>
void
ClosedFormRegistrationControllerBase<ComponentType>::
ResetMainComponent(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
};

} //end of namespace free

#endif

---