freDemonRegistrationController.h

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: freDemonRegistrationController.h,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 __freDemonRegistrationController_h
#define __freDemonRegistrationController_h

#include "freRegistrationProcessorControllerBase.h"
#include "freInterpolatorControllerBase.h"
#include "freDemonRegistrationProcessor.h"

#include "freIntensityImageMediaController.h"
#include "freTransformFieldMediaController.h"

namespace FREE
{
  freControllerIDMacro(DemonRegistrationControllerBase, "DemonRegistrationBase");
template < class TControlledDemonProcessor >
class DemonRegistrationControllerBase : public RegistrationProcessorControllerBase<TControlledDemonProcessor>
{
public:  
  typedef TControlledDemonProcessor ComponentType;
  typedef RegistrationProcessorControllerBase<ComponentType> Superclass;
  typedef typename Superclass::GenericComponentType GenericComponentType;
  typedef typename Superclass::GenericComponentPointer GenericComponentPointer;
  typedef typename Superclass::GenericMediaPointer GenericMediaPointer;

  itkTypeMacro(DemonRegistrationControllerBase, RegistrationProcessorControllerBase);

  virtual ValidityTag::Pointer GetMediaValidityTagRequirement(const MediaID& mediaID,
                                                              SessionComponentCache* pComponentCache) const
  {
    if (mediaID == "finalField")
    {
      ValidityTag::Pointer smpReq = ValidityTag::New(this->GetMediaValidityTagRequirement(mediaID,pComponentCache)->GetTimeStamp());

      //check moving image 
      ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement("movingImage");
      if (smpLink.IsNotNull())
      {
        ValidityTag::Pointer smpImageReq = SessionAccessor::GetValidityTagRequirement(smpLink->GetSourceIDPath(),pComponentCache);
        if (smpReq->IsOutdated(smpImageReq))
        { //movingImage is newer then result so there is a requirement.
          smpReq->SetTag(smpImageReq);
        }
      }
      //check fixed image 
      smpLink = pComponentCache->Setup()->MediaLinks().GetElement("fixedImage");
      if (smpLink.IsNotNull())
      {
        ValidityTag::Pointer smpImageReq = SessionAccessor::GetValidityTagRequirement(smpLink->GetSourceIDPath(),pComponentCache);
        if (smpReq->IsOutdated(smpImageReq))
        { //fixedImage is newer then result so there is a requirement.
          smpReq->SetTag(smpImageReq);
        }
      }
      return smpReq;
    }

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

protected:
  DemonRegistrationControllerBase():Superclass()
  {     
    //Profile settings
    this->UpdateControllerID(ControllerID::DemonRegistrationControllerBase);
    this->m_Description = "Realizes a demon based registration.";
  };

  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                               const SessionComponentCache* pComponentCache,
                               bool bRegardOldSetup) const
  {
    Superclass::GenerateProfile(profile,pComponentCache,bRegardOldSetup);

    //Parameters
    profile.Parameters().AddParameter(cParam_Iterations,Parameter::PVTInteger,cParamDsc_Iterations,1,"10");
    profile.Parameters().AddParameter(cParam_StdDev,CtrlProfile::Parameter::PVTDouble,cParamDsc_StdDev,1,"1.0");
    profile.Parameters().AddParameter(cParam_HistoMatch,Parameter::PVTBool,cParamDsc_HistoMatch,1,"false");
    profile.Parameters().AddParameter(cParam_HistoLevels,Parameter::PVTLong,cParamDsc_HistoLevels,1,"1024");
    profile.Parameters().AddParameter(cParam_HistoMatchPoints,Parameter::PVTLong,cParamDsc_HistoMatchPoints,1,"5");
    profile.Parameters().AddParameter(cParam_HistoThreshold,Parameter::PVTBool,cParamDsc_HistoThreshold,1,"1");

                //Media
                std::string sImageControllerID = ControllerID::IntensityImage2DMediaController;
                if (ComponentType::ImageDimension == 3) sImageControllerID = ControllerID::IntensityImage3DMediaController;
                profile.MediaMap().AddMedia("movingImage",sImageControllerID,DASet,ComponentType::ImageDimension);
                profile.MediaMap().AddMedia("fixedImage",sImageControllerID,DASet,ComponentType::ImageDimension);
          
                std::string sTransformControllerID = ControllerID::TransformField2DMediaController;
                if (ComponentType::ImageDimension == 3) sTransformControllerID = ControllerID::TransformField3DMediaController;
                profile.MediaMap().AddMedia("finalField",sTransformControllerID,DAGet,ComponentType::ImageDimension);

    //Subcomponents
    profile.SubComponents().AddSubComponent(cComp_MainInterpolator,1,csUndefinedController,cCompDsc_MainInterpolator);

    //requirements
                CtrlProfile::ProfileOption* pOption;
                  //interpolator
                pOption = profile.Requirements().AddRequirement(cComp_MainInterpolator)->AddProfileOption();
                pOption->Inheritance().AddAncestor(ControllerID::InterpolatorControllerBase);
    pOption->MediaMap().AddMedia("inputImage",sImageControllerID,DASet,ComponentType::ImageDimension,0,true);
                pOption->CheckForInheritance();
                pOption->CheckForIO();
  };

  virtual GenericComponentType* GetSubComponentCasted(ComponentType* pMainComponent, const ComponentID& compID,
                                                      SessionComponentCache* pMainComponentCache) const
  {
          if (compID == cComp_MainInterpolator) return pMainComponent->smpInterpolate.GetPointer();

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

  virtual void SetSubComponentCasted(GenericComponentType* pSubComponent, ComponentType* pMainComponent,
                               const ComponentID compID, SessionComponentCache* pMainComponentCache) const
  {
          if (compID == cComp_MainInterpolator) pMainComponent->smpInterpolate = dynamic_cast<typename ComponentType::InterpolateType*>(pSubComponent);
          else Superclass::SetSubComponentCasted(pSubComponent, pMainComponent, compID, pMainComponentCache);
  };


  virtual GenericMediaPointer GetMediaCasted(const MediaID& mediaID,
                                                                                                                                                                                                 ComponentType* pComponent,
                                                                                                                                                                                                 SessionComponentCache* pComponentCache,
                                                 SessionInfo* pSessionInfo) const
        {
                GenericMediaPointer smpMedia;
                if (mediaID == "movingImage") return GenericMediaPointer(pComponent->GetMovingImage());
                if (mediaID == "fixedImage") return GenericMediaPointer(pComponent->GetFixedImage());
                if (mediaID == "finalField")
    { //Both are based on the registration so check first if registration needed
      ValidityTag::Pointer smpValField = this->GetMediaValidityTag(mediaID,pComponentCache);
      ValidityTag::Pointer smpValReqField = this->GetMediaValidityTagRequirement(mediaID,pComponentCache);

      if (smpValField->IsOutdated(smpValReqField))
      { //registration is outdated -> compute new segmentation
        SessionBuilder::ActualizeComponent(pComponentCache, pSessionInfo);
        SessionBuilder::LinkMediaToComponent(pComponentCache, pSessionInfo);

        pComponent->StartRegistration();

        this->ActualizeMediaValidityTag("finalImage",pComponentCache);
        this->ActualizeMediaValidityTag("finalField",pComponentCache);
      }

      smpMedia = pComponent->GetTransformationField();

      return smpMedia;
    }
      
                return Superclass::GetMediaCasted(mediaID, pComponent, pComponentCache, pSessionInfo);
        }; 
  
        virtual void SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia,
                                                                                                                        ComponentType* pComponent, SessionComponentCache* pComponentCache,
                              SessionInfo* pSessionInfo) const
        {
                if (mediaID == "movingImage")
    {
      pComponent->SetMovingImage(dynamic_cast<typename ComponentType::ImageType*>(pMedia));
      this->ActualizeMediaValidityTag("movingImage",pComponentCache);
    }
                else if (mediaID == "fixedImage")
    {
      pComponent->SetFixedImage(dynamic_cast<typename ComponentType::ImageType*>(pMedia));
      this->ActualizeMediaValidityTag("fixedImage",pComponentCache);
    }
                else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
        }; 

};

  freControllerIDMacro(Demon2DRegistrationController, "Demon Registration 2D");
class Demon2DRegistrationController : public DemonRegistrationControllerBase<DemonRegistrationProcessor2D>
{
public:  
  typedef DemonRegistrationProcessor2D ComponentType;
  typedef DemonRegistrationControllerBase<ComponentType> Superclass;

  itkTypeMacro(Demon2DRegistrationController, DemonRegistrationControllerBase);

  Demon2DRegistrationController();
};

  freControllerIDMacro(Demon3DRegistrationController, "Demon Registration 3D");
class Demon3DRegistrationController : public DemonRegistrationControllerBase<DemonRegistrationProcessor3D>
{
public:  
  typedef DemonRegistrationProcessor3D ComponentType;
  typedef DemonRegistrationControllerBase<ComponentType> Superclass;

  itkTypeMacro(Demon3DRegistrationController, DemonRegistrationControllerBase);

  Demon3DRegistrationController();
};

} //end of namespace free

#endif

---