freTranslationTransformController.h

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: freTranslationTransformController.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 __freTranslationTransformController_h
#define __freTranslationTransformController_h

#include "freITKTransformControllerBase.h"
#include "freTransformInitializer.h"

#include "freIntensityImageMediaController.h"

#include "itkTranslationTransform.h"

namespace FREE
{

  freControllerIDMacro(TranslationTransformControllerBase, "TranslationTransformBase");
template <int VDimension>
class TranslationTransformControllerBase : public ITKTransformControllerBase< itk::TranslationTransform < ScalarType, VDimension >, VDimension >
{
public:  
  typedef itk::TranslationTransform < ScalarType, VDimension > ComponentType;
  typedef ITKTransformControllerBase<ComponentType, VDimension> Superclass;

  itkTypeMacro(TranslationTransformControllerBase, ITKTransformControllerBase);

  DeclareParameterMacro(TranslationInitializationType);

protected:
  TranslationTransformControllerBase()
  {
    //Profile settings
    this->UpdateControllerID(ControllerID::TranslationTransformControllerBase);
    this->m_Description = "A rigid translation transform.";
  };

  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                               const SessionComponentCache* pComponentCache,
                               bool bRegardOldSetup) const
  {
    Superclass::GenerateProfile(profile,pComponentCache,bRegardOldSetup);

    //Parameters
    profile.Parameters().AddParameter(cParam_TranslationInitializationType,Parameter::PVTInteger,cParamDsc_TranslationInitializationType,1,"0");
    profile.Parameters().AddParameter(cParam_InitialisationMethod,Parameter::PVTInteger,std::string(cParamDsc_InitialisationMethod)+"\n1: translation is set by itv",1,"0");

   //Media
    if (VDimension==2)
    {
      profile.MediaMap().AddMedia("movingInitialImage",ControllerID::IntensityImage2DMediaController,DASet,VDimension);
      profile.MediaMap().AddMedia("fixedInitialImage",ControllerID::IntensityImage2DMediaController,DASet,VDimension);
    }
    else
    {
      profile.MediaMap().AddMedia("movingInitialImage",ControllerID::IntensityImage3DMediaController,DASet,VDimension);
      profile.MediaMap().AddMedia("fixedInitialImage",ControllerID::IntensityImage3DMediaController,DASet,VDimension);
    }
  };

  virtual bool SetInitialTransformValues( ComponentType* pTransformComponent,
                                          SessionComponentCache* pComponentCache,
                                          SessionInfo* pSessionInfo,
                                                                                                                                                            const int& iInitializeByITV) const
  {
    if (!iInitializeByITV)
    {
      ParameterArrayType translation(VDimension);

      int iTransInitType;

      if (!pComponentCache->SetupIsAssigned()) throwCtrlExceptionMacro("","Cannot initialize transform values, transform setup is not assigned in cache.");
      ComponentSetup* pTransformSetup = pComponentCache->Setup();

      if (!pTransformSetup->Parameters().GetParameterValue(cParam_TranslationInitializationType,iTransInitType)) throwExceptionMacro("Missing parameter: " << cParam_TranslationInitializationType);

      if (iTransInitType)
      {//calculate by the images.
        ParameterArrayType fixedCenter(VDimension);
        ParameterArrayType movingCenter(VDimension);

        CenterInitializer<PixelType,VDimension> centerInitializer;

        if (iTransInitType==1) centerInitializer.GeometryOn();
        else centerInitializer.MomentsOn();

        typedef typename ImageTypes<VDimension>::InternalImageType InternalImageType;
      
        SessionComponentCache::GenericComponentType* pGenericInitialFixedImage = DirectSessionComponentAccessor::GetRepositoryElement("fixedInitialImage",pComponentCache);
        SessionComponentCache::GenericComponentType* pGenericInitialMovingImage = DirectSessionComponentAccessor::GetRepositoryElement("movingInitialImage",pComponentCache);
        if (!pGenericInitialFixedImage) throwCtrlExceptionMacro("","Cannot set fixed center via initial image. No initial fixed image linked. Please check media linkage.");
        if (!pGenericInitialMovingImage) throwCtrlExceptionMacro("","Cannot set moving center via initial image. No initial fixed image linked. Please check media linkage.");
        
        InternalImageType* pInitialFixedImage = 0;
        InternalImageType* pInitialMovingImage = 0;

        try
        {
          pInitialFixedImage = dynamic_cast<InternalImageType*>(pGenericInitialFixedImage);
        }
        catchAllNPassMacro("Error while casting initial fixed image");
        if (!pInitialFixedImage) throwCtrlExceptionMacro("","Error while casting initial fixed image.");

        try
        {
          pInitialMovingImage = dynamic_cast<InternalImageType*>(pGenericInitialMovingImage);
        }
        catchAllNPassMacro("Error while casting initial fixed image");
        if (!pInitialMovingImage) throwCtrlExceptionMacro("","Error while casting initial fixed image.");

        centerInitializer.SetImage(pInitialFixedImage);
        centerInitializer.GetCenter(fixedCenter);

        centerInitializer.SetImage(pInitialMovingImage);
        centerInitializer.GetCenter(movingCenter);

        for (int iIndex=0; iIndex<VDimension; iIndex++)
        {
          translation[iIndex] = movingCenter[iIndex]-fixedCenter[iIndex];
        };
      }
      else
      {
        ReferencePointsAccessor<VDimension> pointsAccessor(pComponentCache);

        if (!pointsAccessor.MovingPointsExist()) throwCtrlExceptionMacro("","Cannot estimate translation via reference points. No moving reference point set defined. Please check media linkage.");
        if (!pointsAccessor.FixedPointsExist()) throwCtrlExceptionMacro("","Cannot estimate translation via via reference points. No fixed reference point set defined. Please check media linkage.");

        translation.fill(0);
        for (int iIndex = 0; iIndex<pointsAccessor.GetFixedPointsCount(); iIndex++)
        {
          ParameterArrayType movingRef = pointsAccessor.GetMovingPointArray(iIndex);
          ParameterArrayType fixedRef = pointsAccessor.GetFixedPointArray(iIndex);

          for (int iIndex=0; iIndex<VDimension; iIndex++)
          {
            translation[iIndex] += movingRef[iIndex] - fixedRef[iIndex];
          };
        };

        int iCoupleCount = pointsAccessor.GetFixedPointsCount();
        if (iCoupleCount<1) iCoupleCount = 1;
        for (int iIndex=0; iIndex<VDimension; iIndex++)
        {
          translation[iIndex] = translation[iIndex]/iCoupleCount;
        };
      }

      for (int iIndex=0; iIndex<pTransformSetup->Parameters().ParameterSize(cParam_CurrentTransformValues); iIndex++)
      {
        pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,translation[iIndex],iIndex);
      };
    };
    return true;
  };

  void SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia, ComponentType* pComponent, SessionComponentCache* pComponentCache,
                 SessionInfo* pSessionInfo) const
  {
    if (mediaID == "movingInitialImage")
    {
      DirectSessionComponentAccessor::SetRepositoryElement("movingInitialImage",pMedia,pComponentCache);
    }
    else if (mediaID == "fixedInitialImage")
    {
      DirectSessionComponentAccessor::SetRepositoryElement("fixedInitialImage",pMedia,pComponentCache);
    }
    else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
  };

};

template <int VDimension>
const char* const TranslationTransformControllerBase<VDimension>::
cParam_TranslationInitializationType = "TranslationInitializationType";

template <int VDimension>
const char* const TranslationTransformControllerBase<VDimension>::
cParamDsc_TranslationInitializationType = "Type of translation computation.\n0: Translation will be estimated by the translation vectors of all reference pairs.\n1: Use geometrical image centers for the translation calculation\n2: Use centers of mass for translation calculation.";


  freControllerIDMacro(Translation2DTransformController, "Translation 2D Transform");
class Translation2DTransformController : public TranslationTransformControllerBase<2>
{
public:  
  itkTypeMacro(Translation2DTransformController, TranslationTransformControllerBase);

        Translation2DTransformController();

protected:
  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                               const SessionComponentCache* pComponentCache,
                               bool bRegardOldSetup) const;
};

  freControllerIDMacro(Translation3DTransformController, "Translation 3D Transform");
class Translation3DTransformController : public TranslationTransformControllerBase<3>
{
public:  
  itkTypeMacro(Translation3DTransformController, TranslationTransformControllerBase);

        Translation3DTransformController();

protected:
  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                               const SessionComponentCache* pComponentCache,
                               bool bRegardOldSetup) const;
};

} //end of namespace free

#endif

---