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

namespace FREE
{


DefineParameterMacro(ContinuousLBFGSOptimizerController,GradConvTolerance,"GradConvTolerance","Treshold for the accuracy with which the solution is to be found.");
DefineParameterMacro(ContinuousLBFGSOptimizerController,LineSearchAccuracy,"LineSearchAccuracy","Accuracy of the line search.");
DefineParameterMacro(ContinuousLBFGSOptimizerController,DefaultStepLength,"DefaultStepLength","Step size for the line search.");
DefineParameterMacro(ContinuousLBFGSOptimizerController,TraceOn,"TraceOn","Optimizer should print his progress.");

ContinuousLBFGSOptimizerController::
ContinuousLBFGSOptimizerController()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::ContinuousLBFGSOptimizerController);
  this->m_Description = "Optimizes by an amoeba optimizer approach.";
};

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

        //Parameters
  profile.Parameters().AddParameter(cParam_GradConvTolerance,CtrlProfile::Parameter::PVTDouble,cParamDsc_GradConvTolerance,1,"1.0",-1,true);
  profile.Parameters().AddParameter(cParam_LineSearchAccuracy,CtrlProfile::Parameter::PVTDouble,cParamDsc_LineSearchAccuracy,1,"0.9",-1,true);
  profile.Parameters().AddParameter(cParam_DefaultStepLength,CtrlProfile::Parameter::PVTDouble,cParamDsc_DefaultStepLength,1,"1.0",-1,true);
  profile.Parameters().AddParameter(cParam_TraceOn,CtrlProfile::Parameter::PVTBool,cParamDsc_TraceOn,1,"true");
  profile.Parameters().AddParameter(cParam_Iterations,Parameter::PVTInteger,cParamDsc_Iterations,1,"100",-1,true);
};

void
ContinuousLBFGSOptimizerController::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
  double dGradConvTolerance;
  double dLineSearchAcc;
  double dDefStepLength;
  int iNrOfIterations;
  bool bTraceOn;

  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_GradConvTolerance,dGradConvTolerance,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_LineSearchAccuracy,dLineSearchAcc,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_DefaultStepLength,dDefStepLength,0,iActLevel,true);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_TraceOn,bTraceOn);
    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->SetDefaultStepLength(dDefStepLength);
  pMainComponent->SetGradientConvergenceTolerance(dGradConvTolerance);
  pMainComponent->SetLineSearchAccuracy (dLineSearchAcc);
  pMainComponent->SetMaximumNumberOfFunctionEvaluations(iNrOfIterations);
  pMainComponent->SetTrace(bTraceOn);

  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
ContinuousLBFGSOptimizerController::
SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
{
  StatisticValueDefinition* pEntry = 0;
  std::string sIDPath = pMainComponentCache->GetIDPath();

  if (pMainComponent->GetTrace())
  {
    ParameterArrayType parameters = pMainComponent->GetCachedCurrentPosition();
    std::string sName = "Position #";
    std::string sCommment = "Optimizer position. Meaning depends on chosen transformation";
    
    pEntry = rDictionary.GetValueDefinitionByName(sIDPath,sName+"0");

    if (!pEntry)
    {
      pEntry = rDictionary.AddValueDefinition(sIDPath,sName+"0", sCommment);
      for (unsigned int i = 1; i<parameters.Size(); i++)
      {
        rDictionary.AddValueDefinition(sIDPath,sName+Convert::ToStr(i),sCommment);
      }
    }

    for (unsigned int i = 0; i<parameters.Size(); i++)
    {
      rStatisticEntry.AddValue(Convert::ToStr(parameters.GetElement(i)),pEntry->GetRefID()+i);
    }
  }

  pEntry = rDictionary.GetValueDefinitionByName(sIDPath,"OptimizerValue");
  if (!pEntry) //Entry is not recorded yet, so do so.
  {
    pEntry = rDictionary.AddValueDefinition(sIDPath,"OptimizerValue", "Value of the optimizer");
  }
  rStatisticEntry.AddValue(Convert::ToStr(pMainComponent->GetCachedValue()),pEntry->GetRefID());
};

} //end of namespace free

---