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

namespace FREE
{

  SPSASOOptimizer
    ::SPSASOOptimizer()
  {
    m_ItkOptimizer = ItkOptimizerType::New();
    m_CostFunctionWrapper = ItkSingleValuedCostFunctionWrapper::New();

    m_ValueUpdateRate = 10;

    this->SetMaximize(false);

    m_IterationObserver = IterationObserver::New();
    m_IterationNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnOptIteration);
    m_IterationObserver->fnOnNotify = m_IterationNotificationEvent;
    m_ItkOptimizer->AddObserver(itk::IterationEvent(), m_IterationObserver);

    m_StartObserver = StartObserver::New();
    m_StartNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnOptStart);
    m_StartObserver->fnOnNotify = m_StartNotificationEvent;
    m_ItkOptimizer->AddObserver(itk::StartEvent(), m_StartObserver);

    m_EndObserver = EndObserver::New();
    m_EndNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnOptEnd);
    m_EndObserver->fnOnNotify = m_EndNotificationEvent;
    m_ItkOptimizer->AddObserver(itk::EndEvent(), m_EndObserver);
  }

  void
  SPSASOOptimizer::
  GuessParameters(  unsigned long numberOfGradientEstimates,
      double initialStepSize)
  {
    this->m_ItkOptimizer->GuessParameters(numberOfGradientEstimates,initialStepSize);
  };

  void
    SPSASOOptimizer::
    SetCostFunction( CostFunctionType * costFunction )
  {
    Superclass::SetCostFunction(costFunction);
    m_CostFunctionWrapper->SetWrappedCostFunction(costFunction);
    m_ItkOptimizer->SetCostFunction(m_CostFunctionWrapper);
  };

  void
    SPSASOOptimizer::
    SetInitialPosition (const ParametersType &param)
  {
    Superclass::SetInitialPosition(param);
    m_ItkOptimizer->SetInitialPosition(param);
  };

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

    os << indent << "a: " << this->m_ItkOptimizer->Geta() << std::endl;
    os << indent << "A: " << this->m_ItkOptimizer->GetA() << std::endl;
    os << indent << "Alpha: " << this->m_ItkOptimizer->GetAlpha() << std::endl;
    os << indent << "c: " << this->m_ItkOptimizer->Getc() << std::endl;
    os << indent << "Gamma: " << this->m_ItkOptimizer->GetGamma() << std::endl;

    os << indent << "NumberOfPerturbations: " << this->m_ItkOptimizer->GetNumberOfPerturbations() << std::endl;

    os << indent << "LearningRate: " << this->m_ItkOptimizer->GetLearningRate() << std::endl;

    os << indent << "MaximumNumberOfIterations: " << this->m_ItkOptimizer->GetMaximumNumberOfIterations() << std::endl;
    os << indent << "MinimumNumberOfIterations: " << this->m_ItkOptimizer->GetMinimumNumberOfIterations() << std::endl;
    os << indent << "ValueUpdateRate: " << this->m_ValueUpdateRate << std::endl;

    os << indent << "Maximize: " << this->m_ItkOptimizer->GetMaximize() << std::endl;
    os << indent << "StopCondition: "  << this->m_ItkOptimizer->GetStopCondition() << std::endl;

    os << indent << "Current Iteration " << this->m_ItkOptimizer->GetCurrentIteration() << std::endl;
    os << indent << "Current Cost      " << this->GetCurrentValue()  << std::endl;
  }

  void
    SPSASOOptimizer
    ::StartOptimization( void )
  {
    this->m_ItkOptimizer->SetScales(this->GetScales());
    this->m_ItkOptimizer->StartOptimization();

    this->m_CurrentValue = this->m_ItkOptimizer->GetValue();
    this->m_CurrentDecomposedValue = this->m_CostFunction->GetCurrentDecomposedValue();

    this->m_BestValue = this->m_CurrentValue;
    this->m_BestPosition = this->m_ItkOptimizer->GetCurrentPosition();
  }

  bool
  SPSASOOptimizer
  ::IsStoppable() const
  {
    return true;
  };

   
  void
  SPSASOOptimizer
  ::StopOptimization()
  {
    this->m_ItkOptimizer->StopOptimization();
  };

  bool
  SPSASOOptimizer
  ::IsResumeable() const
  {
    return true;
  };

  void
  SPSASOOptimizer
  ::ResumeOptimization()
  {
    this->m_ItkOptimizer->ResumeOptimization();
  };

  SPSASOOptimizer::ItkOptimizerType * 
    SPSASOOptimizer
    ::GetItkOptimizer()
  {
    return m_ItkOptimizer;
  }

  void
    SPSASOOptimizer::
    OnOptIteration(void* pSender, long threadID)
  {
    if (this->m_ItkOptimizer->GetCurrentIteration()%m_ValueUpdateRate == 0)
    { //retrieving the value cost on evaluation of the objectiv function, so let the
      //user decide how many computation time should be spent on updating information.
      this->m_CurrentValue = this->m_ItkOptimizer->GetValue();
      this->m_CurrentDecomposedValue = this->m_CostFunction->GetCurrentDecomposedValue();

      this->m_BestValue = this->m_CurrentValue;
      this->m_BestPosition = this->m_ItkOptimizer->GetCurrentPosition();
    };

    this->SetCurrentPosition(this->m_ItkOptimizer->GetCurrentPosition());


    //and pass the signal to the rest of the world
    this->InvokeEvent( itk::IterationEvent() );
  };

  void
    SPSASOOptimizer::
    OnOptStart(void* pSender, long threadID)
  {
    //just pass the signal to the rest of the world
    this->InvokeEvent( itk::StartEvent() );
  };

  void
    SPSASOOptimizer::
    OnOptEnd(void* pSender, long threadID)
  {
    //just pass the signal to the rest of the world
    this->InvokeEvent( itk::EndEvent() );
  };

} // end namespace FREE

---