freEuler3DTransformController.cxx

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: freEuler3DTransformController.cxx,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.

=========================================================================*/

#include "freEuler3DTransformController.h"
#include "freTransformSetupAdaptor.h"

namespace FREE
{



Euler3DTransformController::
Euler3DTransformController()
{
  this->UpdateControllerID(ControllerID::Euler3DTransformController);
  this->m_Description = "A combination of rotation and translation in 3 dimensions.";
};

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

  //Parameters
  profile.Parameters().AddParameter(cParam_InitialTransformValues,CtrlProfile::Parameter::PVTDouble,"1..3: rotation angel (in radian)\n4..6: x/y/z translation",6,"0");
  profile.Parameters().AddParameter(cParam_CurrentTransformValues,CtrlProfile::Parameter::PVTDouble,"1..3: rotation angel (in radian)\n4..6: x/y/z translation",6,"0");
  profile.Parameters().AddParameter(cParam_TransformScale,CtrlProfile::Parameter::PVTDouble,"1..3: rotation angel (in radian)\n4..6: x/y/z translation",6,"1",-1,true);
  profile.Parameters().AddParameter("InitialRotationAxis",Parameter::PVTInteger,"Indicates the rotiation axis used for initialisation, if the reference initialisation is used. The order of rotation is always z y x. \n-1: z y x (smart)\n0: z y x.\n1: x\n2: y\n3: y x\n4: z\n5: z x\n6: z y",1,"0");

  //Media
  profile.MediaMap().AddMedia("movingInitialImage",ControllerID::IntensityImage3DMediaController,DASet,3);
  profile.MediaMap().AddMedia("fixedInitialImage",ControllerID::IntensityImage3DMediaController,DASet,3);
};

bool
Euler3DTransformController::
SetInitialTransformValues( ComponentType* pTransformComponent,
                           SessionComponentCache* pComponentCache,
                           SessionInfo* pSessionInfo,
                           const int& iInitializeByITV) const
{
  //let the transform be initialized by MatrixOffsetTransformController
  Superclass::SetInitialTransformValues( pTransformComponent, pComponentCache, pSessionInfo, iInitializeByITV);

  int iCenterType;

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

  if (!pTransformSetup->Parameters().GetParameterValue(cParam_CenterInitializationType,iCenterType)) throwExceptionMacro("Missing parameter: " << "CenterType");

  TransformSetupAdaptor adaptor(pTransformSetup);
  ParameterArrayType itv = adaptor.GetInitialTransformParameters();

  //set current transform values to initial transform values by default
  for (int iIndex=0; iIndex<itv.Size(); iIndex++)
  {
    pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,itv[iIndex],iIndex);
  };

  if (iCenterType>1)
  { //the translation was initialized by controller and not defined
    //by ITV so copy translation to current transform values
    for (int iIndex=0; iIndex<3; iIndex++)
    {
      pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,pTransformComponent->GetTranslation().GetElement(iIndex),iIndex+3);
    }
  }

  return true;

  //TODO: old version insufficient initializer use VersorRigidTransform instead or freTensoInitializer
  //int iCenterType;

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

  //if (!pTransformSetup->Parameters().GetParameterValue(cParam_CenterInitializationType,iCenterType)) throwExceptionMacro("Missing parameter: " << "CenterType");

  //TransformSetupAdaptor adaptor(3, pTransformSetup);
  //ReferencePointsAccessor<3> pointsAccessor(pComponentCache);

  //ParameterArrayType fixedCenter(3);
  //ParameterArrayType movingCenter(3);

  //if (2==(iInitializeByITV&2))
  //{ //translation is stored in the ITV and should be used
  //  // center point x/y/z
  //  ParameterArrayType itv = adaptor.GetInitialTransformParameters();
  //  for (int iIndex=0; iIndex<3; iIndex++)
  //  {
  //    movingCenter[iIndex] = itv[3+iIndex];
  //    fixedCenter[iIndex] = 0;
  //  };
  //}
  //else
  //{ 
  //  if (iCenterType==0)
  //  { //First paire of reference points are the center points
  //    if (!pointsAccessor.MovingPointsExist()) throwCtrlExceptionMacro("","Cannot set moving center via reference points. No moving reference point set defined. Please check media linkage.");
  //    if (!pointsAccessor.FixedPointsExist()) throwCtrlExceptionMacro("","Cannot set fixed center via reference points. No fixed reference point set defined. Please check media linkage.");
  //    fixedCenter = pointsAccessor.GetFixedPointArray(0);
  //    movingCenter = pointsAccessor.GetMovingPointArray(0);
  //  }
  //  else
  //  {
  //    //Center should be calculated
  //    CenterInitializer<PixelType,3> centerInitializer;

  //    if (iCenterType==1) centerInitializer.GeometryOn();
  //    else centerInitializer.MomentsOn();

  //    typedef ImageTypes<3>::InternalImageType InternalImageType;
  //    
  //    SessionAccessor::GenericMediaPointer smpGenericInitialFixedImage = SessionAccessor::GetLinkedMedia("fixedInitialImage",pComponentCache,pSessionInfo);
  //    if (smpGenericInitialFixedImage.IsNull()) throwCtrlExceptionMacro("","Cannot set fixed center via initial image. No initial fixed image linked. Please check media linkage.");
  //    SessionAccessor::GenericMediaPointer smpGenericInitialMovingImage = SessionAccessor::GetLinkedMedia("movingInitialImage",pComponentCache,pSessionInfo);
  //    if (smpGenericInitialMovingImage.IsNull()) 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*>(smpGenericInitialFixedImage.GetPointer());
  //    }
  //    catchAllNPassMacro("Error while casting initial fixed image");
  //    if (!pInitialFixedImage) throwCtrlExceptionMacro("","Error while casting initial fixed image.");

  //    try
  //    {
  //      pInitialMovingImage = dynamic_cast<InternalImageType*>(smpGenericInitialMovingImage.GetPointer());
  //    }
  //    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);
  //  }
  //}

  //ParameterArrayType translation(3);
  //for (int iIndex=0; iIndex<3; iIndex++)
  //{
  //  translation[iIndex] = movingCenter[iIndex]-fixedCenter[iIndex];
  //};

  //  //add the calculated initial translation and center to the setup - to be present
  //  //for the Registrator - when using set initial position.
  //for (int iIndex=0; iIndex<3; iIndex++)
  //{
  //  pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,translation[iIndex],3+iIndex);
  //};

  //if (!(1==(iInitializeByITV&1)))
  //{ //Rotation should be calculated
  //  if (!pointsAccessor.MovingPointsExist()) throwCtrlExceptionMacro("","Cannot estimate rotation via reference points. No moving reference point set defined. Please check media linkage.");
  //  if (!pointsAccessor.FixedPointsExist()) throwCtrlExceptionMacro("","Cannot estimate rotation via via reference points. No fixed reference point set defined. Please check media linkage.");

  //  RotationInitializer<3> rotationInitializer;

  //  rotationInitializer.SetCenterPair(movingCenter,fixedCenter);

  //  //Add all references
  //  int iIndex = 0;
  //  if (iCenterType==0) iIndex = 1; //first reference is the center point;
  //  for (iIndex; iIndex<pointsAccessor.GetFixedPointsCount(); iIndex++)
  //  {
  //    rotationInitializer.AddReferencePair(pointsAccessor.GetMovingPointArray(iIndex),pointsAccessor.GetFixedPointArray(iIndex));
  //  };

  //  //set schedule
  //  int iInitialRotationAxis;
  //  if (!pTransformSetup->Parameters().GetParameterValue("InitialRotationAxis",iInitialRotationAxis)) throwExceptionMacro("Missing parameter: " << "InitialRotationAxis");

  //  rotationInitializer.ClearSchedule(false);
  //  if ((iInitialRotationAxis<1) | (4 == (iInitialRotationAxis & 4))) rotationInitializer.AddToSchedule(RA_Z);
  //  if ((iInitialRotationAxis<1) | (2 == (iInitialRotationAxis & 2))) rotationInitializer.AddToSchedule(RA_Y);
  //  if ((iInitialRotationAxis<1) | (1 == (iInitialRotationAxis & 1))) rotationInitializer.AddToSchedule(RA_X);

  //  rotationInitializer.SetUseRotationWeight(iInitialRotationAxis==-1);

  //  rotationInitializer.ComputeRotations();

  //  //add angel to the parameters. Angel must be inverted, because itk uses back transform
  //  //(fixed to moving) and the initial calculation uses forward transform to allow an intuitive
  //  //parameter setting
  //  pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,-1*rotationInitializer.GetRotation(RA_X),0);
  //  pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,-1*rotationInitializer.GetRotation(RA_Y),1);
  //  pTransformSetup->Parameters().SetParameterValue(cParam_CurrentTransformValues,-1*rotationInitializer.GetRotation(RA_Z),2);
  //};
  //return true;
};

} //end of namespace free

---