freSetupOptimizationProcessor.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: freSetupOptimizationProcessor.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 "freSetupOptimizationProcessor.h"

#include "freControllerCentral.h"
#include "freRegistrationObserver.h"
#include "freSetupOptimizationProgressObserver.h"

namespace FREE
{




Setup*
SetupOptimizationProcessor::
GetSetup()
{
  return m_smpSetup.GetPointer();
};

void
SetupOptimizationProcessor::
SetSetup(Setup* pSetup)
{
  m_smpSetup = pSetup;

  if (m_Transform.IsNotNull()) m_Transform->SetReferenceSetup(m_smpSetup);

  this->Modified();
};

Adaptation::AdaptationList*
SetupOptimizationProcessor::
GetAdaptationList()
{
  return m_smpAdaptations;
};

void
SetupOptimizationProcessor::
SetAdaptationList(Adaptation::AdaptationList* pAdaptations)
{
  m_smpAdaptations = pAdaptations;
  
  if (m_Metric.IsNotNull()) m_Metric->SetAdaptationList(pAdaptations);

  this->Modified();
};

void
SetupOptimizationProcessor::
StartOptimization()
{
  m_lCurIteration = 0;

        m_bOptimizationStarted = true;

        if (!m_Transform) throwExceptionMacro("Cannot start registration; no transformation component available.");
  if (!m_Metric) throwExceptionMacro("Cannot start registration; no metric component available.");
  if (!m_Optimizer) throwExceptionMacro("Cannot start registration; no optimizer component available.");

  try
  {
    //Connect all registration components
    if(fnOnProgress.IsNotNull()) fnOnProgress->Execute(RSTInitProcessor, "Connecting components",this);

    m_Metric->SetTransform(m_Transform);
    m_Metric->SetAdaptationList(m_smpAdaptations);

    m_Optimizer->SetCostFunction(m_Metric);

    //Set initials parameters
    if(fnOnProgress.IsNotNull()) fnOnProgress->Execute(RSTInitProcessor, "Setting initial transform parameters and setup values of components", this);
    m_Optimizer->SetInitialPosition(m_Transform->GetParameters());

                //Link Events
                m_Metric->fnOnEvaluationProgress = this->fnOnMetricComputationProgress;
                m_Metric->fnOnEvaluationDone = this->fnOnEvaluationDone;
                m_Metric->fnOnNextAdaptation = this->fnOnNextAdaptation;
                m_Metric->fnOnEvaluationFailed = this->fnOnEvaluationFailed;

    m_Metric->Initialize();
                
    //also add observer for optimizer iterations
                IterationObserver::Pointer iterationObserver = IterationObserver::New();
                NotificationEvent<Self>::Pointer iterationNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnNewIteration);
    iterationObserver->fnOnNotify = iterationNotificationEvent;
    m_Optimizer->AddObserver(itk::IterationEvent(), iterationObserver);
    
    //and the observer for evaluation progress to all subcomponents
                SetupOptimizationProgressObserver::Pointer progressObserver = SetupOptimizationProgressObserver::New();
                ProgressEvent<Self>::Pointer progressNotificationEvent = ProgressEvent<Self>::New(this, &Self::OnEvaluationProgress);
    progressObserver->fnOnNotify = progressNotificationEvent.GetPointer();
    m_Metric->AddObserver(EvaluationProgressObserverEvent(), progressObserver);
    m_Transform->AddObserver(EvaluationProgressObserverEvent(), progressObserver);
    m_Optimizer->AddObserver(EvaluationProgressObserverEvent(), progressObserver);
  }
  catchAllNPassMacro("Unknown Error while preparing the registration.");

  try
  {
    if(fnOnProgress.IsNotNull()) fnOnProgress->Execute(RSTProcessing,"",this);

                m_Optimizer->StartOptimization();
  }
  catchAllNPassMacro("Unknown Error while itk processing the registration.");

  //Save the final setup
  if(fnOnProgress.IsNotNull()) fnOnProgress->Execute(RSTFinalizing, "Optimization finished; computing final setup.",this);
        m_FinalParameters = m_Optimizer->GetBestPosition();
        m_FinalMeasure = m_Optimizer->GetBestValue();
        m_Transform->SetParameters(m_FinalParameters);
        m_smpFinalSetup = m_Transform->GenerateTransformedSetup();

  std::stringstream sstream;
  sstream << "Optimized setup: final parameter: " << m_FinalParameters << "; measure: "<< m_FinalMeasure;
  m_smpFinalSetup->SetDescription(sstream.str());

  m_bOptimizationDone = true;
};

void
SetupOptimizationProcessor::
ResumeOptimization()
{
        if (!m_bOptimizationStarted) throwExceptionMacro("Cannot resume optimization befor optimization started.");

  try
  {
    if(fnOnProgress.IsNotNull()) fnOnProgress->Execute(RSTProcessing,"",this);

                m_Optimizer->ResumeOptimization();
  }
  catchAllNPassMacro("Unknown Error while itk processing the registration.");

  //Save the final setup
  if(fnOnProgress.IsNotNull()) fnOnProgress->Execute(RSTFinalizing, "Optimization finished; computing final setup.",this);
        m_FinalParameters = m_Optimizer->GetBestPosition();
        m_FinalMeasure = m_Optimizer->GetBestValue();
        m_Transform->SetParameters(m_FinalParameters);
        m_smpFinalSetup = m_Transform->GenerateTransformedSetup();

  std::stringstream sstream;
  sstream << "Optimized setup: final parameter: " << m_FinalParameters << "; measure: "<< m_FinalMeasure;
  m_smpFinalSetup->SetDescription(sstream.str());
};

bool
SetupOptimizationProcessor::
OptimizationIsResumable()
{
  if (m_Optimizer.IsNotNull())
  {
                return m_Optimizer->IsResumeable();
  }
  return false;
};

void
SetupOptimizationProcessor::
StopOptimization()
{
  if (m_Optimizer.IsNotNull())
  {
                m_Optimizer->StopOptimization();
  }
};

bool
SetupOptimizationProcessor::
OptimizationIsStoppable()
{
  if (m_Optimizer.IsNotNull())
  {
                return m_Optimizer->IsStoppable();
  }
  return false;
};

SetupOptimizationProcessor::
SetupOptimizationProcessor()
{ 
  m_bOptimizationDone = false;
  m_bOptimizationStarted = false;
  fnOnNextIteration = NULL;
  fnOnProgress = NULL;
  fnOnEvaluationDone = NULL;
  fnOnNextAdaptation = NULL;
  fnOnEvaluationFailed = NULL;

  m_lCurIteration = 0;
};

SetupOptimizationProcessor::
~SetupOptimizationProcessor()
{};

void
SetupOptimizationProcessor::
ComputeOptimization()
{

};

void
SetupOptimizationProcessor::
OnNewIteration(void* pSender, long threadID)
{
        if(fnOnNextIteration.IsNotNull()) fnOnNextIteration->Execute(m_lCurIteration, m_Optimizer->GetCurrentValue(), m_Optimizer->GetCurrentDecomposedValue(), m_Optimizer->GetCurrentPosition(), this);
  m_lCurIteration++;
};

void
SetupOptimizationProcessor::
OnEvaluationProgress(const long iStatusID, const std::string& sComment, void* pSender, long threadID)
{
        if(fnOnEvaluationProgress.IsNotNull()) fnOnEvaluationProgress->Execute(iStatusID, sComment, pSender, threadID);
};

const long
SetupOptimizationProcessor::
GetMaxIterationCount() const
{
        if (m_Optimizer.IsNull()) return -1;

        //TODO
        return 0;
};

const long
SetupOptimizationProcessor::
GetCurrentIterationCount() const
{
        return m_lCurIteration;
}

}//End of Namespace free

---