freRigidRegistrationProcessor.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: freRigidRegistrationProcessor.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 __freRigidRegistrationProcessor_txx
#define __freRigidRegistrationProcessor_txx

#include "freRigidRegistrationProcessor.h"
#include "freOptimizerControllerBase.h"
#include "freTransformSetupAdaptor.h"

namespace FREE
{



template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
SingleRigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
ComputeRegistration()
{
    long optimizerObserverID = 0;

    try
    {
        RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::ComputeRegistration();

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

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

        //Connect images
        if(this->fnOnProgress.IsNotNull())
            this->fnOnProgress->Execute(RSTInitProcessor, "Connecting images",this);
        this->m_Registration->SetFixedImage(this->m_smpFixedImage);
        this->m_Registration->SetMovingImage(this->m_smpMovingImage);

        //Set ROI
        //TODO Regions will only defined via the metrics now and not by using the registration
        //Add the maskimage and and region media to ImageToImageMetrics
        //RegionType region = smpFixedPart->GetLargestPossibleRegion();
        //this->m_Registration->SetFixedImageRegion(region);

        //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 <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
SingleRigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
SingleRigidRegistrationProcessorBase():RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>()
{}
;

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
SingleRigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
~SingleRigidRegistrationProcessorBase()
{}
;




template <unsigned int VImageDimension>
RigidRegistrationProcessor<VImageDimension>::
RigidRegistrationProcessor():SingleRigidRegistrationProcessorBase< RegistrationType, TransformType, InterpolatorType, MetricType, OptimizerType, VImageDimension>()
{}
;

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



template <unsigned int VImageDimension>
const int
MultiRigidRegistrationProcessor<VImageDimension>::
GetResolutionLevelCount() const
{
    int iLevelCount;
    if (this->GetComponentSetup())
        if (this->GetComponentSetup()->Parameters().GetParameterValue(cParam_MRRegLevel,iLevelCount))
            return iLevelCount;
    return 1;
};

template <unsigned int VImageDimension>
void
MultiRigidRegistrationProcessor<VImageDimension>::
ComputeRegistration()
{
    long optimizerObserverID = 0;
    try
    {
        Superclass::ComputeRegistration();

        m_bFirstResLevel = true;
        this->m_iResolutionLevel = 0;

        int iLevelNumber;
        this->GetComponentSetup()->Parameters().GetParameterValue(cParam_MRRegLevel,iLevelNumber);
        this->m_Registration->SetNumberOfLevels(iLevelNumber);

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

        SessionBuilder::ActualizeComponent(this->m_pComponentCache, this->m_pSessionInfo);
        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());

        //Prepare multi resolution pyramids
        bool bUseSchedule;
        this->GetComponentSetup()->Parameters().GetParameterValue(cParam_MRRegUseSchedule,bUseSchedule);

        if (bUseSchedule)
        {
            //Create schedule
            int iPixelSize;
            itk::Array2D<unsigned int> schedule(iLevelNumber,VImageDimension);
            for (int iLevel=0; iLevel<iLevelNumber; iLevel++)
            {
                for (int iDim=0; iDim<VImageDimension; iDim++)
                {
                    this->GetComponentSetup()->Parameters().GetParameterValue(cParam_MRRegResolutionSchedule,iPixelSize,iDim,iLevel);
                    schedule[iLevel][iDim] = iPixelSize;
                };
            };
            smpFixedImagePyramid->SetNumberOfLevels(iLevelNumber);
            smpMovingImagePyramid->SetNumberOfLevels(iLevelNumber);
            smpFixedImagePyramid->SetSchedule(schedule);
            smpMovingImagePyramid->SetSchedule(schedule);
        }

        this->m_Registration->SetFixedImagePyramid( smpFixedImagePyramid );
        this->m_Registration->SetMovingImagePyramid( smpMovingImagePyramid );

        //Connect images
        if(this->fnOnProgress.IsNotNull())
            this->fnOnProgress->Execute(RSTInitProcessor, "Connecting images",this);

        this->m_Registration->SetFixedImage(this->m_smpFixedImage);
        this->m_Registration->SetMovingImage(this->m_smpMovingImage);

        //Set ROI
        //TODO Regions should only defined via the metrics now and not by using the registration
        //Add the maskimage and and region media to ImageToImageMetrics
        //RegionType region = this->m_smpFixedImage->GetLargestPossibleRegion();
        //if (this->m_smpROIs.IsNotNull())
        //    region.Crop(this->GetFixedROI()->GetITKImageRegion(this->m_smpFixedImage->GetSpacing()));
        //Remark: the multi resulution registration needs the fixed image region to be set,
        //otherwise the image pyramides would produce useless images
        this->m_Registration->SetFixedImageRegion(this->m_smpFixedImage->GetLargestPossibleRegion());

        //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;
        this->m_LevelObserver->fnOnNotify = m_LevelNotificationEvent;

        optimizerObserverID = this->m_Optimizer->AddObserver(itk::IterationEvent(), this->m_IterationObserver);
        this->m_Registration->AddObserver(itk::IterationEvent(), m_LevelObserver);

        // Setting maximize/minimize for the optimizer is done by the optimzer 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,"Starting registration",this);
        this->m_Registration->StartRegistration();

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

    //Save the final 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>
MultiRigidRegistrationProcessor<VImageDimension>::
MultiRigidRegistrationProcessor():RigidRegistrationProcessorBase< RegistrationType, TransformType, InterpolatorType, MetricType, OptimizerType, VImageDimension>()
{
    smpFixedImagePyramid = PyramidType::New();
    smpMovingImagePyramid = PyramidType::New();
    m_LevelObserver = IterationObserver::New();
    m_LevelNotificationEvent = NotificationEvent<MultiRigidRegistrationProcessor>::New(this, &Self::OnNewLevel);
};

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

template <unsigned int VImageDimension>
void
MultiRigidRegistrationProcessor<VImageDimension>::
OnNewLevel(void* pSender, long threadID)
{
    if (m_bFirstResLevel)
        m_bFirstResLevel = false;
    else
    {
        this->m_iResolutionLevel++;
        try
        {
            if (this->m_iResolutionLevel>0)
            {
                SessionBuilder::ActualizeComponent(this->m_pComponentCache, this->m_pSessionInfo, this->m_iResolutionLevel);
                //the first level has been initialized in StartRegistration()
            }
        }
        catchAllNPassMacro("Unknown error, while actualizing the setup parameters during a level change.");
    }

    this->m_lCurIteration = 0;

    if (this->fnOnNextLevel)
    {
        try
        {
            if(this->fnOnNextLevel.IsNotNull())
                this->fnOnNextLevel->Execute(this->m_iResolutionLevel,this);
        }
        catchAllNPassMacro("Unknown error, while calling OnNextLevel event.");
    };
};

}//End of Namespace free

#endif

---