freRegStepGradDescOptimizerControllerBase.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: freRegStepGradDescOptimizerControllerBase.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.

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

#ifndef __freRegStepGradDescOptimizerControllerBase_txx
#define __freRegStepGradDescOptimizerControllerBase_txx

#include "freRegStepGradDescOptimizerControllerBase.h"
#include "freExceptions.h"

namespace FREE
{


template <class TOptimizer>
const char* const RegStepGradDescOptimizerControllerBase<TOptimizer>::cParam_RelaxationFactor = "RelaxationFactor";
template <class TOptimizer>
const char* const RegStepGradDescOptimizerControllerBase<TOptimizer>::cParamDsc_RelaxationFactor = "Factor of relaxation, when optimizer changes direction.";

template <class TOptimizer>
RegStepGradDescOptimizerControllerBase<TOptimizer>::
RegStepGradDescOptimizerControllerBase()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::RegStepGradDescOptimizerControllerBase);
  this->m_Description = "Base class for a regular step gradient descent approach.";
};

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

        //Parameters
  profile.Parameters().AddParameter(cParam_DynamicLevelStepLength,Parameter::PVTBool,cParamDsc_DynamicLevelStepLength,1,"true",-1,true);
  profile.Parameters().AddParameter(cParam_MaxStepLength,CtrlProfile::Parameter::PVTDouble,cParamDsc_MaxStepLength,1,"1.0",-1,true);
  profile.Parameters().AddParameter(cParam_MinStepLength,CtrlProfile::Parameter::PVTDouble,cParamDsc_MinStepLength,1,"0.01",-1,true);
  profile.Parameters().AddParameter(cParam_Iterations,Parameter::PVTULong,cParamDsc_Iterations,1,"100",-1,true);
  profile.Parameters().AddParameter(cParam_GradMagTolerance,CtrlProfile::Parameter::PVTDouble,cParamDsc_GradMagTolerance,1,"0.0001");
  profile.Parameters().AddParameter(cParam_RelaxationFactor,CtrlProfile::Parameter::PVTDouble,cParamDsc_RelaxationFactor,1,"0.5");

};

template <class TOptimizer>
void
RegStepGradDescOptimizerControllerBase<TOptimizer>::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
  double dMaxStepLength = 0;
  double dRelaxationFactor;
  double dMinStepLength;
  unsigned long lNrOfIterations;
  double dGradMagTolerance;
  bool bDynamicLevelStepLength;

  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_Iterations,lNrOfIterations,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_DynamicLevelStepLength,bDynamicLevelStepLength,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_MinStepLength,dMinStepLength,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_GradMagTolerance,dGradMagTolerance,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_RelaxationFactor,dRelaxationFactor,0,iActLevel,true);
          if ((iActLevel!=0)&(bDynamicLevelStepLength))
          {
                  dMaxStepLength = pMainComponent->GetCurrentStepLength();
          }
          else
          {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_MaxStepLength,dMaxStepLength,0,iActLevel,true);
          }
  }
  catchAllNPassMacro("Error while retrieving parameter values.");

  ParameterArrayType scales = this->GetTransformScales(pComponentCache,iActLevel);
  pMainComponent->SetScales(scales);

  Parameter::Pointer smpDirection = pComponentCache->GetParentCache()->Controller()->GetParameter(pComponentCache->GetParentCache(),OptimizerOwnerControllerInterface::cParam_MinimizeToOptimize);
  if (smpDirection.IsNull()) throwCtrlExceptionMacro("","Cannot retrieve optimization direction via optimizer owner. Parameter \"MinimizeToOptimize\" is unknown. Please ensure valid session and setup");
  bool bMinimize;
  smpDirection->GetParameterValue(bMinimize);
  pMainComponent->SetMaximize( !bMinimize);

  pMainComponent->SetNumberOfIterations(lNrOfIterations);
  pMainComponent->SetGradientMagnitudeTolerance(dGradMagTolerance);
  pMainComponent->SetMinimumStepLength(dMinStepLength);
        pMainComponent->SetRelaxationFactor(dRelaxationFactor);
  pMainComponent->SetMaximumStepLength(dMaxStepLength); 
};

template <class TOptimizer>
void
RegStepGradDescOptimizerControllerBase<TOptimizer>::
SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
{
  Superclass::SetStatisticEntryMainComponent(rStatisticEntry,pMainComponent,
                                            pMainComponentCache,pSessionInfo,
                                            rDictionary);
  
  std::string sName = "OptimizerValue";
  std::string sIDPath = pMainComponentCache->GetIDPath();
  StatisticValueDefinition* pEntry = rDictionary.GetValueDefinitionByName(sIDPath, sName);
    
  if (!pEntry) //Entry is not recorded yet, so do so.
  {
    pEntry = rDictionary.AddValueDefinition(sIDPath, sName, "Value of the Optimizer");
  }

  rStatisticEntry.AddValue(Convert::ToStr(pMainComponent->GetValue()),pEntry->GetRefID());
};

} //end of namespace free

#endif

---