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

namespace FREE
{




DefineParameterMacro(ExhaustiveSOOptimizerController,StepLength,"StepLength","Determines the basic step length of the optimizer along every search axis.");
DefineParameterMacro(ExhaustiveSOOptimizerController,NumberOfSteps,"NumberOfSteps","Number of steps to the left and to the right of the initial value along the search axis.");
DefineParameterMacro(ExhaustiveSOOptimizerController,ParameterAxis,"ParameterAxis","Indicates the search axis a parameter belongs to.");
DefineParameterMacro(ExhaustiveSOOptimizerController,LogarithmicAxis,"LogarithmicAxis","Indicates if the axis will be searched linear (flase) or logarithmic (true).");
DefineParameterMacro(ExhaustiveSOOptimizerController,MinimumIsBest,"MinimumIsBest","Indicates if the best result found by the search is the maximum finding or minimum.");


ExhaustiveSOOptimizerController::
ExhaustiveSOOptimizerController()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::ExhaustiveSOOptimizerController);
  this->m_Description = "Optimizes by an exhaustive search approach.";
};

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

        //Parameters
  profile.Parameters().AddParameter(cParam_StepLength,CtrlProfile::Parameter::PVTDouble,cParamDsc_StepLength,1,"1.0");
  profile.Parameters().AddParameter(cParam_NumberOfSteps,CtrlProfile::Parameter::PVTULong,cParamDsc_NumberOfSteps,1,"5");
  profile.Parameters().AddParameter(cParam_ParameterAxis,Parameter::PVTLong,cParamDsc_ParameterAxis,1,"-1");
  profile.Parameters().AddParameter(cParam_LogarithmicAxis,Parameter::PVTLong,cParamDsc_LogarithmicAxis,1,"0");
  profile.Parameters().AddParameter(cParam_MinimumIsBest,CtrlProfile::Parameter::PVTBool,cParamDsc_MinimumIsBest,1,"true");
};


long
ExhaustiveSOOptimizerController::
GetMaxIterationCount(const SessionComponentCache* pComponentCache, unsigned int iResolutionLevel) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("","Passed pComponentCache is NULL.");
        if (!pComponentCache->SetupIsAssigned()) throwCtrlExceptionMacro("","Cache has no setup assigned.");

  Parameter::Pointer smpParam = this->GetParameter(pComponentCache,std::string(cParam_StepLength));
  if (smpParam.IsNull()) throwCtrlExceptionMacro("","Error; missing parameter: "<< cParam_StepLength);

  long lResult = 1;
    
  for (unsigned int index = 0; index<smpParam->ParameterSize(); index++)
  {
    long lSteps;
                smpParam->GetParameterValue(lSteps,index);
    lResult *= lSteps;
  }

  return lResult;
};

void
ExhaustiveSOOptimizerController::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
        Superclass::ActualizeMainComponent(pMainComponent, pComponentCache,
                                                                                                                                                 pSessionInfo, iActLevel);

        double dStepLength;
        bool bMinIsBest;
  ComponentType::StepsType numberOfSteps;
  ComponentType::ParameterAxisType parameterAxis;
  ComponentType::AxisTypeType logAxis;

  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_StepLength,dStepLength);
    SessionAccessor::GetParameterValue(pComponentCache,cParam_MinimumIsBest,bMinIsBest);
  }
  catchAllNPassMacro("Error while retrieving parameter values.");    

  Parameter::Pointer smpParameter = SessionAccessor::GetParameter(pComponentCache,cParam_NumberOfSteps);
  if (smpParameter.IsNull()) throwExceptionMacro("Missing parameter: " << cParam_NumberOfSteps);
        numberOfSteps = Convert::ParameterLayerToArray<ComponentType::StepsType>(*(smpParameter->GetParameterLayer(0)));

  smpParameter = SessionAccessor::GetParameter(pComponentCache,cParam_ParameterAxis);
  if (smpParameter.IsNull()) throwExceptionMacro("Missing parameter: " << cParam_ParameterAxis);
        parameterAxis = Convert::ParameterLayerToArray<ComponentType::ParameterAxisType>(*(smpParameter->GetParameterLayer(0)));

  smpParameter = SessionAccessor::GetParameter(pComponentCache,cParam_LogarithmicAxis);
  if (smpParameter.IsNull()) throwExceptionMacro("Missing parameter: " << cParam_LogarithmicAxis);
        logAxis = Convert::ParameterLayerToArray<ComponentType::AxisTypeType>(*(smpParameter->GetParameterLayer(0)));

  ComponentSetup* pTransformSetup = pComponentCache->Setup()->GetComponentByIDPath("../"+ComponentID(cComp_MainTransform));
  if (!pTransformSetup) throwCtrlExceptionMacro("","No main transform setup found to gather parameter scales");
  TransformSetupAdaptor adaptor(pTransformSetup);

  pMainComponent->SetStepLength(dStepLength);
        pMainComponent->SetInitialPosition( adaptor.GetInitialTransformParameters() );
  pMainComponent->SetNumberOfSteps(numberOfSteps);
  pMainComponent->SetParameterAxis(parameterAxis);
  pMainComponent->SetAxisType(logAxis);
        pMainComponent->SetMinimumIsBest(bMinIsBest);
};

void
ExhaustiveSOOptimizerController::
SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
{
  ParameterArrayType parameters = pMainComponent->GetCurrentPosition();

  std::string sName = "Position #";
  std::string sIDPath = pMainComponentCache->GetIDPath();
  std::string sCommment = "Optimizer position. Meaning depends on chosen transformation";
  StatisticValueDefinition* pEntry = rDictionary.GetValueDefinitionByName(sIDPath,sName+"0");
    
  if (!pEntry) //Entry is not recorded yet, so do so.
  {
    std::string sName = "Position #";
    pEntry = rDictionary.AddValueDefinition(sIDPath,sName+"0", sCommment);
    for (unsigned int i = 1; i<parameters.Size(); i++)
    {
      rDictionary.AddValueDefinition(sIDPath,sName+Convert::ToStr(i),sCommment);
    }

    rDictionary.AddValueDefinition(sIDPath,"OptimizerValue", "Composed value of the optimizer");
  }
  
  for (unsigned int i = 0; i<parameters.Size(); i++)
  {
    rStatisticEntry.AddValue(Convert::ToStr(parameters.GetElement(i)),pEntry->GetRefID()+i);
  }

  rStatisticEntry.AddValue(Convert::ToStr(pMainComponent->GetCurrentValue()),pEntry->GetRefID()+parameters.Size());
};

} //end of namespace free

---