freSetupOptimizationProcessorController.cxx

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: freSetupOptimizationProcessorController.cxx,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.

=========================================================================*/
#include "freSetupOptimizationProcessorController.h"

#include "freSetupOptimizationMetricControllerBase.h"
#include "freSetupOptimizationOptimizerControllerBase.h"
#include "freSetupTransformController.h"

namespace FREE
{




DefineParameterMacro(SetupOptimizationProcessorController,Setup,"Setup","Path to the setup that should be optimized. If a path is set, setup will be loaded automatically.");
DefineParameterMacro(SetupOptimizationProcessorController,AdaptationList,"AdaptationList","Path to the adaptation list used as test basis for the optimization process. If a path is set, adaptation list will be loaded automatically.");

SetupOptimizationProcessorController::
SetupOptimizationProcessorController() : ComponentControllerBase<ComponentType>()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::SetupOptimizationProcessorController);
  this->m_Description = "Class processing a setup optimization.";
};

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

  //Parameters
        profile.Parameters().AddParameter(cParam_Setup,Parameter::PVTURI,cParamDsc_Setup,1,"");
  profile.Parameters().AddParameter(cParam_AdaptationList,Parameter::PVTURI,cParamDsc_AdaptationList,1,"");

  //Subcomponents
  profile.SubComponents().AddSubComponent(cComp_MainMetric);
  profile.SubComponents().AddSubComponent(cComp_MainTransform);
  profile.SubComponents().AddSubComponent(cComp_MainOptimizer);

  //Requirements
        CtrlProfile::ProfileOption* pOption;
    //metric
        pOption = profile.Requirements().AddRequirement(cComp_MainMetric)->AddProfileOption();
        pOption->Inheritance().AddAncestor(ControllerID::SetupOptimizationMetricControllerBase);
        pOption->CheckForInheritance();
    //transform
        pOption = profile.Requirements().AddRequirement(cComp_MainTransform)->AddProfileOption();
        pOption->Inheritance().AddAncestor(ControllerID::SetupTransformControllerBase);
        pOption->CheckForInheritance();
    //transform
        pOption = profile.Requirements().AddRequirement(cComp_MainOptimizer)->AddProfileOption();
        pOption->Inheritance().AddAncestor(ControllerID::SetupOptimizationOptimizerControllerBase);
        pOption->CheckForInheritance();
};

SetupOptimizationProcessorController::GenericComponentType* 
SetupOptimizationProcessorController::
GetSubComponentCasted(ComponentType* pMainComponent, const ComponentID& compID,
                      SessionComponentCache* pMainComponentCache) const
{
        if (compID == cComp_MainMetric) return pMainComponent->GetMetric();
        if (compID == cComp_MainTransform) return pMainComponent->GetTransform();
        if (compID == cComp_MainOptimizer) return pMainComponent->GetOptimizer();

        return ComponentControllerBase<ComponentType>::GetSubComponentCasted(pMainComponent, compID, pMainComponentCache);
}; 

void
SetupOptimizationProcessorController::
SetSubComponentCasted(GenericComponentType* pSubComponent, ComponentType* pMainComponent,
                      const ComponentID compID, SessionComponentCache* pMainComponentCache) const
{
  if (compID == cComp_MainMetric) pMainComponent->SetMetric(static_cast<SetupOptimizationMetric*>(pSubComponent));
  else if (compID == cComp_MainTransform) pMainComponent->SetTransform(static_cast<SetupTransform*>(pSubComponent));
  else if (compID == cComp_MainOptimizer) pMainComponent->SetOptimizer(static_cast<SetupOptimizationOptimizer*>(pSubComponent));
  else ComponentControllerBase<ComponentType>::SetSubComponentCasted(pSubComponent, pMainComponent, compID, pMainComponentCache);
}; 

void
SetupOptimizationProcessorController::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
        std::string sSetupFile;
        std::string sAdaptationsFile;

  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_Setup,sSetupFile);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_AdaptationList,sAdaptationsFile);
  }
  catchAllNPassMacro("Error while retrieving parameter values.");

  Setup::Pointer smpSetup = Setup::New();

        if (!sSetupFile.empty())
        {
                try
                {
                        smpSetup->LoadFromFile(sSetupFile);
                }
                catchAllNPassMacro("Unkown error while loading setup for setup optimization processor.");

                pMainComponent->SetSetup(smpSetup); //also passes the setup to the transform if yet defined.
        }

  Adaptation::AdaptationList::Pointer smpAdaptations = Adaptation::AdaptationList::New();

        if (!sAdaptationsFile.empty())
        {
                try
                {
                        smpAdaptations->LoadFromFile(sAdaptationsFile);
                }
                catchAllNPassMacro("Unkown error while loading adaptation list for setup optimization processor.");

                pMainComponent->SetAdaptationList(smpAdaptations);
        }
};

void
SetupOptimizationProcessorController::
BuildFinalization(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Error: component cache is invalid (NULL), cannot finalize the building process.");
  if (!pComponentCache->ComponentIsAssigned()) throwCtrlExceptionMacro("","Error: component is missing, cannot finalize the building process.");

  ComponentType* pMainComponent = dynamic_cast<ComponentType*>(pComponentCache->Component().GetPointer());

  if (!pMainComponent) throwCtrlExceptionMacro("","Error: wrong main component type, cannot finalize the building process.");

  //plug all subcomponents together to achive proper functionality before the call of pMainComponent->StartOptimization.
  //this is needed for the proper use of the optimizer guess functionality in this->ActualizeMainComponent.
  pMainComponent->GetMetric()->SetTransform(pMainComponent->GetTransform());
  pMainComponent->GetMetric()->SetAdaptationList(pMainComponent->GetAdaptationList());

  pMainComponent->GetOptimizer()->SetCostFunction(pMainComponent->GetMetric());
};

void
SetupOptimizationProcessorController::
SetStatisticEntrySubComponents(StatisticEntry& rStatisticEntry, SessionComponentCache* pComponentCache,
                              SessionInfo* pSessionInfo, StatisticDictionary& rDictionary) const
{
  for (unsigned int index=0; index<pComponentCache->SubCaches().Size(); index++)
  {
    try
    {
      SessionComponentCache* pSubCache = (pComponentCache->SubCaches()).GetElement(index);

      if (!pSubCache) throwCtrlExceptionMacro("","Error cannot set sub components. Sub cache is present but Null. IDPath: "<<pComponentCache->GetIDPath().ToStr()<<"; sub cache index: "<<index);

      StatisticEntry::Pointer smpSubEntry = rStatisticEntry.CreateChildEntry();

      StatisticEntryDefinition* pSubEntryDef = rDictionary.GetEntryDefinitionByName(pSubCache->GetIDPath(),pSubCache->GetComponentID());
      if (!pSubEntryDef)
      {
        pSubEntryDef = rDictionary.AddEntryDefinition(pSubCache->GetIDPath(),pSubCache->GetComponentID(),pSubCache->GetControllerID(),"sub component information");
      }

      smpSubEntry->SetRefID(pSubEntryDef->GetRefID());

      SessionBuilder::SetStatisticEntry(*smpSubEntry, pSubCache, pSessionInfo);
    }
    catchAllNPassMacro("Error while setting step statistic of subcomponent.");
  }
};

} //end of namespace free

---