freEvolutionaryStrategySOOptimizer.h

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: freEvolutionaryStrategySOOptimizer.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.

=========================================================================*/
#ifndef __freEvolutionaryStrategySOOptimizer_h
#define __freEvolutionaryStrategySOOptimizer_h

#include "freSetupOptimizationOptimizer.h"

#include "freRegistrationObserver.h"

#include "freItkSingleValuedCostFunctionWrapper.h"
#include "freEvolutionaryStrategyOptimizer.h"
#include "freESControllerInfo.h"

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

    itkTypeMacro( EvolutionaryStrategySOOptimizer, SetupOptimizationOptimizer );

    itkNewMacro(Self);

    typedef ES::EvolutionaryStrategyOptimizer< ESIndividualType > InternalOptimizerType;
    typedef InternalOptimizerType::Pointer InternalOptimizerPointer;

    typedef  InternalOptimizerType::IndividualType            IndividualType;
    typedef  InternalOptimizerType::IndividualPointer         IndividualPointer;
    typedef  InternalOptimizerType::ObjectiveValueType        ObjectiveValueType;
    typedef  InternalOptimizerType::IndividualIDType          IndividualIDType;
    typedef  InternalOptimizerType::IndividualSelectionType   IndividualSelectionType;
    typedef  InternalOptimizerType::HeritageMapType           HeritageMapType;

    typedef  InternalOptimizerType::PopulationType            PopulationType;
    typedef  InternalOptimizerType::PopulationPointer         PopulationPointer;

    typedef  InternalOptimizerType::ParentSelectorType        ParentSelectorType;
    typedef  InternalOptimizerType::ParentSelectorPointer     ParentSelectorPointer;

    typedef  InternalOptimizerType::RecombinatorType          RecombinatorType;
    typedef  InternalOptimizerType::RecombinatorPointer       RecombinatorPointer;

    typedef  InternalOptimizerType::MutationType              MutationType;
    typedef  InternalOptimizerType::MutationPointer           MutationPointer;

    typedef  InternalOptimizerType::SelectionType             SelectionType;
    typedef  InternalOptimizerType::SelectionPointer          SelectionPointer;

    void SetMaximize(bool maximize);
    bool GetMaximize() const;
    void MaximizeOn(void) 
    { SetMaximize( true ); }
    void MaximizeOff(void) 
    { SetMaximize( false ); }
    bool GetMinimize( ) const
    { return !GetMaximize(); }
    void SetMinimize(bool v)
    { this->SetMaximize(!v); }
    void MinimizeOn(void) 
    { SetMaximize( false ); }
    void MinimizeOff(void) 
    { SetMaximize( true ); }

    void SetMaximumIteration(unsigned int iMaximumIteration);
    const unsigned int GetMaximumIteration() const;

    void SetNumberOfParents(unsigned long iNumberOfParents);
    const unsigned long GetNumberOfParents() const;

    void SetNumberOfChildren(unsigned long iNumberOfChildren);
    const unsigned long GetNumberOfChildren() const;

    void SetMutateIntitialPopulation(bool bMutateIntitialPopulation);
    const bool GetMutateIntitialPopulation() const;

    void SetThreshold(ObjectiveValueType threshold);
    const ObjectiveValueType GetThreshold() const;

    virtual void SetParentSelector( ParentSelectorType * pParentSelector );
    virtual const ParentSelectorType* GetParentSelector() const;
    virtual ParentSelectorType* GetParentSelector();

    virtual void SetRecombinator( RecombinatorType * pRecombinator );
    virtual const RecombinatorType* GetRecombinator() const;
    virtual RecombinatorType* GetRecombinator();

    virtual void SetMutation( MutationType * pMutation );
    virtual const MutationType* GetMutation() const;
    virtual MutationType* GetMutation();

    virtual void SetSelection( SelectionType * pSelection );
    virtual const SelectionType* GetSelection() const;
    virtual SelectionType* GetSelection();

    virtual const PopulationType* GetPopulation() const;
    virtual PopulationType* GetPopulation();

    const IndividualType* GetBestIndividualEver() const;
    const IndividualType* GetBestIndividual() const;

    virtual void Initialize(const PopulationType& population);

    virtual void Initialize();

    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();

    const HeritageMapType& GetRecentParentSelections() const;

    const PopulationPointer& GetRecentPopulationSelections() const;
    const PopulationPointer& GetNewChildren() const;

    const IndividualType* GetCurrentChild() const;
    IndividualType* GetCurrentChild();

    InternalOptimizerType * GetInternalOptimizer();

    DecomposedMeasureType GetDecomposedIndividualValue(const IndividualIDType& rID);

  protected:
    EvolutionaryStrategySOOptimizer();
    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);
    void OnChildGen(void* pSender, long threadID);
    void OnChildEval(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;

    typedef RegistrationObserverBase<ES::NewChildGenerationEvent> ChildGenerationObserver;
    ChildGenerationObserver::Pointer m_ChildGenerationObserver;
    NotificationEvent<Self>::Pointer m_ChildGenerationNotificationEvent;

    typedef RegistrationObserverBase<ES::NewChildEvaluationEvent> ChildEvaluationObserver;
    ChildEvaluationObserver::Pointer m_ChildEvaluationObserver;
    NotificationEvent<Self>::Pointer m_ChildEvaluationNotificationEvent;

    InternalOptimizerPointer m_InternalOptimizer;
    ItkSingleValuedCostFunctionWrapper::Pointer m_CostFunctionWrapper;

    typedef  std::map<IndividualIDType,DecomposedMeasureType> IndividualMeasureMapType;
    //map containing all decomposed measures of individuals of the last optimization iteration
    IndividualMeasureMapType m_MeasureMap;

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

} // end namespace FREE

#endif
    
 

---