Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes

mitk::TransformFactory< TPixelType, VImageDimension > Class Template Reference
[Classes related to rigid registration]

This class creates a transform for a rigid registration process. More...

#include <mitkTransformFactory.h>

List of all members.

Public Types

typedef TransformFactory Self
typedef itk::Object Superclass
typedef itk::SmartPointer< Self > Pointer
typedef itk::SmartPointer
< const Self > 		ConstPointer
typedef itk::Image< TPixelType,
VImageDimension > 		FixedImageType
typedef itk::Image< TPixelType,
VImageDimension > 		MovingImageType
typedef itk::Image< TPixelType, 2 > FixedImage2DType
typedef itk::Image< TPixelType, 2 > MovingImage2DType
typedef itk::Image< TPixelType, 3 > FixedImage3DType
typedef itk::Image< TPixelType, 3 > MovingImage3DType
typedef itk::Transform< double,
VImageDimension,
VImageDimension > 		TransformType
typedef TransformType::Pointer TransformPointer

Public Member Functions

virtual const char * GetClassName () const
TransformPointer GetTransform ()
 Returns the transform which then can be used in combination with a metric, an optimizer and an interpolator within a registration pipeline.
void SetFixedImage (FixedImageType *fixed)
 Sets the fixed image which is needed by transform initializer.
void SetMovingImage (MovingImageType *moving)
 Sets the moving image which is needed by transform initializer.
void SetTransformParameters (TransformParameters::Pointer transformParameters)
 Sets the instance to the transform parameters class which holds all parameters for the new transform.
TransformParameters::Pointer GetTransformParameters ()
 Returns the instance to the transform parameters class which holds all parameters for the new transform.

Static Public Member Functions

static Pointer New ()

Protected Member Functions

 TransformFactory ()
 ~TransformFactory ()

Protected Attributes

TransformParameters::Pointer m_TransformParameters
FixedImageType::Pointer m_FixedImage
MovingImageType::Pointer m_MovingImage
FixedImage2DType::Pointer m_FixedImage2D
MovingImage2DType::Pointer m_MovingImage2D
FixedImage3DType::Pointer m_FixedImage3D
MovingImage3DType::Pointer m_MovingImage3D

Detailed Description

template<class TPixelType, unsigned int VImageDimension>
class mitk::TransformFactory< TPixelType, VImageDimension >

This class creates a transform for a rigid registration process.

This class will e.g. be instantiated by mitkImageRegistrationMethod and a transform corresponding to the integer value stored in mitkTransformParameters will be created. Therefore SetTransformParameters() has to be called with an instance of mitkTransformParameters, which holds all parameter informations for the new transformation.

GetTransform() returns the transform which then can be used in combination with a metric, an optimizer and an interpolator within a registration pipeline.

Author:
Daniel Stein

Definition at line 47 of file mitkTransformFactory.h.

Member Typedef Documentation

template<class TPixelType, unsigned int VImageDimension>
typedef itk::SmartPointer<const Self> mitk::TransformFactory< TPixelType, VImageDimension >::ConstPointer

Definition at line 50 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Image< TPixelType, 2 > mitk::TransformFactory< TPixelType, VImageDimension >::FixedImage2DType

Definition at line 57 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Image< TPixelType, 3 > mitk::TransformFactory< TPixelType, VImageDimension >::FixedImage3DType

Definition at line 59 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Image< TPixelType, VImageDimension > mitk::TransformFactory< TPixelType, VImageDimension >::FixedImageType

Definition at line 53 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Image< TPixelType, 2 > mitk::TransformFactory< TPixelType, VImageDimension >::MovingImage2DType

Definition at line 58 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Image< TPixelType, 3 > mitk::TransformFactory< TPixelType, VImageDimension >::MovingImage3DType

Definition at line 60 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Image< TPixelType, VImageDimension > mitk::TransformFactory< TPixelType, VImageDimension >::MovingImageType

Definition at line 56 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::SmartPointer<Self> mitk::TransformFactory< TPixelType, VImageDimension >::Pointer

Definition at line 50 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef TransformFactory mitk::TransformFactory< TPixelType, VImageDimension >::Self

Definition at line 50 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Object mitk::TransformFactory< TPixelType, VImageDimension >::Superclass

Definition at line 50 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef TransformType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::TransformPointer

Definition at line 64 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
typedef itk::Transform< double, VImageDimension, VImageDimension > mitk::TransformFactory< TPixelType, VImageDimension >::TransformType

Definition at line 62 of file mitkTransformFactory.h.

Constructor & Destructor Documentation

template<class TPixelType , unsigned int VImageDimension>
mitk::TransformFactory< TPixelType, VImageDimension >::TransformFactory (  ) [protected]

Definition at line 48 of file mitkTransformFactory.txx.

                                                                    : 
    m_TransformParameters(NULL),
    m_FixedImage(NULL),
    m_MovingImage(NULL),
    m_FixedImage2D(NULL),
    m_MovingImage2D(NULL),
    m_FixedImage3D(NULL),
    m_MovingImage3D(NULL)
  {

  }
template<class TPixelType, unsigned int VImageDimension>
mitk::TransformFactory< TPixelType, VImageDimension >::~TransformFactory (  ) [inline, protected]

Definition at line 100 of file mitkTransformFactory.h.

{};

Member Function Documentation

template<class TPixelType, unsigned int VImageDimension>
virtual const char* mitk::TransformFactory< TPixelType, VImageDimension >::GetClassName (  ) const [virtual]
template<class TPixelType , unsigned int VImageDimension>
TransformFactory< TPixelType, VImageDimension >::TransformPointer mitk::TransformFactory< TPixelType, VImageDimension >::GetTransform (  )

Returns the transform which then can be used in combination with a metric, an optimizer and an interpolator within a registration pipeline.

Definition at line 166 of file mitkTransformFactory.txx.

References mitk::TransformParameters::AFFINETRANSFORM, mitk::TransformParameters::CENTEREDEULER3DTRANSFORM, mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM, mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM, mitk::TransformParameters::EULER2DTRANSFORM, mitk::TransformParameters::EULER3DTRANSFORM, mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM, mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM, mitk::TransformParameters::RIGID2DTRANSFORM, mitk::TransformParameters::RIGID3DTRANSFORM, mitk::TransformParameters::SCALELOGARITHMICTRANSFORM, mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM, mitk::TransformParameters::SCALETRANSFORM, mitk::TransformParameters::SIMILARITY2DTRANSFORM, mitk::TransformParameters::SIMILARITY3DTRANSFORM, mitk::TransformParameters::TRANSLATIONTRANSFORM, mitk::TransformParameters::VERSORRIGID3DTRANSFORM, and mitk::TransformParameters::VERSORTRANSFORM.

  {
    int transform = m_TransformParameters->GetTransform();
    if (transform == TransformParameters::TRANSLATIONTRANSFORM)
    {
    typename itk::TranslationTransform< double, VImageDimension>::Pointer transformPointer = itk::TranslationTransform< double, VImageDimension>::New();
      transformPointer->SetIdentity();
    return transformPointer.GetPointer();
    }
    else if (transform == TransformParameters::SCALETRANSFORM)
    {
      typename itk::ScaleTransform< double, VImageDimension>::Pointer transformPointer = itk::ScaleTransform< double, VImageDimension>::New();
      transformPointer->SetIdentity();
      return transformPointer.GetPointer();
    }
    else if (transform == TransformParameters::SCALELOGARITHMICTRANSFORM)
    {
      typename itk::ScaleLogarithmicTransform< double, VImageDimension>::Pointer transformPointer = itk::ScaleLogarithmicTransform< double, VImageDimension>::New();
      transformPointer->SetIdentity();
      return transformPointer.GetPointer();
    }
    else if (transform == TransformParameters::AFFINETRANSFORM)
    {
      typename itk::AffineTransform< double, VImageDimension>::Pointer transformPointer = itk::AffineTransform< double, VImageDimension>::New();    
      transformPointer->SetIdentity();
      if (m_TransformParameters->GetTransformInitializerOn())
      {
        typedef typename itk::AffineTransform< double, VImageDimension >    AffineTransformType;
        typedef typename itk::CenteredTransformInitializer<AffineTransformType, FixedImageType, MovingImageType> TransformInitializerType;
        typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
        transformInitializer->SetFixedImage( m_FixedImage );
        transformInitializer->SetMovingImage( m_MovingImage );
        transformInitializer->SetTransform( transformPointer );
        if (m_TransformParameters->GetMomentsOn())
        {
          transformInitializer->MomentsOn();
        }
        else
        {
          transformInitializer->GeometryOn();
        }
        transformInitializer->InitializeTransform();        
      }
      m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
      m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
      m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
      return transformPointer.GetPointer();
    }
    else if (transform == TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
    {
      typedef typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension >    CenteredAffineTransformType;
      typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension>::Pointer transformPointer = itk::FixedCenterOfRotationAffineTransform< double, VImageDimension>::New();
      transformPointer->SetIdentity();
      if (m_TransformParameters->GetTransformInitializerOn())
      {
        typedef typename itk::FixedCenterOfRotationAffineTransform< double, VImageDimension >    FixedCenterOfRotationAffineTransformType;
        typedef typename itk::CenteredTransformInitializer<FixedCenterOfRotationAffineTransformType, FixedImageType, MovingImageType> TransformInitializerType;
        typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
        transformInitializer->SetFixedImage( m_FixedImage );
        transformInitializer->SetMovingImage( m_MovingImage );
        transformInitializer->SetTransform( transformPointer );
        if (m_TransformParameters->GetMomentsOn())
        {
          transformInitializer->MomentsOn();
        }
        else
        {
          transformInitializer->GeometryOn();
        }
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        transformInitializer->InitializeTransform();        
      }
      return transformPointer.GetPointer();
    }
    else if (transform == TransformParameters::RIGID3DTRANSFORM)
    {
      //return MakeRigidTransform<VImageDimension>();
      if (VImageDimension == 3)
      {
        typename itk::Rigid3DTransform< double >::Pointer transformPointer = itk::Rigid3DTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::EULER3DTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::Euler3DTransform< double >::Pointer transformPointer = itk::Euler3DTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::CENTEREDEULER3DTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::CenteredEuler3DTransform< double >::Pointer transformPointer = itk::CenteredEuler3DTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::QUATERNIONRIGIDTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::QuaternionRigidTransform< double >::Pointer transformPointer = itk::QuaternionRigidTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::VERSORTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::VersorTransform< double >::Pointer transformPointer = itk::VersorTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::VERSORRIGID3DTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::VersorRigid3DTransform< double >::Pointer transformPointer = itk::VersorRigid3DTransform< double >::New();
        transformPointer->SetIdentity();
        typedef typename itk::VersorRigid3DTransform< double >    VersorRigid3DTransformType;
        if (m_TransformParameters->GetTransformInitializerOn())
        {
          typedef typename itk::CenteredTransformInitializer<VersorRigid3DTransformType, FixedImage3DType, MovingImage3DType> TransformInitializerType;
          typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
          transformInitializer->SetFixedImage( m_FixedImage3D );
          transformInitializer->SetMovingImage( m_MovingImage3D );
          transformInitializer->SetTransform( transformPointer );
          if (m_TransformParameters->GetMomentsOn())
          {
            transformInitializer->MomentsOn();
          }
          else
          {
            transformInitializer->GeometryOn();
          }
          transformInitializer->InitializeTransform();
        }
        typedef VersorRigid3DTransformType::VersorType  VersorType;
        typedef VersorType::VectorType     VectorType;

        VersorType     rotation;
        VectorType     axis;
  
        axis[0] = 0.0;
        axis[1] = 0.0;
        axis[2] = 1.0;

        const double angle = 0;

        rotation.Set(  axis, angle  );

        transformPointer->SetRotation( rotation );
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::ScaleSkewVersor3DTransform< double >::Pointer transformPointer = itk::ScaleSkewVersor3DTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::SIMILARITY3DTRANSFORM)
    {
      if (VImageDimension == 3)
      {
        typename itk::Similarity3DTransform< double >::Pointer transformPointer = itk::Similarity3DTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        m_TransformParameters->SetTransformCenterZ(transformPointer->GetCenter()[2]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::RIGID2DTRANSFORM)
    {
      if (VImageDimension == 2)
      {
        typename itk::Rigid2DTransform< double >::Pointer transformPointer = itk::Rigid2DTransform< double >::New();
        transformPointer->SetIdentity();
        transformPointer->SetAngle( m_TransformParameters->GetAngle() );
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::CENTEREDRIGID2DTRANSFORM)
    {
      if (VImageDimension == 2)
      {
        typename itk::CenteredRigid2DTransform< double >::Pointer transformPointer = itk::CenteredRigid2DTransform< double >::New();
        transformPointer->SetIdentity();
        if (m_TransformParameters->GetTransformInitializerOn())
        {
          typedef typename itk::CenteredRigid2DTransform< double >    CenteredRigid2DTransformType;
          typedef typename itk::CenteredTransformInitializer<CenteredRigid2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
          typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
          transformInitializer->SetFixedImage( m_FixedImage2D );
          transformInitializer->SetMovingImage( m_MovingImage2D );
          transformInitializer->SetTransform( transformPointer );
          if (m_TransformParameters->GetMomentsOn())
          {
            transformInitializer->MomentsOn();
          }
          else
          {
            transformInitializer->GeometryOn();
          }
        transformInitializer->InitializeTransform();
        }
        transformPointer->SetAngle( m_TransformParameters->GetAngle() );
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::EULER2DTRANSFORM)
    {
      if (VImageDimension == 2)
      {
        typename itk::Euler2DTransform< double >::Pointer transformPointer = itk::Euler2DTransform< double >::New();
        transformPointer->SetIdentity();
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::SIMILARITY2DTRANSFORM)
    {
      if (VImageDimension == 2)
      {
        typename itk::Similarity2DTransform< double >::Pointer transformPointer = itk::Similarity2DTransform< double >::New();
        transformPointer->SetIdentity();
        transformPointer->SetScale( m_TransformParameters->GetScale() );
        transformPointer->SetAngle( m_TransformParameters->GetAngle() );
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    else if (transform == TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
    {
      if (VImageDimension == 2)
      {
        typename itk::CenteredSimilarity2DTransform< double >::Pointer transformPointer = itk::CenteredSimilarity2DTransform< double >::New();
        transformPointer->SetIdentity();
        if (m_TransformParameters->GetTransformInitializerOn())
        {
          typedef typename itk::CenteredSimilarity2DTransform< double >    CenteredSimilarity2DTransformType;
          typedef typename itk::CenteredTransformInitializer<CenteredSimilarity2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
          typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
          transformInitializer->SetFixedImage( m_FixedImage2D );
          transformInitializer->SetMovingImage( m_MovingImage2D );
          transformInitializer->SetTransform( transformPointer );
          if (m_TransformParameters->GetMomentsOn())
          {
            transformInitializer->MomentsOn();
          }
          else
          {
            transformInitializer->GeometryOn();
          }
          transformInitializer->InitializeTransform();        
        }
        transformPointer->SetScale( m_TransformParameters->GetScale() );
        transformPointer->SetAngle( m_TransformParameters->GetAngle() );
        m_TransformParameters->SetTransformCenterX(transformPointer->GetCenter()[0]);
        m_TransformParameters->SetTransformCenterY(transformPointer->GetCenter()[1]);
        return reinterpret_cast<TransformType*>(transformPointer.GetPointer());
      }
    }
    return NULL;
  }
template<class TPixelType, unsigned int VImageDimension>
TransformParameters::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::GetTransformParameters (  ) [inline]

Returns the instance to the transform parameters class which holds all parameters for the new transform.

Definition at line 93 of file mitkTransformFactory.h.

    {
      return m_TransformParameters;
    }
template<class TPixelType, unsigned int VImageDimension>
static Pointer mitk::TransformFactory< TPixelType, VImageDimension >::New (  ) [static]

Method for creation through the object factory.

template<class TPixelType , unsigned int VImageDimension>
void mitk::TransformFactory< TPixelType, VImageDimension >::SetFixedImage ( FixedImageType *  fixed )

Sets the fixed image which is needed by transform initializer.

Definition at line 61 of file mitkTransformFactory.txx.

  {
    if (VImageDimension == 2)
    {
      m_FixedImage2D = reinterpret_cast<FixedImage2DType*>(fixed);
      m_FixedImage = fixed;
    }
    else
    {
      m_FixedImage3D = reinterpret_cast<FixedImage3DType*>(fixed);;
      m_FixedImage = fixed;
    }
  }
template<class TPixelType , unsigned int VImageDimension>
void mitk::TransformFactory< TPixelType, VImageDimension >::SetMovingImage ( MovingImageType *  moving )

Sets the moving image which is needed by transform initializer.

Definition at line 76 of file mitkTransformFactory.txx.

  {
    if (VImageDimension == 2)
    {
      m_MovingImage2D = reinterpret_cast<MovingImage2DType*>(moving);
      m_MovingImage = moving;
    }
    else
    {
      m_MovingImage3D = reinterpret_cast<MovingImage3DType*>(moving);
      m_MovingImage = moving;
    }
  }
template<class TPixelType, unsigned int VImageDimension>
void mitk::TransformFactory< TPixelType, VImageDimension >::SetTransformParameters ( TransformParameters::Pointer  transformParameters ) [inline]

Sets the instance to the transform parameters class which holds all parameters for the new transform.

Definition at line 85 of file mitkTransformFactory.h.

    {
      m_TransformParameters = transformParameters;
    }

Member Data Documentation

template<class TPixelType, unsigned int VImageDimension>
FixedImageType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_FixedImage [protected]

Definition at line 103 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
FixedImage2DType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_FixedImage2D [protected]

Definition at line 105 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
FixedImage3DType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_FixedImage3D [protected]

Definition at line 107 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
MovingImageType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_MovingImage [protected]

Definition at line 104 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
MovingImage2DType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_MovingImage2D [protected]

Definition at line 106 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
MovingImage3DType::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_MovingImage3D [protected]

Definition at line 108 of file mitkTransformFactory.h.

template<class TPixelType, unsigned int VImageDimension>
TransformParameters::Pointer mitk::TransformFactory< TPixelType, VImageDimension >::m_TransformParameters [protected]

Definition at line 100 of file mitkTransformFactory.h.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Generated on Tue Oct 19 2010 16:20:39 for mitk by  doxygen 1.7.2