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

namespace FREE
{

EvolutionaryStrategySOOptimizer
::EvolutionaryStrategySOOptimizer()
{
  itkDebugMacro("Constructor");

        m_InternalOptimizer = InternalOptimizerType::New();
        m_CostFunctionWrapper = ItkSingleValuedCostFunctionWrapper::New();

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

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

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

        m_ChildGenerationObserver = ChildGenerationObserver::New();
        m_ChildGenerationNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnChildGen);
        m_ChildGenerationObserver->fnOnNotify = m_ChildGenerationNotificationEvent;
  m_InternalOptimizer->AddObserver(ES::NewChildGenerationEvent(), m_ChildGenerationObserver);

  m_ChildEvaluationObserver = ChildEvaluationObserver::New();
        m_ChildEvaluationNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnChildEval);
        m_ChildEvaluationObserver->fnOnNotify = m_ChildEvaluationNotificationEvent;
  m_InternalOptimizer->AddObserver(ES::NewChildEvaluationEvent(), m_ChildEvaluationObserver);

  m_CurrentValue = 0;
  m_CurrentDecomposedValue.Fill(0.0);
}

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

  os << indent << "CurrentValue = " << m_CurrentValue << std::endl;
  os << indent << "CurrentDecomposedValue = " << m_CurrentDecomposedValue << std::endl;
}

void
EvolutionaryStrategySOOptimizer
::StartOptimization( void )
{
  m_InternalOptimizer->SetScales(this->GetScales());
  m_InternalOptimizer->StartOptimization();
}

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

 
void
EvolutionaryStrategySOOptimizer
::StopOptimization()
{
  m_InternalOptimizer->StopOptimization();
};

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

void
EvolutionaryStrategySOOptimizer
::ResumeOptimization()
{
  m_InternalOptimizer->ResumeOptimization();
};

const EvolutionaryStrategySOOptimizer::HeritageMapType&
EvolutionaryStrategySOOptimizer
::GetRecentParentSelections() const
{
  return m_InternalOptimizer->GetRecentParentSelections();
};

const EvolutionaryStrategySOOptimizer::PopulationPointer&
EvolutionaryStrategySOOptimizer
::GetRecentPopulationSelections() const
{
  return m_InternalOptimizer->GetRecentPopulationSelections();
};


const EvolutionaryStrategySOOptimizer::PopulationPointer&
EvolutionaryStrategySOOptimizer
::GetNewChildren() const
{
  return m_InternalOptimizer->GetNewChildren();
};


EvolutionaryStrategySOOptimizer::InternalOptimizerType * 
EvolutionaryStrategySOOptimizer
::GetInternalOptimizer()
{
  return m_InternalOptimizer;
}

void
EvolutionaryStrategySOOptimizer::
OnOptIteration(void* pSender, long threadID)
{
        m_CurrentValue = m_InternalOptimizer->GetCurrentCost();
        m_CurrentDecomposedValue = m_CostFunction->GetCurrentDecomposedValue();
        this->SetCurrentPosition(m_InternalOptimizer->GetCurrentPosition());

        m_BestValue = m_CurrentValue;
        m_BestPosition = m_InternalOptimizer->GetCurrentPosition();
        
        //and pass the signal to the rest of the world
        this->InvokeEvent( itk::IterationEvent() );

  m_MeasureMap.clear();
};

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

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

void
EvolutionaryStrategySOOptimizer::
OnChildGen(void* pSender, long threadID)
{
  //just pass the signal to the rest of the world
  this->InvokeEvent( ES::NewChildGenerationEvent() );

  const IndividualType* pChild = GetCurrentChild();
  if (pChild)
  {
    std::ostringstream strstream;
    pChild->Print(strstream);
    this->InvokeEvent( EvaluationProgressObserverEvent(0,strstream.str()) );
  }
};

void
EvolutionaryStrategySOOptimizer::
OnChildEval(void* pSender, long threadID)
{
  //Get the decomposed metric value for the child
  //so it can be used for the statistics
  const IndividualType* pChild = GetCurrentChild();
  if (pChild)
  {
    m_MeasureMap[pChild->GetIndividualID()] = m_CostFunction->GetCurrentDecomposedValue();
  }

  //now pass the signal to the rest of the world
  this->InvokeEvent( ES::NewChildEvaluationEvent() );
};

EvolutionaryStrategySOOptimizer::DecomposedMeasureType
EvolutionaryStrategySOOptimizer::
GetDecomposedIndividualValue(const IndividualIDType& rID)
{
  return m_MeasureMap[rID];
};

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

void
EvolutionaryStrategySOOptimizer::
SetMaximize(bool maximize)
{
  m_InternalOptimizer->SetMaximize(maximize);
};

bool
EvolutionaryStrategySOOptimizer::
GetMaximize() const
{ 
  return m_InternalOptimizer->GetMaximize();
};

void
EvolutionaryStrategySOOptimizer::
SetInitialPosition (const ParametersType &param)
{
  Superclass::SetInitialPosition(param);
  m_InternalOptimizer->SetInitialPosition(param);
};

void
EvolutionaryStrategySOOptimizer::
SetMaximumIteration(unsigned int iMaximumIteration)
{
  m_InternalOptimizer->SetMaximumIteration(iMaximumIteration);
};

const unsigned int
EvolutionaryStrategySOOptimizer::
GetMaximumIteration() const
{
  return m_InternalOptimizer->GetMaximumIteration();
};

void
EvolutionaryStrategySOOptimizer::
SetNumberOfParents(unsigned long iNumberOfParents)
{
  m_InternalOptimizer->SetNumberOfParents(iNumberOfParents);
};

const unsigned long
EvolutionaryStrategySOOptimizer::
GetNumberOfParents() const
{
  return m_InternalOptimizer->GetNumberOfParents();
};

void
EvolutionaryStrategySOOptimizer::
SetNumberOfChildren(unsigned long iNumberOfChildren)
{
  m_InternalOptimizer->SetNumberOfChildren(iNumberOfChildren);
};

const unsigned long
EvolutionaryStrategySOOptimizer::
GetNumberOfChildren() const
{
  return m_InternalOptimizer->GetNumberOfChildren();
};

void
EvolutionaryStrategySOOptimizer::
SetMutateIntitialPopulation(bool bMutateIntitialPopulation)
{
  m_InternalOptimizer->SetMutateIntitialPopulation(bMutateIntitialPopulation);
};

const bool
EvolutionaryStrategySOOptimizer::
GetMutateIntitialPopulation() const
{
  return m_InternalOptimizer->GetMutateIntitialPopulation();
};


void
EvolutionaryStrategySOOptimizer::
SetThreshold(ObjectiveValueType threshold)
{
  m_InternalOptimizer->SetThreshold(threshold);
};

const EvolutionaryStrategySOOptimizer::ObjectiveValueType
EvolutionaryStrategySOOptimizer::
GetThreshold() const
{
  return m_InternalOptimizer->GetThreshold();
};

void
EvolutionaryStrategySOOptimizer::
SetParentSelector( ParentSelectorType * pParentSelector )
{
  m_InternalOptimizer->SetParentSelector(pParentSelector);
};

const EvolutionaryStrategySOOptimizer::ParentSelectorType*
EvolutionaryStrategySOOptimizer::
GetParentSelector() const
{
  return m_InternalOptimizer->GetParentSelector();
};

EvolutionaryStrategySOOptimizer::ParentSelectorType*
EvolutionaryStrategySOOptimizer::
GetParentSelector()
{
  return m_InternalOptimizer->GetParentSelector();
};

void
EvolutionaryStrategySOOptimizer::
SetRecombinator( RecombinatorType * pRecombinator )
{
  m_InternalOptimizer->SetRecombinator(pRecombinator);
};

const EvolutionaryStrategySOOptimizer::RecombinatorType*
EvolutionaryStrategySOOptimizer::
GetRecombinator() const
{
  return m_InternalOptimizer->GetRecombinator();
};

EvolutionaryStrategySOOptimizer::RecombinatorType*
EvolutionaryStrategySOOptimizer::
GetRecombinator()
{
  return m_InternalOptimizer->GetRecombinator();
};

void
EvolutionaryStrategySOOptimizer::
SetMutation( MutationType * pMutation )
{
  m_InternalOptimizer->SetMutation(pMutation);
};

const EvolutionaryStrategySOOptimizer::MutationType*
EvolutionaryStrategySOOptimizer::
GetMutation() const
{
  return m_InternalOptimizer->GetMutation();
};

EvolutionaryStrategySOOptimizer::MutationType*
EvolutionaryStrategySOOptimizer::
GetMutation()
{
  return m_InternalOptimizer->GetMutation();
};

void
EvolutionaryStrategySOOptimizer::
SetSelection( SelectionType * pSelection )
{
  m_InternalOptimizer->SetSelection(pSelection);
};

const EvolutionaryStrategySOOptimizer::SelectionType*
EvolutionaryStrategySOOptimizer::
GetSelection() const
{
  return m_InternalOptimizer->GetSelection();
};

EvolutionaryStrategySOOptimizer::SelectionType*
EvolutionaryStrategySOOptimizer::
GetSelection()
{
  return m_InternalOptimizer->GetSelection();
};

const EvolutionaryStrategySOOptimizer::PopulationType*
EvolutionaryStrategySOOptimizer::
GetPopulation() const
{
  return m_InternalOptimizer->GetPopulation();
};

EvolutionaryStrategySOOptimizer::PopulationType*
EvolutionaryStrategySOOptimizer::
GetPopulation()
{
  return m_InternalOptimizer->GetPopulation();
};

const EvolutionaryStrategySOOptimizer::IndividualType*
EvolutionaryStrategySOOptimizer::
GetBestIndividualEver() const
{
  return m_InternalOptimizer->GetBestIndividualEver();
};

const EvolutionaryStrategySOOptimizer::IndividualType*
EvolutionaryStrategySOOptimizer::
GetBestIndividual() const
{
  return m_InternalOptimizer->GetBestIndividual();
};

void
EvolutionaryStrategySOOptimizer::
Initialize(const PopulationType& population)
{
  m_InternalOptimizer->Initialize(population);
  m_MeasureMap.clear();
};

void
EvolutionaryStrategySOOptimizer::
Initialize()
{
  m_InternalOptimizer->Initialize();
  m_MeasureMap.clear();
};

const EvolutionaryStrategySOOptimizer::IndividualType*
EvolutionaryStrategySOOptimizer::
GetCurrentChild() const
{
  return m_InternalOptimizer->GetCurrentChild();
};

EvolutionaryStrategySOOptimizer::IndividualType*
EvolutionaryStrategySOOptimizer::
GetCurrentChild()
{
  return m_InternalOptimizer->GetCurrentChild();
};

} // end namespace FREE

---