freSPSASOOptimizer.h

Go to the documentation of this file.

/*=========================================================================

Program:   F.R.E.E. - flexible registration evaluation engine
Module:    $RCSfile: freSPSASOOptimizer.h,v $
  Language:  C++

Language:  C++

Copyright (c) 2003 University Heidelberg, University of applied science Heilbronn.
All rights reserved.

Portions of this code are covered under the ITK copyright.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

Portions of this code are covered under the VTK copyright.
See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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 __freSPSASOOptimizer_h
#define __freSPSASOOptimizer_h

#include "freSetupOptimizationOptimizer.h"
#include "freRegistrationObserver.h"
#include "freItkSingleValuedCostFunctionWrapper.h"

#include "itkSPSAOptimizer.h"

namespace FREE
{

#define freGetWrappedConstMacro(name,type) \
  virtual type Get##name () const \
  { \
    return this->m_ItkOptimizer->Get##name (); \
  }

#define freGetWrappedConstReferenceMacro(name,type) \
  virtual const type & Get##name () const \
  { \
  return this->m_ItkOptimizer->Get##name (); \
  }

#define freSetWrappedMacro(name,type) \
  virtual void Set##name (const type _arg) \
  { \
    this->m_ItkOptimizer->Set##name ( _arg ); \
    this->Modified(); \
  } 

  class ITK_EXPORT SPSASOOptimizer : 
    public SetupOptimizationOptimizer
  {
  public:
    typedef SPSASOOptimizer  Self;
    typedef SetupOptimizationOptimizer                                          Superclass;
    typedef itk::SmartPointer<Self>               Pointer;
    typedef itk::SmartPointer<const Self>         ConstPointer;

    itkTypeMacro( SPSASOOptimizer, SetupOptimizationOptimizer );

    itkNewMacro(Self);

    virtual void GuessParameters(  unsigned long numberOfGradientEstimates,
      double initialStepSize);

    itkSetMacro( ValueUpdateRate, long );
    itkGetConstMacro( ValueUpdateRate, long );

    freGetWrappedConstMacro( CurrentIteration, unsigned long );
    freGetWrappedConstMacro( StopCondition, itk::SPSAOptimizer::StopConditionType );
    freGetWrappedConstMacro( LearningRate, double);
    freGetWrappedConstMacro( GradientMagnitude, double);
    freGetWrappedConstReferenceMacro( Gradient, itk::SPSAOptimizer::DerivativeType);

    freSetWrappedMacro( a, double );
    freGetWrappedConstMacro( a, double );

    freSetWrappedMacro( c, double );
    freGetWrappedConstMacro( c, double );

    freSetWrappedMacro( A, double );
    freGetWrappedConstMacro( A, double );

    freSetWrappedMacro( Alpha, double );
    freGetWrappedConstMacro( Alpha, double );

    freSetWrappedMacro( Gamma, double );
    freGetWrappedConstMacro( Gamma, double );

    freGetWrappedConstMacro( Maximize, bool );
    freSetWrappedMacro( Maximize, bool );
    void MaximizeOn()
    { this->m_ItkOptimizer->SetMaximize(true); }
    void MaximizeOff()
    { this->m_ItkOptimizer->SetMaximize(true); }
    bool GetMinimize( ) const
    { return !this->m_ItkOptimizer->GetMinimize(); }
    void SetMinimize(bool v)
    { this->m_ItkOptimizer->SetMinimize(v); }
    void MinimizeOn()
    { this->m_ItkOptimizer->MinimizeOn(); }
    void MinimizeOff()
    { this->m_ItkOptimizer->MinimizeOff(); }

    freSetWrappedMacro( NumberOfPerturbations, unsigned long );
    freGetWrappedConstMacro( NumberOfPerturbations, unsigned long );

    freGetWrappedConstMacro( StateOfConvergence, double );

    freSetWrappedMacro( StateOfConvergenceDecayRate, double );
    freGetWrappedConstMacro( StateOfConvergenceDecayRate, double );

    freSetWrappedMacro( MinimumNumberOfIterations, unsigned long);
    freGetWrappedConstMacro( MinimumNumberOfIterations, unsigned long);

    freSetWrappedMacro( MaximumNumberOfIterations, unsigned long );
    freGetWrappedConstMacro( MaximumNumberOfIterations, unsigned long );

    freSetWrappedMacro(Tolerance, double);
    freGetWrappedConstMacro(Tolerance, double);

    virtual void SetCostFunction( CostFunctionType * costFunction );

    virtual void SetInitialPosition (const ParametersType &param);

    virtual void StartOptimization( void );

    virtual bool IsStoppable() const;
    virtual void StopOptimization();

    virtual bool IsResumeable() const;
    virtual void ResumeOptimization();

    typedef itk::SPSAOptimizer ItkOptimizerType;
    typedef ItkOptimizerType::Pointer ItkOptimizerPointer;

    ItkOptimizerType * GetItkOptimizer();

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

    void OnOptIteration(void* pSender, long threadID);
    void OnOptStart(void* pSender, long threadID);
    void OnOptEnd(void* pSender, long threadID);

    IterationObserver::Pointer m_IterationObserver;
    NotificationEvent<Self>::Pointer m_IterationNotificationEvent;

    typedef RegistrationObserverBase<itk::StartEvent> StartObserver;
    StartObserver::Pointer m_StartObserver;
    NotificationEvent<Self>::Pointer m_StartNotificationEvent;

    typedef RegistrationObserverBase<itk::EndEvent> EndObserver;
    EndObserver::Pointer m_EndObserver;
    NotificationEvent<Self>::Pointer m_EndNotificationEvent;

    ItkOptimizerPointer m_ItkOptimizer;
    ItkSingleValuedCostFunctionWrapper::Pointer m_CostFunctionWrapper;

    long m_ValueUpdateRate;

  private:  
    SPSASOOptimizer(const Self&); //purposely not implemented
    void operator=(const Self&);//purposely not implemented
  };

} // end namespace FREE

#endif

---