frePowellOptimizerController.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: frePowellOptimizerController.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 "frePowellOptimizerController.h"
#include "freExceptions.h"

namespace FREE
{




DefineParameterMacro(PowellOptimizerController,MaximumLineIteration,"MaximumLineIteration","Maximum number of line search iterations.");
DefineParameterMacro(PowellOptimizerController,StepLength,"StepLength","StepLength for the (scaled) spacing of the sampling of parameter space while bracketing the extremum");
DefineParameterMacro(PowellOptimizerController,StepTolerance,"StepTolerance","Once the local extreme is known to be within this distance of the current parameter values, optimization terminates.");
DefineParameterMacro(PowellOptimizerController,ValueTolerance,"ValueTolerance","Once this current cost function value is known to be within this tolerance of the cost function value at the local extreme, optimization terminates.");

PowellOptimizerController::
PowellOptimizerController()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::PowellOptimizerController);
  this->m_Description = "Optimizes by using a Powell optimizer with Brent line search.";
};

void
PowellOptimizerController::
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,"100",-1,true);
  profile.Parameters().AddParameter(cParam_MaximumLineIteration,Parameter::PVTInteger,cParamDsc_MaximumLineIteration,1,"100",-1,true);
  profile.Parameters().AddParameter(cParam_StepLength,Parameter::PVTDouble,cParamDsc_StepLength,1,"1.0",-1,true);
  profile.Parameters().AddParameter(cParam_StepTolerance,Parameter::PVTDouble,cParamDsc_StepTolerance,1,"0.00001",-1,true);
  profile.Parameters().AddParameter(cParam_ValueTolerance,Parameter::PVTDouble,cParamDsc_ValueTolerance,1,"0.00001",-1,true);
};

void
PowellOptimizerController::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
  double dValueTolerance;
  double dStepTolerance;
  double dStepLength;
  int iNrOfIterations;
  int iLineIteration;

  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_MaximumLineIteration,iLineIteration,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_StepLength,dStepLength,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_StepTolerance,dStepTolerance,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_ValueTolerance,dValueTolerance,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_Iterations,iNrOfIterations,0,iActLevel,true);
  }
  catchAllNPassMacro("Error while retrieving parameter values.");

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

  pMainComponent->SetMaximumIteration(iNrOfIterations);
  pMainComponent->SetMaximumLineIteration(iLineIteration);
  pMainComponent->SetStepLength(dStepLength);
  pMainComponent->SetStepTolerance(dStepTolerance);
  pMainComponent->SetValueTolerance(dValueTolerance);

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

void
PowellOptimizerController::
SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
{
  Superclass::SetStatisticEntryMainComponent(rStatisticEntry,pMainComponent,
                                            pMainComponentCache,pSessionInfo,
                                            rDictionary);

  std::string sName = "GlobalIterationID";
  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, "Nr / ID of the global search.");
    rDictionary.AddValueDefinition(sIDPath,"LineIterationID", "Nr / ID of the line search iteration.");
    rDictionary.AddValueDefinition(sIDPath,"OptimizerValue", "Composed value of the current optimizer position");
  }
  
  rStatisticEntry.AddValue(Convert::ToStr(pMainComponent->GetCurrentIteration()),pEntry->GetRefID());
  rStatisticEntry.AddValue(Convert::ToStr(pMainComponent->GetCurrentLineIteration()),pEntry->GetRefID()+1);
  rStatisticEntry.AddValue(Convert::ToStr(pMainComponent->GetCurrentCost()),pEntry->GetRefID()+2);
};

PowellOptimizerController::MeasuresType
PowellOptimizerController::
GetCurrentValue(ComponentType* pOptimizer) const
{
        MeasuresType values(1);
        values.Fill(pOptimizer->GetValue());
        return values;
};

} //end of namespace free

---