freClosedFormRegistrationProcessor.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: freClosedFormRegistrationProcessor.h,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 __freClosedFormRegistrationProcessor_txx
#define __freClosedFormRegistrationProcessor_txx

#include "freClosedFormRegistrationProcessor.h"
#include "freTransformSetupAdaptor.h"

#include "itkLandmarkBasedTransformInitializer.h"

namespace FREE
{


template <unsigned int VImageDimension>
const long
ClosedFormRegistrationProcessor<VImageDimension>::
GetMaxIterationCount() const
{
    return 1;
};

template <unsigned int VImageDimension>
void
ClosedFormRegistrationProcessor<VImageDimension>::
ComputeRegistration()
{
    Superclass::ComputeRegistration();

    if (this->m_Transform.IsNull())
        throwExceptionMacro("Cannot start registration; no transformation 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_lCurIteration = 0;

    try
    {
         //Connect point sets a calculate transform
        if(this->fnOnProgress.IsNotNull())
            this->fnOnProgress->Execute(RSTInitProcessor,"Computing transform via closed form solution",this);

        typedef itk::LandmarkBasedTransformInitializer<TransformType, ImageType, ImageType> LandmarkInitializerType;
        typename LandmarkInitializerType::Pointer lmInitializer = LandmarkInitializerType::New();

        lmInitializer->SetFixedLandmarks(this->m_FixedPointSet->GetPoints()->CastToSTLContainer());
        lmInitializer->SetMovingLandmarks(this->m_MovingPointSet->GetPoints()->CastToSTLContainer());
        lmInitializer->SetTransform(this->m_Transform);
        lmInitializer->InitializeTransform();
    }
    catchAllNPassMacro("Unknown Error while computing registration.");

    try
    {
      //Save the final parameters as current transform parameters
      this->m_CurrentTransformParameters = this->m_Transform->GetParameters();
      ComponentSetup* pTransformSetup = this->GetComponentSetup()->Components().GetElement(cComp_MainTransform);
      
      TransformSetupAdaptor finalTransformAdaptor(pTransformSetup);
      finalTransformAdaptor.SetCurrentTransformParameters(this->m_CurrentTransformParameters);
    }
    catchAllNPassMacro("Unknown Error while saving result.");
};

template <unsigned int VImageDimension>
ClosedFormRegistrationProcessor<VImageDimension>::
ClosedFormRegistrationProcessor()
{
    this->m_FixedPointSet = NULL;
    this->m_MovingPointSet = NULL;
};

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

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

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

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

template <unsigned int VImageDimension>
typename ClosedFormRegistrationProcessor<VImageDimension>::TransformFunctionMediaPointer
ClosedFormRegistrationProcessor<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 ClosedFormRegistrationProcessor<VImageDimension>::TransformFunctionMediaPointer
ClosedFormRegistrationProcessor<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
ClosedFormRegistrationProcessor< VImageDimension>::
ReleaseInputs()
{
  Superclass::ReleaseInputs();
  this->m_FixedPointSet = NULL;
  this->m_MovingPointSet = NULL;
};

}//End of Namespace free

#endif

---