freLimitedAxisAmoebaSOOptimizer.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: freLimitedAxisAmoebaSOOptimizer.h,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 "freLimitedAxisAmoebaSOOptimizer.h"
#include "itkCommand.h"
#include "itkEventObject.h"

namespace FREE
{

LimitedAxisAmoebaSOOptimizer
::LimitedAxisAmoebaSOOptimizer()
{
        m_InitialSimplexDelta.SetSize(1);
  m_ParameterAxis.Fill(-1); //Axis index equals parameter index.
        m_NumberOfAxis = 0;
}

void
LimitedAxisAmoebaSOOptimizer
::PrintSelf(std::ostream& os, itk::Indent indent) const
{
  Superclass::PrintSelf(os,indent);

  os << indent << "NumberOfAxis: "
     << m_NumberOfAxis << std::endl;
  os << indent << "ParameterAxis: "
     << m_ParameterAxis << std::endl;
}

LimitedAxisAmoebaSOOptimizer::MeasureType
LimitedAxisAmoebaSOOptimizer
::GetValue (const ParametersType &parameters)
{
        //translate 
  ParametersType scaledParameters = parameters;
  if(m_ScalesInitialized)
  {
    const ScalesType scales = this->GetScales();
    for(unsigned int i=0;i<parameters.size();i++)
    {
      scaledParameters[i] *= scales[i]; 
    }
  }
  return this->GetNonConstCostFunctionAdaptor()->f( scaledParameters );
};

LimitedAxisAmoebaSOOptimizer::DecomposedMeasureType
LimitedAxisAmoebaSOOptimizer
::GetDecomposedValue (const ParametersType &parameters)
{
        this->GetValue(parameters);
        return this->GetNonConstCostFunctionAdaptor()->GetCachedDecomposedValue();
};

void
LimitedAxisAmoebaSOOptimizer::
SetCostFunction( CostFunctionType * costFunction )
{
        const unsigned int numberOfParameters = 
                costFunction->GetNumberOfParameters();

        CostFunctionAdaptorType * adaptor = 
                new CostFunctionAdaptorType( numberOfParameters, m_NumberOfAxis );

        this->m_CostFunction = costFunction;
        adaptor->SetCostFunction( costFunction );

        if( m_OptimizerInitialized )
        { 
                delete m_VnlOptimizer;
        }

        this->SetCostFunctionAdaptor( adaptor );

        m_VnlOptimizer = new vnl_amoeba( *adaptor );

        // set up optimizer parameters
        m_VnlOptimizer->set_max_iterations( static_cast<int>( m_MaximumNumberOfIterations ) );
        m_VnlOptimizer->set_x_tolerance( m_ParametersConvergenceTolerance );
        m_VnlOptimizer->set_f_tolerance( m_FunctionConvergenceTolerance );

        m_OptimizerInitialized = true;
}

void
LimitedAxisAmoebaSOOptimizer
::StartOptimization( void )
{
    
        this->InvokeEvent( itk::StartEvent() );

        CostFunctionAdaptorType* pCostFunctionAdaptor = static_cast<CostFunctionAdaptorType*>(this->GetCostFunctionAdaptor());

        if( this->GetMaximize() )
    {
    pCostFunctionAdaptor->NegateCostFunctionOn();
    }

  ParametersType originPosition = this->GetInitialPosition();

  InternalParametersType internalParameters( m_NumberOfAxis );
        internalParameters.fill(0.0); //The limited axis optimization always starts at axis origins

        ScalesType scales(this->GetCostFunction()->GetNumberOfParameters());
        scales.Fill(1.0);
  if(m_ScalesInitialized)
    {
    scales = this->GetScales();
    }

        pCostFunctionAdaptor->SetScales(scales);
        pCostFunctionAdaptor->SetOriginPosition(originPosition);
        pCostFunctionAdaptor->SetParameterAxis(this->GetParameterAxis());

  // vnl optimizers return the solution by reference 
  // in the variable provided as initial position
  if (m_AutomaticInitialSimplex)
    {
    m_VnlOptimizer->minimize( internalParameters );
    }
  else
    {
    InternalParametersType delta( m_InitialSimplexDelta );
    m_VnlOptimizer->minimize( internalParameters, delta );
    }
  
  this->SetCurrentPosition(this->GetCachedCurrentPosition());

        m_BestPosition = this->GetCachedCurrentPosition();
        m_BestValue     = this->GetCachedValue();
    
        this->InvokeEvent( itk::EndEvent() );
}

} // end namespace FREE

---