freRigidRegistrationProcessorBase.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: freRigidRegistrationProcessorBase.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 __freRigidRegistrationProcessorBase_txx
#define __freRigidRegistrationProcessorBase_txx

#include "freRigidRegistrationProcessorBase.h"
#include "freOptimizerControllerBase.h"

namespace FREE
{


template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
SetMetric(MetricType* pMetric)
{
  if (pMetric != m_Metric.GetPointer())
  {
    m_Metric = pMetric;
    if (m_Registration.IsNotNull()) m_Registration->SetMetric(pMetric);
  }
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
SetTransform(TransformType* pTransform)
{
  if (pTransform != this->m_Transform.GetPointer())
  {
    this->m_Transform = pTransform;
    if (m_Registration.IsNotNull()) m_Registration->SetTransform(pTransform);
  }
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
SetOptimizer(OptimizerType* pOptimizer)
{
  if (pOptimizer != m_Optimizer.GetPointer())
  {
    m_Optimizer = pOptimizer;
    if (m_Registration.IsNotNull()) m_Registration->SetOptimizer(pOptimizer);
  }
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
SetInterpolator(InterpolatorType* pInterpolator)
{
  if (pInterpolator != m_Interpolator.GetPointer())
  {
    m_Interpolator = pInterpolator;
    if (m_Registration.IsNotNull()) m_Registration->SetInterpolator(pInterpolator);
  }
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
const long
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, 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 <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
ComputeRegistration()
{
    Superclass::ComputeRegistration();
    if (this->m_Transform.IsNull())
        throwExceptionMacro("Cannot start registration; no transformation component available.");
    if (this->m_Interpolator.IsNull())
        throwExceptionMacro("Cannot start registration; no interpolation 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_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;
    //Rest will be defined in derived versions of the base class;
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
RigidRegistrationProcessorBase()
{
    this->m_Interpolator = NULL;
    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 <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
~RigidRegistrationProcessorBase()
{}
;

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
typename RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::TransformFieldPointer
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
ComputeTransformationField(const PointType& origin, const RegionType& region, const SpacingType& spacing)
{
  return TransformInterface::ComputeTransformationField(origin,region,spacing);
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
bool
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
TransformationIsValid () const
{
  return this->m_bRegistrationStarted;
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
NotifyProgress(const RegistrationStatusType status, const std::string& sComment)
{
  if(this->fnOnProgress.IsNotNull())
    this->fnOnProgress->Execute(status, sComment,this);
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
typename RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::TransformFunctionMediaPointer
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
GetTransformationFunction()
{
  return GetTransformationFunction(this->m_FixedOrigin,this->m_FixedRegion,this->m_FixedSpacing);
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
typename RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::TransformFunctionMediaPointer
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
GetInverseTransformationFunction()
{
  return GetInverseTransformationFunction(this->m_FixedOrigin,this->m_FixedRegion,this->m_FixedSpacing);
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, 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);
};

template <class TRegistrationMethod, class TTransformBase, class TInterpolateBase,
class TMetricBase, class TOptimizerBase, unsigned int VImageDimension>
void
RigidRegistrationProcessorBase<TRegistrationMethod, TTransformBase, TInterpolateBase, TMetricBase, TOptimizerBase, VImageDimension>::
ResetInternals()
{
    //Set images to null to force the metric to release the images;
    this->m_Registration->SetFixedImage(0);
    this->m_Registration->SetMovingImage(0);
    //Reset the registration by creating a new one.
    this->m_Registration = RegistrationType::New();
};

}//End of Namespace free

#endif

---