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

namespace FREE
{

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

        this->SetMaximize(false);
        this->SetMaximumIteration(100);
        this->SetMaximumLineIteration(100);
        this->SetStepLength(1.0);
        this->SetStepTolerance(0.00001);
        this->SetValueTolerance(0.00001);

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

PowellSOOptimizer
::~PowellSOOptimizer()
{
}

void
PowellSOOptimizer::
SetMaximize(bool maximize)
{
        m_ItkOptimizer->SetMaximize(maximize);
        this->Modified();
};

void
PowellSOOptimizer::
SetMaximumIteration(unsigned int iMaximumIteration)
{
        m_ItkOptimizer->SetMaximumIteration(iMaximumIteration);
        this->Modified();
};

const unsigned int
PowellSOOptimizer::
GetMaximumIteration() const
{
        return m_ItkOptimizer->GetMaximumIteration();
};

void
PowellSOOptimizer::
SetMaximumLineIteration(unsigned int iMaximumLineIteration)
{
        m_ItkOptimizer->SetMaximumLineIteration(iMaximumLineIteration);
        this->Modified();
};

const unsigned int
PowellSOOptimizer::
GetMaximumLineIteration() const
{
        return m_ItkOptimizer->GetMaximumLineIteration();
};

void
PowellSOOptimizer::
SetStepLength(double dStepLenght)
{
        m_ItkOptimizer->SetStepLength(dStepLenght);
        this->Modified();
};

const double&
PowellSOOptimizer::
GetStepLength() const
{
        return m_ItkOptimizer->GetStepLength();
};

void
PowellSOOptimizer::
SetStepTolerance(double dStepTolerance)
{
        m_ItkOptimizer->SetStepTolerance(dStepTolerance);
        this->Modified();
};

const double&
PowellSOOptimizer::
GetStepTolerance() const
{
        return m_ItkOptimizer->GetStepTolerance();
};

void
PowellSOOptimizer::
SetValueTolerance(double dValueTolerance)
{
        m_ItkOptimizer->SetValueTolerance(dValueTolerance);
        this->Modified();
};

const double&
PowellSOOptimizer::
GetValueTolerance() const
{
        return m_ItkOptimizer->GetValueTolerance();
};

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

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

void
PowellSOOptimizer
::PrintSelf(std::ostream& os, itk::Indent indent) const
{
  Superclass::PrintSelf(os,indent);
        
        os << indent << "Current Iteration " << m_ItkOptimizer->GetCurrentIteration() << std::endl;
        os << indent << "Maximize On/Off   " << m_ItkOptimizer->GetMaximize()         << std::endl;
        os << indent << "StepLength        " << m_ItkOptimizer->GetStepLength()       << std::endl;
        os << indent << "StepTolerance     " << m_ItkOptimizer->GetStepTolerance()    << std::endl;
        os << indent << "ValueTolerance    " << m_ItkOptimizer->GetValueTolerance()   << std::endl;
        os << indent << "Current Cost      " << m_ItkOptimizer->GetCurrentCost()      << std::endl;
        os << indent << "Maximum Line Iteration " << m_ItkOptimizer->GetMaximumLineIteration() << std::endl;
        os << indent << "Current Line Iteration " << m_ItkOptimizer->GetCurrentLineIteration() << std::endl;
}

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

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

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


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

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


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

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

} // end namespace FREE

---