mitk: mitkTransformFactory.txx Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date: $
00006 Version:   $Revision: $
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "mitkTransformFactory.h"
00019 #include "mitkTransformParameters.h"
00020 
00021 #include "itkTranslationTransform.h"
00022 #include "itkScaleTransform.h"
00023 #include "itkScaleLogarithmicTransform.h"
00024 #include "itkAffineTransform.h"
00025 #include "itkCenteredAffineTransform.h"
00026 #include "itkFixedCenterOfRotationAffineTransform.h"
00027 #include "itkAzimuthElevationToCartesianTransform.h"
00028 #include "itkCenteredTransformInitializer.h"
00029 #include <itkRigid3DTransform.h>
00030 #include <itkEuler3DTransform.h>
00031 #include <itkCenteredEuler3DTransform.h>
00032 #include <itkQuaternionRigidTransform.h>
00033 #include <itkVersorTransform.h>
00034 #include <itkVersorRigid3DTransform.h>
00035 #include <itkScaleSkewVersor3DTransform.h>
00036 #include <itkSimilarity3DTransform.h>
00037 #include <itkRigid2DTransform.h>
00038 #include <itkCenteredRigid2DTransform.h>
00039 #include <itkEuler2DTransform.h>
00040 #include <itkSimilarity2DTransform.h>
00041 #include <itkCenteredSimilarity2DTransform.h>
00042 
00043 
00044 
00045 namespace mitk {
00046 
00047   template < class TPixelType, unsigned int VImageDimension >
00048   TransformFactory< TPixelType, VImageDimension >::TransformFactory() : 
00049     m_TransformParameters(NULL),
00050     m_FixedImage(NULL),
00051     m_MovingImage(NULL),
00052     m_FixedImage2D(NULL),
00053     m_MovingImage2D(NULL),
00054     m_FixedImage3D(NULL),
00055     m_MovingImage3D(NULL)
00056   {
00057 
00058   }
00059   
00060   template < class TPixelType, unsigned int VImageDimension >
00061   void TransformFactory< TPixelType, VImageDimension >::SetFixedImage(FixedImageType* fixed)
00062   {
00063     if (VImageDimension == 2)
00064     {
00065       m_FixedImage2D = reinterpret_cast<FixedImage2DType*>(fixed);
00066       m_FixedImage = fixed;
00067     }
00068     else
00069     {
00070       m_FixedImage3D = reinterpret_cast<FixedImage3DType*>(fixed);;
00071       m_FixedImage = fixed;
00072     }
00073   }
00074   
00075   template < class TPixelType, unsigned int VImageDimension >
00076   void TransformFactory< TPixelType, VImageDimension >::SetMovingImage(MovingImageType* moving)
00077   {
00078     if (VImageDimension == 2)
00079     {
00080       m_MovingImage2D = reinterpret_cast<MovingImage2DType*>(moving);
00081       m_MovingImage = moving;
00082     }
00083     else
00084     {
00085       m_MovingImage3D = reinterpret_cast<MovingImage3DType*>(moving);
00086       m_MovingImage = moving;
00087     }
00088   }
00089 
00090   /*template < class TPixelType, unsigned int VImageDimension >
00091   typename ::itk::Transform< double, VImageDimension, VImageDimension >::Pointer 
00092   MakeRigidTransform();
00093 
00094   template <class TPixelType>
00095   typename ::itk::Transform< double, 3, 3 >::Pointer
00096   MakeRigidTransform<TPixelType, 3>()
00097   {
00098     itk::Rigid3DTransform< double >::Pointer transform = itk::Rigid3DTransform< double >::New();
00099     transform->SetIdentity();
00100     return transform.GetPointer();
00101   }
00102 
00103   template <class TPixelType>
00104   typename ::itk::Transform< double, 2, 2 >::Pointer
00105   MakeRigidTransform<TPixelType, 2>()
00106   {
00107     return NULL;
00108   }*/
00109 
00110   /*template < unsigned int VImageDimension >
00111   typename ::itk::Transform< double, VImageDimension, VImageDimension >::Pointer 
00112   MakeRigidTransform();
00113 
00114   template <>
00115   typename ::itk::Transform< double, 3, 3 >::Pointer
00116   MakeRigidTransform<3>()
00117   {
00118     itk::Rigid3DTransform< double >::Pointer transform = itk::Rigid3DTransform< double >::New();
00119     transform->SetIdentity();
00120     return transform.GetPointer();
00121   }
00122 
00123   template <>
00124   typename ::itk::Transform< double, 2, 2 >::Pointer
00125   MakeRigidTransform<2>()
00126   {
00127     return NULL;
00128   }*/
00129 //
00130 //template<class T, class U, int I> class X
00131 //  { void f() { cout << "Primary template" << endl; } };
00132 //template<class T> class X<int, T*, 10>
00133 //  { void f() { cout << "Partial specialization 3" << endl;
00134 //  } };
00135 // 
00136 //
00137 //template < class TPixelType > class TransformFactory<TPixelType, 3>
00138 //{
00139 //  typedef typename itk::Transform< double, 3, 3 >    TransformType;
00140 //  typedef typename TransformType::Pointer TransformPointer;
00141 //
00142 //  typename TransformPointer MakeRigidTransform()
00143 //    {
00144 //    }
00145 //};
00146 
00147 
00148   //template <>
00149   //  typename TransformFactory< double, 3 >::TransformPointer
00150   //    TransformFactory< double, 3 >::MakeRigidTransform()
00151   //{
00152   //  itk::Rigid3DTransform< double >::Pointer transform = itk::Rigid3DTransform< double >::New();
00153   //  transform->SetIdentity();
00154   //  return transform.GetPointer();
00155   //}
00156 
00157   //template <>
00158   //  typename TransformFactory< double, 2 >::TransformPointer
00159   //    TransformFactory< double, 2 >::MakeRigidTransform()
00160   //{
00161   //  return NULL;
00162   //}
00163 
00164   template < class TPixelType, unsigned int VImageDimension >
00165     typename TransformFactory< TPixelType, VImageDimension >::TransformPointer
00166     TransformFactory< TPixelType, VImageDimension >::GetTransform()
00167   {
00168     int transform = m_TransformParameters->GetTransform();
00169     if (transform == TransformParameters::TRANSLATIONTRANSFORM)
00170     {
00171     typename itk::TranslationTransform< double, VImageDimension>::Pointer transformPointer = itk::TranslationTransform< double, VImageDimension>::New();
00172       transformPointer->SetIdentity();
00173     return transformPointer.GetPointer();
00174     }
00175     else if (transform == TransformParameters::SCALETRANSFORM)
00176     {
00177       typename itk::ScaleTransform< double, VImageDimension>::Pointer transformPointer = itk::ScaleTransform< double, VImageDimension>::New();
00178       transformPointer->SetIdentity();
00179       return transformPointer.GetPointer();
00180     }
00181     else if (transform == TransformParameters::SCALELOGARITHMICTRANSFORM)
00182     {
00183       typename itk::ScaleLogarithmicTransform< double, VImageDimension>::Pointer transformPointer = itk::ScaleLogarithmicTransform< double, VImageDimension>::New();
00184       transformPointer->SetIdentity();
00185       return transformPointer.GetPointer();
00186     }
00187     else if (transform == TransformParameters::AFFINETRANSFORM)
00188     {
00189       typename itk::AffineTransform< double, VImageDimension>::Pointer transformPointer = itk::AffineTransform< double, VImageDimension>::New();    
00190       transformPointer->SetIdentity();
00191       if (m_TransformParameters->GetTransformInitializerOn())
00192       {
00193         typedef typename itk::AffineTransform< double, VImageDimension >    AffineTransformType;
00194         typedef typename itk::CenteredTransformInitializer<AffineTransformType, FixedImageType, MovingImageType> TransformInitializerType;
00195         typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
00196         transformInitializer->SetFixedImage( m_FixedImage );
00197         transformInitializer->SetMovingImage( m_MovingImage );
00198         transformInitializer->SetTransform( transformPointer );
00199         if (m_TransformParameters->GetMomentsOn())
00200         {
00201           transformInitializer->MomentsOn();
00202         }
00203         else
00204         {
00205           transformInitializer->GeometryOn();
00206         }
00207         transformInitializer->InitializeTransform();        
00208       }
00209       m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00210       m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00211       m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00212       return transformPointer.GetPointer();
00213     }
00214     else if (transform == TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
00215     {
00216       typedef typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension >    CenteredAffineTransformType;
00217       typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension>::Pointer transformPointer = itk::FixedCenterOfRotationAffineTransform< double, VImageDimension>::New();
00218       transformPointer->SetIdentity();
00219       if (m_TransformParameters->GetTransformInitializerOn())
00220       {
00221         typedef typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension >    FixedCenterOfRotationAffineTransformType;
00222         typedef typename itk::CenteredTransformInitializer<FixedCenterOfRotationAffineTransformType, FixedImageType, MovingImageType> TransformInitializerType;
00223         typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
00224         transformInitializer->SetFixedImage( m_FixedImage );
00225         transformInitializer->SetMovingImage( m_MovingImage );
00226         transformInitializer->SetTransform( transformPointer );
00227         if (m_TransformParameters->GetMomentsOn())
00228         {
00229           transformInitializer->MomentsOn();
00230         }
00231         else
00232         {
00233           transformInitializer->GeometryOn();
00234         }
00235         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00236         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00237         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00238         transformInitializer->InitializeTransform();        
00239       }
00240       return transformPointer.GetPointer();
00241     }
00242     else if (transform == TransformParameters::RIGID3DTRANSFORM)
00243     {
00244       //return MakeRigidTransform<VImageDimension>();
00245       if (VImageDimension == 3)
00246       {
00247         typename itk::Rigid3DTransform< double >::Pointer transformPointer = itk::Rigid3DTransform< double >::New();
00248         transformPointer->SetIdentity();
00249         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00250         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00251         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00252         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00253       }
00254     }
00255     else if (transform == TransformParameters::EULER3DTRANSFORM)
00256     {
00257       if (VImageDimension == 3)
00258       {
00259         typename itk::Euler3DTransform< double >::Pointer transformPointer = itk::Euler3DTransform< double >::New();
00260         transformPointer->SetIdentity();
00261         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00262         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00263         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00264         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00265       }
00266     }
00267     else if (transform == TransformParameters::CENTEREDEULER3DTRANSFORM)
00268     {
00269       if (VImageDimension == 3)
00270       {
00271         typename itk::CenteredEuler3DTransform< double >::Pointer transformPointer = itk::CenteredEuler3DTransform< double >::New();
00272         transformPointer->SetIdentity();
00273         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00274         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00275         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00276         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00277       }
00278     }
00279     else if (transform == TransformParameters::QUATERNIONRIGIDTRANSFORM)
00280     {
00281       if (VImageDimension == 3)
00282       {
00283         typename itk::QuaternionRigidTransform< double >::Pointer transformPointer = itk::QuaternionRigidTransform< double >::New();
00284         transformPointer->SetIdentity();
00285         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00286         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00287         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00288         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00289       }
00290     }
00291     else if (transform == TransformParameters::VERSORTRANSFORM)
00292     {
00293       if (VImageDimension == 3)
00294       {
00295         typename itk::VersorTransform< double >::Pointer transformPointer = itk::VersorTransform< double >::New();
00296         transformPointer->SetIdentity();
00297         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00298         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00299         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00300         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00301       }
00302     }
00303     else if (transform == TransformParameters::VERSORRIGID3DTRANSFORM)
00304     {
00305       if (VImageDimension == 3)
00306       {
00307         typename itk::VersorRigid3DTransform< double >::Pointer transformPointer = itk::VersorRigid3DTransform< double >::New();
00308         transformPointer->SetIdentity();
00309         typedef typename itk::VersorRigid3DTransform< double >    VersorRigid3DTransformType;
00310         if (m_TransformParameters->GetTransformInitializerOn())
00311         {
00312           typedef typename itk::CenteredTransformInitializer<VersorRigid3DTransformType, FixedImage3DType, MovingImage3DType> TransformInitializerType;
00313           typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
00314           transformInitializer->SetFixedImage( m_FixedImage3D );
00315           transformInitializer->SetMovingImage( m_MovingImage3D );
00316           transformInitializer->SetTransform( transformPointer );
00317           if (m_TransformParameters->GetMomentsOn())
00318           {
00319             transformInitializer->MomentsOn();
00320           }
00321           else
00322           {
00323             transformInitializer->GeometryOn();
00324           }
00325           transformInitializer->InitializeTransform();
00326         }
00327         typedef VersorRigid3DTransformType::VersorType  VersorType;
00328         typedef VersorType::VectorType     VectorType;
00329 
00330         VersorType     rotation;
00331         VectorType     axis;
00332   
00333         axis[0] = 0.0;
00334         axis[1] = 0.0;
00335         axis[2] = 1.0;
00336 
00337         const double angle = 0;
00338 
00339         rotation.Set(  axis, angle  );
00340 
00341         transformPointer->SetRotation( rotation );
00342         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00343         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00344         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00345         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00346       }
00347     }
00348     else if (transform == TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
00349     {
00350       if (VImageDimension == 3)
00351       {
00352         typename itk::ScaleSkewVersor3DTransform< double >::Pointer transformPointer = itk::ScaleSkewVersor3DTransform< double >::New();
00353         transformPointer->SetIdentity();
00354         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00355         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00356         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00357         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00358       }
00359     }
00360     else if (transform == TransformParameters::SIMILARITY3DTRANSFORM)
00361     {
00362       if (VImageDimension == 3)
00363       {
00364         typename itk::Similarity3DTransform< double >::Pointer transformPointer = itk::Similarity3DTransform< double >::New();
00365         transformPointer->SetIdentity();
00366         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00367         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00368         m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
00369         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00370       }
00371     }
00372     else if (transform == TransformParameters::RIGID2DTRANSFORM)
00373     {
00374       if (VImageDimension == 2)
00375       {
00376         typename itk::Rigid2DTransform< double >::Pointer transformPointer = itk::Rigid2DTransform< double >::New();
00377         transformPointer->SetIdentity();
00378         transformPointer->SetAngle( m_TransformParameters->GetAngle() );
00379         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00380         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00381         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00382       }
00383     }
00384     else if (transform == TransformParameters::CENTEREDRIGID2DTRANSFORM)
00385     {
00386       if (VImageDimension == 2)
00387       {
00388         typename itk::CenteredRigid2DTransform< double >::Pointer transformPointer = itk::CenteredRigid2DTransform< double >::New();
00389         transformPointer->SetIdentity();
00390         if (m_TransformParameters->GetTransformInitializerOn())
00391         {
00392           typedef typename itk::CenteredRigid2DTransform< double >    CenteredRigid2DTransformType;
00393           typedef typename itk::CenteredTransformInitializer<CenteredRigid2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
00394           typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
00395           transformInitializer->SetFixedImage( m_FixedImage2D );
00396           transformInitializer->SetMovingImage( m_MovingImage2D );
00397           transformInitializer->SetTransform( transformPointer );
00398           if (m_TransformParameters->GetMomentsOn())
00399           {
00400             transformInitializer->MomentsOn();
00401           }
00402           else
00403           {
00404             transformInitializer->GeometryOn();
00405           }
00406         transformInitializer->InitializeTransform();
00407         }
00408         transformPointer->SetAngle( m_TransformParameters->GetAngle() );
00409         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00410         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00411         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00412       }
00413     }
00414     else if (transform == TransformParameters::EULER2DTRANSFORM)
00415     {
00416       if (VImageDimension == 2)
00417       {
00418         typename itk::Euler2DTransform< double >::Pointer transformPointer = itk::Euler2DTransform< double >::New();
00419         transformPointer->SetIdentity();
00420         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00421         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00422         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00423       }
00424     }
00425     else if (transform == TransformParameters::SIMILARITY2DTRANSFORM)
00426     {
00427       if (VImageDimension == 2)
00428       {
00429         typename itk::Similarity2DTransform< double >::Pointer transformPointer = itk::Similarity2DTransform< double >::New();
00430         transformPointer->SetIdentity();
00431         transformPointer->SetScale( m_TransformParameters->GetScale() );
00432         transformPointer->SetAngle( m_TransformParameters->GetAngle() );
00433         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00434         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00435         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00436       }
00437     }
00438     else if (transform == TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
00439     {
00440       if (VImageDimension == 2)
00441       {
00442         typename itk::CenteredSimilarity2DTransform< double >::Pointer transformPointer = itk::CenteredSimilarity2DTransform< double >::New();
00443         transformPointer->SetIdentity();
00444         if (m_TransformParameters->GetTransformInitializerOn())
00445         {
00446           typedef typename itk::CenteredSimilarity2DTransform< double >    CenteredSimilarity2DTransformType;
00447           typedef typename itk::CenteredTransformInitializer<CenteredSimilarity2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
00448           typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
00449           transformInitializer->SetFixedImage( m_FixedImage2D );
00450           transformInitializer->SetMovingImage( m_MovingImage2D );
00451           transformInitializer->SetTransform( transformPointer );
00452           if (m_TransformParameters->GetMomentsOn())
00453           {
00454             transformInitializer->MomentsOn();
00455           }
00456           else
00457           {
00458             transformInitializer->GeometryOn();
00459           }
00460           transformInitializer->InitializeTransform();        
00461         }
00462         transformPointer->SetScale( m_TransformParameters->GetScale() );
00463         transformPointer->SetAngle( m_TransformParameters->GetAngle() );
00464         m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
00465         m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
00466         return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
00467       }
00468     }
00469     return NULL;
00470   }
00471 } // end namespace