frePointSetRegistrationProcessor.txx

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: frePointSetRegistrationProcessor.txx,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 __frePointSetRegistrationProcessor_txx
#define __frePointSetRegistrationProcessor_txx

#include "frePointSetRegistrationProcessor.h"
#include "freOptimizerControllerBase.h"
#include "freTransformSetupAdaptor.h"

namespace FREE
{



template <unsigned int VImageDimension>
const long
PointSetRegistrationProcessor<VImageDimension>::
GetMaxIterationCount() const
{
    if (this->m_pComponentCache)
    {
        SessionComponentCache* pCache = this->m_pComponentCache->SubCaches().GetElement(cComp_MainOptimizer);
        if(pCache)
        {
            const GenericOptimizerController* pOptCtrl = dynamic_cast<const GenericOptimizerController*>(pCache->Controller());
            if (!pOptCtrl) throwExceptionMacro("Error. Cannot get max iteration count. Component of main optimizer cache is not a descendant of OptimizerControllerInterface.");
            return pOptCtrl->GetMaxIterationCount(pCache,this->m_iResolutionLevel);
        }
    }
    return -1;
};

template <unsigned int VImageDimension>
void
PointSetRegistrationProcessor<VImageDimension>::
ComputeRegistration()
{
    Superclass::ComputeRegistration();
    if (this->m_Transform.IsNull())
        throwExceptionMacro("Cannot start registration; no transformation component available.");
    if (this->m_Metric.IsNull())
        throwExceptionMacro("Cannot start registration; no metric component available.");
    if (this->m_Optimizer.IsNull())
        throwExceptionMacro("Cannot start registration; no optimizer component available.");

    if (this->m_FixedPointSet.IsNull())
        throwExceptionMacro("Cannot start registration; no fixed point set available.");
    if (this->m_MovingPointSet.IsNull())
        throwExceptionMacro("Cannot start registration; no moving point set available.");

    if (!this->m_pComponentCache)
        throwExceptionMacro("Cannot start registration; no processor cache available. Ensure that the registration is initialized properly.");

    this->m_pOptimizerCache = this->m_pComponentCache->GetCacheByIDPath(cIDPSelf+IDPath(cComp_MainOptimizer));
    if (!this->m_pOptimizerCache)
        throwExceptionMacro("Cannot start registration; no optimizer cache available. Ensure that the registration is initialized properly.");

    this->m_lCurIteration = 0;

    long optimizerObserverID = 0;

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

        this->m_Registration->SetMetric(this->m_Metric);
        this->m_Registration->SetOptimizer(this->m_Optimizer);
        this->m_Registration->SetTransform(this->m_Transform);

        //Set initials parameters
        if(this->fnOnProgress.IsNotNull())
            this->fnOnProgress->Execute(RSTInitProcessor, "Setting initial transform parameters and setup values of components",this);
        
        ComponentSetup* pTransformSetup = this->GetComponentSetup()->Components().GetElement(cComp_MainTransform);
        if (!pTransformSetup)
            throwExceptionMacro("Component setup of MainTransform does not exist.");
        
        TransformSetupAdaptor transformAdaptor(pTransformSetup);
        this->m_Registration->SetInitialTransformParameters(transformAdaptor.GetCurrentTransformParameters());

        //Connect images
        if(this->fnOnProgress.IsNotNull())
            this->fnOnProgress->Execute(RSTInitProcessor, "Connecting Point sets",this);
        this->m_Registration->SetFixedPointSet(this->m_FixedPointSet);
        this->m_Registration->SetMovingPointSet(this->m_MovingPointSet);

        //build string with transform parameters to notify progress
        std::string sParams = "";
        for ( int iIndex = 0; iIndex < transformAdaptor.GetCurrentTransformParameters().Size(); iIndex++)
        {
            sParams =sParams+"; "+FREE::Convert::ToStr( transformAdaptor.GetCurrentTransformParameters().GetElement(iIndex),5);
        }
        if(this->fnOnProgress.IsNotNull())
            this->fnOnProgress->Execute(RSTInitProcessor, "Initial transform parameters: "+sParams,this);

        //Register observer
        this->m_IterationObserver->fnOnNotify = this->m_IterationNotificationEvent;
        optimizerObserverID = this->m_Optimizer->AddObserver(itk::IterationEvent(), this->m_IterationObserver);

        // Setting maximize/minimize for the optimizer is done by the optimizer controller,
        // because not every optimizer has to set this information.
    }
    catchAllNPassMacro("Unknown Error while preparing the registration.");

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

        //Call the OnNextLevel one time before starting the registration.
        //even a singel resolution Registration has at least one level to notify
        if(this->fnOnNextLevel.IsNotNull())
            this->fnOnNextLevel->Execute(this->m_iResolutionLevel,this);

        this->m_Registration->StartRegistration();

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

    //Save the final parameters as current transform parameters
    TransformSetupAdaptor finalTransformAdaptor(this->GetComponentSetup()->Components().GetElement(cComp_MainTransform));
    finalTransformAdaptor.SetCurrentTransformParameters(this->m_Registration->GetLastTransformParameters());

    this->m_CurrentTransformParameters = this->m_Registration->GetLastTransformParameters();
};

template <unsigned int VImageDimension>
PointSetRegistrationProcessor<VImageDimension>::
PointSetRegistrationProcessor()
{
    this->m_Metric = NULL;
    this->m_Optimizer = NULL;
    this->m_pOptimizerCache = NULL;

    this->m_Registration = RegistrationType::New();

    this->m_IterationObserver = IterationObserver::New();
    this->m_IterationNotificationEvent = NotificationEvent<Self>::New(this, &Self::OnNewIteration);
}

template <unsigned int VImageDimension>
PointSetRegistrationProcessor<VImageDimension>::
~PointSetRegistrationProcessor()
{};

template <unsigned int VImageDimension>
typename PointSetRegistrationProcessor<VImageDimension>::TransformFieldPointer
PointSetRegistrationProcessor<VImageDimension>::
ComputeTransformationField(const PointType& origin, const RegionType& region, const SpacingType& spacing)
{
  return TransformInterface::ComputeTransformationField(origin,region,spacing);
};

template <unsigned int VImageDimension>
bool
PointSetRegistrationProcessor<VImageDimension>::
TransformationIsValid () const
{
  return this->m_bRegistrationStarted;
};

template <unsigned int VImageDimension>
void
PointSetRegistrationProcessor<VImageDimension>::
NotifyProgress(const RegistrationStatusType status, const std::string& sComment)
{
  if(this->fnOnProgress.IsNotNull())
    this->fnOnProgress->Execute(status, sComment,this);
};

template <unsigned int VImageDimension>
typename PointSetRegistrationProcessor<VImageDimension>::TransformFunctionMediaPointer
PointSetRegistrationProcessor<VImageDimension>::
GetTransformationFunction()
{
  PointType origin;
  origin.Fill(0.0);

  RegionType region;
  typename RegionType::IndexType index;
  index.Fill(0);
  typename RegionType::SizeType size;
  size.Fill(0);
  region.SetIndex(index);
  region.SetSize(size);

  SpacingType spacing;
  spacing.Fill(1);

  return GetTransformationFunction(origin,region,spacing);
};

template <unsigned int VImageDimension>
typename PointSetRegistrationProcessor<VImageDimension>::TransformFunctionMediaPointer
PointSetRegistrationProcessor<VImageDimension>::
GetInverseTransformationFunction()
{
  PointType origin;
  origin.Fill(0.0);

  RegionType region;
  typename RegionType::IndexType index;
  index.Fill(0);
  typename RegionType::SizeType size;
  size.Fill(0);
  region.SetIndex(index);
  region.SetSize(size);

  SpacingType spacing;
  spacing.Fill(1);

  return GetInverseTransformationFunction(origin,region,spacing);
};

template <unsigned int VImageDimension>
void
PointSetRegistrationProcessor<VImageDimension>::
ReleaseInputs()
{
  Superclass::ReleaseInputs();
  this->m_FixedPointSet = NULL;
  this->m_MovingPointSet = NULL;
};

template <unsigned int VImageDimension>
void
PointSetRegistrationProcessor<VImageDimension>::
OnNewIteration(void* pSender, long threadID)
{
    if(this->fnOnNextIteration.IsNotNull())
        this->fnOnNextIteration->Execute(this->m_lCurIteration, NULL, this, 0);
    this->m_lCurIteration++;

    //Store the current position of the optimizer (thus the parameters of the transform),
    //this enables the ComputeTransformationField to compute interims transformation fields
    //of the ongoing registration process.
    //use the controller interface to get the current position. Needed for
    //optimizers with different interface behaviour (e.g. vnl optimizer)
    const GenericOptimizerController* pOptimizerCtrl = dynamic_cast<const GenericOptimizerController*>(this->m_pOptimizerCache->Controller());
    if (!pOptimizerCtrl) throwExceptionMacro("Error. Cannot get current position. Component of main optimizer cache is not a descendant of OptimizerControllerInterface.");
    this->m_CurrentTransformParameters = pOptimizerCtrl->GetCurrentPosition(this->m_pOptimizerCache);
};

}//End of Namespace free

#endif

---