freMVNonLinearVNLOptimizerControllerBase.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: freMVNonLinearVNLOptimizerControllerBase.txx,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 __freMVNonLinearVNLOptimizerControllerBase_txx
#define __freMVNonLinearVNLOptimizerControllerBase_txx

#include "freMVNonLinearVNLOptimizerControllerBase.h"

namespace FREE
{

template <class TControlledVNLOptimizer>
const char* const
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::cParam_UseCostFunctionGradient = "UseCostFunctionGradient";

template <class TControlledVNLOptimizer>
const char* const
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::cParamDsc_UseCostFunctionGradient = "Indicates if the gradient of the cost function should be used";

template <class TControlledVNLOptimizer>
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::
MVNonLinearVNLOptimizerControllerBase()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::MVNonLinearVNLOptimizerControllerBase);
  this->m_Description = "Base controller for multiple valued vnl optimizers.";
};

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

  //Parameter
  profile.Parameters().AddParameter(cParam_UseCostFunctionGradient,CtrlProfile::Parameter::PVTBool,cParamDsc_UseCostFunctionGradient,1,"false");
};

template <class TControlledVNLOptimizer>
void
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::
SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
{
  ParameterArrayType parameters = pMainComponent->GetCachedCurrentPosition();
  MeasuresType measure = pMainComponent->GetCachedValue();

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

  if (!pValueEntry) //Entry is not recorded yet, so do so.
  {
    pValueEntry = rDictionary.AddValueDefinition(sIDPath,"OptimizerValue #0", "Current optimizer value; meaning depends on chosen metric");
    for (unsigned int i = 1; i<measure.Size(); i++)
    {
      rDictionary.AddValueDefinition(sIDPath,"OptimizerValue #"+Convert::ToStr(i),"Current optimizer value; meaning depends on chosen metric");
    }
  }
  
  for (unsigned int i = 0; i<parameters.Size(); i++)
  {
    rStatisticEntry.AddValue(Convert::ToStr(parameters.GetElement(i)),pParamEntry->GetRefID()+i);
  }

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

template <class TControlledVNLOptimizer>
typename MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::ParametersType
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::
GetCurrentPosition(TControlledVNLOptimizer* pOptimizer) const
{
        return pOptimizer->GetCachedCurrentPosition();
};

template <class TControlledVNLOptimizer>
typename MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::MeasuresType
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::
GetCurrentValue(TControlledVNLOptimizer* pOptimizer) const
{
        return pOptimizer->GetCachedValue();
};

template <class TControlledVNLOptimizer>
void
MVNonLinearVNLOptimizerControllerBase<TControlledVNLOptimizer>::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
  Superclass::ActualizeMainComponent(pMainComponent, pComponentCache, pSessionInfo, iActLevel);

  bool bUseCostGradient = true;

  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_UseCostFunctionGradient,bUseCostGradient);
  }
  catchAllNPassMacro("Error while retrieving parameter values.");

  pMainComponent->SetUseCostFunctionGradient(bUseCostGradient);
};

} //end of namespace FREE

#endif

---