diff --git a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredRigid2DTransformView.cpp b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredRigid2DTransformView.cpp
index f3b844d2ed..1789631ecf 100644
--- a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredRigid2DTransformView.cpp
+++ b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredRigid2DTransformView.cpp
@@ -1,178 +1,185 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkCenteredRigid2DTransformView.h"
 #include "mitkImageAccessByItk.h"
 #include <mitkImageCast.h>
 #include <itkCenteredRigid2DTransform.h>
 #include <itkCenteredTransformInitializer.h>
 #include <QValidator>
 
 QmitkCenteredRigid2DTransformView::QmitkCenteredRigid2DTransformView(QWidget* parent, Qt::WindowFlags f ) : QmitkRigidRegistrationTransformsGUIBase(parent, f),
 m_CenterX(0), m_CenterY(0), m_CenterZ(0)
 {
 }
 
 QmitkCenteredRigid2DTransformView::~QmitkCenteredRigid2DTransformView()
 {
 }
 
 mitk::TransformParameters::TransformType QmitkCenteredRigid2DTransformView::GetTransformType()
 {
   return mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM;
 }
 
 itk::Object::Pointer QmitkCenteredRigid2DTransformView::GetTransform()
 {
   if (m_FixedImage.IsNotNull())
   {
-    AccessByItk(m_FixedImage, GetTransform2);
+    AccessFixedDimensionByItk(m_FixedImage, GetTransform2, 2);
     return m_TransformObject;
   }
   return NULL;
 }
 
 template < class TPixelType, unsigned int VImageDimension >
-itk::Object::Pointer QmitkCenteredRigid2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* /* itkImage1 */)
+itk::Object::Pointer QmitkCenteredRigid2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* itkImage1)
 {
   if (VImageDimension == 2)
   {
     typedef typename itk::Image< TPixelType, 2 >  FixedImage2DType;
     typedef typename itk::Image< TPixelType, 2 >  MovingImage2DType;
-    typename FixedImage2DType::Pointer fixedImage2D;
-    mitk::CastToItkImage(m_FixedImage, fixedImage2D);
-    typename MovingImage2DType::Pointer movingImage2D;
-    mitk::CastToItkImage(m_MovingImage, movingImage2D);
+
+    // the fixedImage is the input parameter (fix for Bug #14626)
+    typename FixedImage2DType::Pointer fixedImage2D = itkImage1;
+
+    // the movingImage type is known, use the ImageToItk filter (fix for Bug #14626)
+    typename mitk::ImageToItk<MovingImage2DType>::Pointer movingImageToItk =
+        mitk::ImageToItk<MovingImage2DType>::New();
+    movingImageToItk->SetInput(m_MovingImage);
+    movingImageToItk->Update();
+    typename MovingImage2DType::Pointer movingImage2D = movingImageToItk->GetOutput();
+
     typename itk::CenteredRigid2DTransform< double >::Pointer transformPointer = itk::CenteredRigid2DTransform< double >::New();
     transformPointer->SetIdentity();
     if (m_Controls.m_CenterForInitializerCenteredRigid2D->isChecked())
     {
       typedef typename itk::CenteredRigid2DTransform< double >    CenteredRigid2DTransformType;
       typedef typename itk::CenteredTransformInitializer<CenteredRigid2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
       typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
       transformInitializer->SetFixedImage( fixedImage2D );
       transformInitializer->SetMovingImage( movingImage2D );
       transformInitializer->SetTransform( transformPointer );
       if (m_Controls.m_MomentsCenteredRigid2D->isChecked())
       {
         transformInitializer->MomentsOn();
       }
       else
       {
         transformInitializer->GeometryOn();
       }
       transformInitializer->InitializeTransform();
     }
     transformPointer->SetAngle( m_Controls.m_AngleCenteredRigid2D->text().toFloat() );
     m_CenterX = transformPointer->GetCenter()[0];
     m_CenterY = transformPointer->GetCenter()[1];
     m_TransformObject = transformPointer.GetPointer();
     return transformPointer.GetPointer();
   }
   return NULL;
 }
 
 itk::Array<double> QmitkCenteredRigid2DTransformView::GetTransformParameters()
 {
   itk::Array<double> transformValues;
   transformValues.SetSize(9);
   transformValues.fill(0);
   transformValues[0] = m_Controls.m_UseOptimizerScalesCenteredRigid2D->isChecked();
   transformValues[1] = m_Controls.m_RotationScaleCenteredRigid2D->text().toDouble();
   transformValues[2] = m_Controls.m_CenterXScaleCenteredRigid2D->text().toDouble();
   transformValues[3] = m_Controls.m_CenterYScaleCenteredRigid2D->text().toDouble();
   transformValues[4] = m_Controls.m_TranslationXScaleCenteredRigid2D->text().toDouble();
   transformValues[5] = m_Controls.m_TranslationYScaleCenteredRigid2D->text().toDouble();
   transformValues[6] = m_Controls.m_AngleCenteredRigid2D->text().toFloat();
   transformValues[7] = m_Controls.m_CenterForInitializerCenteredRigid2D->isChecked();
   transformValues[8] = m_Controls.m_MomentsCenteredRigid2D->isChecked();
   return transformValues;
 }
 
 void QmitkCenteredRigid2DTransformView::SetTransformParameters(itk::Array<double> transformValues)
 {
   m_Controls.m_UseOptimizerScalesCenteredRigid2D->setChecked(transformValues[0]);
   m_Controls.m_RotationScaleCenteredRigid2D->setText(QString::number(transformValues[1]));
   m_Controls.m_CenterXScaleCenteredRigid2D->setText(QString::number(transformValues[2]));
   m_Controls.m_CenterYScaleCenteredRigid2D->setText(QString::number(transformValues[3]));
   m_Controls.m_TranslationXScaleCenteredRigid2D->setText(QString::number(transformValues[4]));
   m_Controls.m_TranslationYScaleCenteredRigid2D->setText(QString::number(transformValues[5]));
   m_Controls.m_AngleCenteredRigid2D->setText(QString::number(transformValues[6]));
   m_Controls.m_CenterForInitializerCenteredRigid2D->setChecked(transformValues[7]);
   m_Controls.m_MomentsCenteredRigid2D->setChecked(transformValues[8]);
   m_Controls.m_GeometryCenteredRigid2D->setChecked(!transformValues[8]);
 }
 
 QString QmitkCenteredRigid2DTransformView::GetName()
 {
   return "CenteredRigid2D";
 }
 
 void QmitkCenteredRigid2DTransformView::SetupUI(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   QValidator* validatorLineEditInputFloat = new QDoubleValidator(0, 20000000, 8, this);
   m_Controls.m_AngleCenteredRigid2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_RotationScaleCenteredRigid2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_CenterXScaleCenteredRigid2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_CenterYScaleCenteredRigid2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_TranslationXScaleCenteredRigid2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_TranslationYScaleCenteredRigid2D->setValidator(validatorLineEditInputFloat);
 }
 
 itk::Array<double> QmitkCenteredRigid2DTransformView::GetScales()
 {
   itk::Array<double> scales;
   scales.SetSize(5);
   scales.Fill(1.0);
   if (m_Controls.m_UseOptimizerScalesCenteredRigid2D->isChecked())
   {
     scales[0] = m_Controls.m_RotationScaleCenteredRigid2D->text().toDouble();
     scales[1] = m_Controls.m_CenterXScaleCenteredRigid2D->text().toDouble();
     scales[2] = m_Controls.m_CenterYScaleCenteredRigid2D->text().toDouble();
     scales[3] = m_Controls.m_TranslationXScaleCenteredRigid2D->text().toDouble();
     scales[4] = m_Controls.m_TranslationYScaleCenteredRigid2D->text().toDouble();
   }
   return scales;
 }
 
 vtkTransform* QmitkCenteredRigid2DTransformView::Transform(vtkMatrix4x4* /* vtkmatrix */, vtkTransform* vtktransform, itk::Array<double> transformParams)
 {
   if (m_MovingImage.IsNotNull())
   {
     mitk::ScalarType angle = transformParams[0] * 45.0 / atan(1.0);;
     vtktransform->PostMultiply();
     vtktransform->Translate(-transformParams[1], -transformParams[2], 0);
     vtktransform->RotateZ(angle);
     vtktransform->Translate(transformParams[1], transformParams[2], 0);
     vtktransform->Translate(transformParams[3], transformParams[4], 0);
     vtktransform->PreMultiply();
   }
   return vtktransform;
 }
 
 int QmitkCenteredRigid2DTransformView::GetNumberOfTransformParameters()
 {
   if (m_FixedImage.IsNotNull())
   {
     if (m_FixedImage->GetDimension() == 2)
       return 5;
     else
       return 0;
   }
   else
     return 0;
 }
diff --git a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredSimilarity2DTransformView.cpp b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredSimilarity2DTransformView.cpp
index fe248a4aaf..4d052e4ad9 100644
--- a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredSimilarity2DTransformView.cpp
+++ b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkCenteredSimilarity2DTransformView.cpp
@@ -1,186 +1,192 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkCenteredSimilarity2DTransformView.h"
 #include "mitkImageAccessByItk.h"
 #include <mitkImageCast.h>
 #include <itkCenteredSimilarity2DTransform.h>
 #include <itkCenteredTransformInitializer.h>
 #include <QValidator>
 
 QmitkCenteredSimilarity2DTransformView::QmitkCenteredSimilarity2DTransformView(QWidget* parent, Qt::WindowFlags f ) : QmitkRigidRegistrationTransformsGUIBase(parent, f),
 m_CenterX(0), m_CenterY(0), m_CenterZ(0)
 {
 }
 
 QmitkCenteredSimilarity2DTransformView::~QmitkCenteredSimilarity2DTransformView()
 {
 }
 
 mitk::TransformParameters::TransformType QmitkCenteredSimilarity2DTransformView::GetTransformType()
 {
   return mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM;
 }
 
 itk::Object::Pointer QmitkCenteredSimilarity2DTransformView::GetTransform()
 {
   if (m_FixedImage.IsNotNull())
   {
-    AccessByItk(m_FixedImage, GetTransform2);
+    AccessFixedDimensionByItk(m_FixedImage, GetTransform2, 2);
     return m_TransformObject;
   }
   return NULL;
 }
 
 template < class TPixelType, unsigned int VImageDimension >
-itk::Object::Pointer QmitkCenteredSimilarity2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* /* itkImage1 */)
+itk::Object::Pointer QmitkCenteredSimilarity2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* itkImage1)
 {
   if (VImageDimension == 2)
   {
     typedef typename itk::Image< TPixelType, 2 >  FixedImage2DType;
     typedef typename itk::Image< TPixelType, 2 >  MovingImage2DType;
-    typename FixedImage2DType::Pointer fixedImage2D;
-    mitk::CastToItkImage(m_FixedImage, fixedImage2D);
-    typename MovingImage2DType::Pointer movingImage2D;
-    mitk::CastToItkImage(m_MovingImage, movingImage2D);
+
+    // the fixedImage is the input parameter (fix for Bug #14626)
+    typename FixedImage2DType::Pointer fixedImage2D = itkImage1;
+
+    // the movingImage type is known, use the ImageToItk filter (fix for Bug #14626)
+    typename mitk::ImageToItk<MovingImage2DType>::Pointer movingImageToItk =
+        mitk::ImageToItk<MovingImage2DType>::New();
+    movingImageToItk->SetInput(m_MovingImage);
+    movingImageToItk->Update();
+    typename MovingImage2DType::Pointer movingImage2D = movingImageToItk->GetOutput();
 
     typename itk::CenteredSimilarity2DTransform< double >::Pointer transformPointer = itk::CenteredSimilarity2DTransform< double >::New();
     transformPointer->SetIdentity();
     if (m_Controls.m_CenterForInitializerCenteredSimilarity2D->isChecked())
     {
       typedef typename itk::CenteredSimilarity2DTransform< double >    CenteredSimilarity2DTransformType;
       typedef typename itk::CenteredTransformInitializer<CenteredSimilarity2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
       typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
       transformInitializer->SetFixedImage( fixedImage2D );
       transformInitializer->SetMovingImage( movingImage2D );
       transformInitializer->SetTransform( transformPointer );
       if (m_Controls.m_MomentsCenteredSimilarity2D->isChecked())
       {
         transformInitializer->MomentsOn();
       }
       else
       {
         transformInitializer->GeometryOn();
       }
       transformInitializer->InitializeTransform();
     }
     transformPointer->SetScale( m_Controls.m_InitialScaleCenteredSimilarity2D->text().toFloat() );
     transformPointer->SetAngle( m_Controls.m_AngleCenteredSimilarity2D->text().toFloat() );
     m_CenterX = transformPointer->GetCenter()[0];
     m_CenterY = transformPointer->GetCenter()[1];
     m_TransformObject = transformPointer.GetPointer();
     return transformPointer.GetPointer();
   }
   return NULL;
 }
 
 itk::Array<double> QmitkCenteredSimilarity2DTransformView::GetTransformParameters()
 {
   itk::Array<double> transformValues;
   transformValues.SetSize(11);
   transformValues.fill(0);
   transformValues[0] = m_Controls.m_UseOptimizerScalesCenteredSimilarity2D->isChecked();
   transformValues[1] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale1->text().toDouble();
   transformValues[2] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale2->text().toDouble();
   transformValues[3] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale3->text().toDouble();
   transformValues[4] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale4->text().toDouble();
   transformValues[5] = m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationX->text().toDouble();
   transformValues[6] = m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationY->text().toDouble();
   transformValues[7] = m_Controls.m_InitialScaleCenteredSimilarity2D->text().toFloat();
   transformValues[8] = m_Controls.m_AngleCenteredSimilarity2D->text().toFloat();
   transformValues[9] = m_Controls.m_CenterForInitializerCenteredSimilarity2D->isChecked();
   transformValues[10] = m_Controls.m_MomentsCenteredSimilarity2D->isChecked();
   return transformValues;
 }
 
 void QmitkCenteredSimilarity2DTransformView::SetTransformParameters(itk::Array<double> transformValues)
 {
   m_Controls.m_UseOptimizerScalesCenteredSimilarity2D->setChecked(transformValues[0]);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale1->setText(QString::number(transformValues[1]));
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale2->setText(QString::number(transformValues[2]));
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale3->setText(QString::number(transformValues[3]));
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale4->setText(QString::number(transformValues[4]));
   m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationX->setText(QString::number(transformValues[5]));
   m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationY->setText(QString::number(transformValues[6]));
   m_Controls.m_InitialScaleCenteredSimilarity2D->setText(QString::number(transformValues[7]));
   m_Controls.m_AngleCenteredSimilarity2D->setText(QString::number(transformValues[8]));
   m_Controls.m_CenterForInitializerCenteredSimilarity2D->setChecked(transformValues[9]);
   m_Controls.m_MomentsCenteredSimilarity2D->setChecked(transformValues[10]);
   m_Controls.m_GeometryCenteredSimilarity2D->setChecked(!transformValues[10]);
 }
 
 QString QmitkCenteredSimilarity2DTransformView::GetName()
 {
   return "CenteredSimilarity2D";
 }
 
 void QmitkCenteredSimilarity2DTransformView::SetupUI(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   QValidator* validatorLineEditInputFloat = new QDoubleValidator(0, 20000000, 8, this);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale1->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale2->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale3->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScale4->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationX->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationY->setValidator(validatorLineEditInputFloat);
 }
 
 itk::Array<double> QmitkCenteredSimilarity2DTransformView::GetScales()
 {
   itk::Array<double> scales;
   scales.SetSize(6);
   scales.Fill(1.0);
   if (m_Controls.m_UseOptimizerScalesCenteredSimilarity2D->isChecked())
   {
     scales[0] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale1->text().toDouble();
     scales[1] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale2->text().toDouble();
     scales[2] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale3->text().toDouble();
     scales[3] = m_Controls.m_ScalesCenteredSimilarity2DTransformScale4->text().toDouble();
     scales[4] = m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationX->text().toDouble();
     scales[5] = m_Controls.m_ScalesCenteredSimilarity2DTransformScaleTranslationY->text().toDouble();
   }
   return scales;
 }
 
 vtkTransform* QmitkCenteredSimilarity2DTransformView::Transform(vtkMatrix4x4* /*vtkmatrix*/, vtkTransform* vtktransform, itk::Array<double> transformParams)
 {
   if (m_MovingImage.IsNotNull())
   {
     mitk::ScalarType angle = transformParams[1] * 45.0 / atan(1.0);
     vtktransform->PostMultiply();
     vtktransform->Translate(-transformParams[2], -transformParams[3], 0);
     vtktransform->Scale(transformParams[0], transformParams[0], 1);
     vtktransform->RotateZ(angle);
     vtktransform->Translate(transformParams[2], transformParams[3], 0);
     vtktransform->Translate(transformParams[4], transformParams[5], 0);
     vtktransform->PreMultiply();
   }
   return vtktransform;
 }
 
 int QmitkCenteredSimilarity2DTransformView::GetNumberOfTransformParameters()
 {
   if (m_FixedImage.IsNotNull())
   {
     if (m_FixedImage->GetDimension() == 2)
       return 6;
     else
       return 0;
   }
   else
     return 0;
 }
diff --git a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkEuler2DTransformView.cpp b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkEuler2DTransformView.cpp
index 9b89d7c7a8..aaa6a8f174 100644
--- a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkEuler2DTransformView.cpp
+++ b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkEuler2DTransformView.cpp
@@ -1,162 +1,169 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkEuler2DTransformView.h"
 #include "mitkImageAccessByItk.h"
 #include <mitkImageCast.h>
 #include <itkEuler2DTransform.h>
 #include <itkCenteredTransformInitializer.h>
 #include <QValidator>
 
 QmitkEuler2DTransformView::QmitkEuler2DTransformView(QWidget* parent, Qt::WindowFlags f ) : QmitkRigidRegistrationTransformsGUIBase(parent, f),
 m_CenterX(0), m_CenterY(0), m_CenterZ(0)
 {
 }
 
 QmitkEuler2DTransformView::~QmitkEuler2DTransformView()
 {
 }
 
 mitk::TransformParameters::TransformType QmitkEuler2DTransformView::GetTransformType()
 {
   return mitk::TransformParameters::EULER2DTRANSFORM;
 }
 
 itk::Object::Pointer QmitkEuler2DTransformView::GetTransform()
 {
   if (m_FixedImage.IsNotNull())
   {
-    AccessByItk(m_FixedImage, GetTransform2);
+    AccessFixedDimensionByItk(m_FixedImage, GetTransform2, 2);
     return m_TransformObject;
   }
   return NULL;
 }
 
 template < class TPixelType, unsigned int VImageDimension >
-itk::Object::Pointer QmitkEuler2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* /* itkImage1 */)
+itk::Object::Pointer QmitkEuler2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* itkImage1)
 {
   if (VImageDimension == 2)
   {
     typedef typename itk::Image< TPixelType, 2 >  FixedImage2DType;
     typedef typename itk::Image< TPixelType, 2 >  MovingImage2DType;
-    typename FixedImage2DType::Pointer fixedImage2D;
-    mitk::CastToItkImage(m_FixedImage, fixedImage2D);
-    typename MovingImage2DType::Pointer movingImage2D;
-    mitk::CastToItkImage(m_MovingImage, movingImage2D);
+
+    // the fixedImage is the input parameter (fix for Bug #14626)
+    typename FixedImage2DType::Pointer fixedImage2D = itkImage1;
+
+    // the movingImage type is known, use the ImageToItk filter (fix for Bug #14626)
+    typename mitk::ImageToItk<MovingImage2DType>::Pointer movingImageToItk =
+        mitk::ImageToItk<MovingImage2DType>::New();
+    movingImageToItk->SetInput(m_MovingImage);
+    movingImageToItk->Update();
+    typename MovingImage2DType::Pointer movingImage2D = movingImageToItk->GetOutput();
+
     typename itk::Euler2DTransform< double >::Pointer transformPointer = itk::Euler2DTransform< double >::New();
     transformPointer->SetIdentity();
     if (m_Controls.m_CenterForInitializerEuler2D->isChecked())
     {
       typedef typename itk::Euler2DTransform< double > Euler2DTransformType;
       typedef typename itk::CenteredTransformInitializer<Euler2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
       typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
       transformInitializer->SetFixedImage( fixedImage2D );
       transformInitializer->SetMovingImage( movingImage2D );
       transformInitializer->SetTransform( transformPointer );
       if (m_Controls.m_MomentsEuler2D->isChecked())
       {
         transformInitializer->MomentsOn();
       }
       else
       {
         transformInitializer->GeometryOn();
       }
       transformInitializer->InitializeTransform();
     }
     m_TransformObject = transformPointer.GetPointer();
     return transformPointer.GetPointer();
   }
   return NULL;
 }
 
 itk::Array<double> QmitkEuler2DTransformView::GetTransformParameters()
 {
   itk::Array<double> transformValues;
   transformValues.SetSize(6);
   transformValues.fill(0);
   transformValues[0] = m_Controls.m_UseOptimizerScalesEuler2D->isChecked();
   transformValues[1] = m_Controls.m_RotationScaleEuler2D->text().toDouble();
   transformValues[2] = m_Controls.m_TranslationXScaleEuler2D->text().toDouble();
   transformValues[3] = m_Controls.m_TranslationYScaleEuler2D->text().toDouble();
   transformValues[4] = m_Controls.m_CenterForInitializerEuler2D->isChecked();
   transformValues[5] = m_Controls.m_MomentsEuler2D->isChecked();
   return transformValues;
 }
 
 void QmitkEuler2DTransformView::SetTransformParameters(itk::Array<double> transformValues)
 {
   m_Controls.m_UseOptimizerScalesEuler2D->setChecked(transformValues[0]);
   m_Controls.m_RotationScaleEuler2D->setText(QString::number(transformValues[1]));
   m_Controls.m_TranslationXScaleEuler2D->setText(QString::number(transformValues[2]));
   m_Controls.m_TranslationYScaleEuler2D->setText(QString::number(transformValues[3]));
   m_Controls.m_CenterForInitializerEuler2D->setChecked(transformValues[4]);
   m_Controls.m_MomentsEuler2D->setChecked(transformValues[5]);
   m_Controls.m_GeometryEuler2D->setChecked(!transformValues[5]);
 }
 
 QString QmitkEuler2DTransformView::GetName()
 {
   return "Euler2D";
 }
 
 void QmitkEuler2DTransformView::SetupUI(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   QValidator* validatorLineEditInputFloat = new QDoubleValidator(0, 20000000, 8, this);
   m_Controls.m_RotationScaleEuler2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_TranslationXScaleEuler2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_TranslationYScaleEuler2D->setValidator(validatorLineEditInputFloat);
 }
 
 itk::Array<double> QmitkEuler2DTransformView::GetScales()
 {
   itk::Array<double> scales;
   scales.SetSize(3);
   scales.Fill(1.0);
   if (m_Controls.m_UseOptimizerScalesEuler2D->isChecked())
   {
     scales[0] = m_Controls.m_RotationScaleEuler2D->text().toDouble();
     scales[1] = m_Controls.m_TranslationXScaleEuler2D->text().toDouble();
     scales[2] = m_Controls.m_TranslationYScaleEuler2D->text().toDouble();
   }
   return scales;
 }
 
 vtkTransform* QmitkEuler2DTransformView::Transform(vtkMatrix4x4* /*vtkmatrix*/, vtkTransform* vtktransform, itk::Array<double> transformParams)
 {
   if (m_MovingImage.IsNotNull())
   {
     mitk::ScalarType angle = transformParams[0] * 45.0 / atan(1.0);
     vtktransform->PostMultiply();
     vtktransform->RotateZ(angle);
     vtktransform->Translate(transformParams[1], transformParams[2], 0);
     vtktransform->PreMultiply();
   }
   return vtktransform;
 }
 
 int QmitkEuler2DTransformView::GetNumberOfTransformParameters()
 {
   if (m_FixedImage.IsNotNull())
   {
     if (m_FixedImage->GetDimension() == 2)
       return 3;
     else
       return 0;
   }
   else
     return 0;
 }
diff --git a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid2DTransformView.cpp b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid2DTransformView.cpp
index df5eaf94f5..a2500abc83 100644
--- a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid2DTransformView.cpp
+++ b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkRigid2DTransformView.cpp
@@ -1,162 +1,169 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkRigid2DTransformView.h"
 #include "mitkImageAccessByItk.h"
 #include <mitkImageCast.h>
 #include <itkRigid2DTransform.h>
 #include <itkCenteredTransformInitializer.h>
 #include <QValidator>
 
 QmitkRigid2DTransformView::QmitkRigid2DTransformView(QWidget* parent, Qt::WindowFlags f ) : QmitkRigidRegistrationTransformsGUIBase(parent, f),
 m_CenterX(0), m_CenterY(0), m_CenterZ(0)
 {
 }
 
 QmitkRigid2DTransformView::~QmitkRigid2DTransformView()
 {
 }
 
 mitk::TransformParameters::TransformType QmitkRigid2DTransformView::GetTransformType()
 {
   return mitk::TransformParameters::RIGID2DTRANSFORM;
 }
 
 itk::Object::Pointer QmitkRigid2DTransformView::GetTransform()
 {
   if (m_FixedImage.IsNotNull())
   {
-    AccessByItk(m_FixedImage, GetTransform2);
+    AccessFixedDimensionByItk(m_FixedImage, GetTransform2, 2);
     return m_TransformObject;
   }
   return NULL;
 }
 
 template < class TPixelType, unsigned int VImageDimension >
-itk::Object::Pointer QmitkRigid2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* /*itkImage1*/)
+itk::Object::Pointer QmitkRigid2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* itkImage1)
 {
   if (VImageDimension == 2)
   {
     typedef typename itk::Image< TPixelType, 2 >  FixedImage2DType;
     typedef typename itk::Image< TPixelType, 2 >  MovingImage2DType;
-    typename FixedImage2DType::Pointer fixedImage2D;
-    mitk::CastToItkImage(m_FixedImage, fixedImage2D);
-    typename MovingImage2DType::Pointer movingImage2D;
-    mitk::CastToItkImage(m_MovingImage, movingImage2D);
+
+    // the fixedImage is the input parameter (fix for Bug #14626)
+    typename FixedImage2DType::Pointer fixedImage2D = itkImage1;
+
+    // the movingImage type is known, use the ImageToItk filter (fix for Bug #14626)
+    typename mitk::ImageToItk<MovingImage2DType>::Pointer movingImageToItk =
+        mitk::ImageToItk<MovingImage2DType>::New();
+    movingImageToItk->SetInput(m_MovingImage);
+    movingImageToItk->Update();
+    typename MovingImage2DType::Pointer movingImage2D = movingImageToItk->GetOutput();
+
     typename itk::Rigid2DTransform< double >::Pointer transformPointer = itk::Rigid2DTransform< double >::New();
     transformPointer->SetIdentity();
     if (m_Controls.m_CenterForInitializerRigid2D->isChecked())
     {
       typedef typename itk::Rigid2DTransform< double > Rigid2DTransformType;
       typedef typename itk::CenteredTransformInitializer<Rigid2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
       typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
       transformInitializer->SetFixedImage( fixedImage2D );
       transformInitializer->SetMovingImage( movingImage2D );
       transformInitializer->SetTransform( transformPointer );
       if (m_Controls.m_MomentsRigid2D->isChecked())
       {
         transformInitializer->MomentsOn();
       }
       else
       {
         transformInitializer->GeometryOn();
       }
       transformInitializer->InitializeTransform();
     }
     m_TransformObject = transformPointer.GetPointer();
     return transformPointer.GetPointer();
   }
   return NULL;
 }
 
 itk::Array<double> QmitkRigid2DTransformView::GetTransformParameters()
 {
   itk::Array<double> transformValues;
   transformValues.SetSize(6);
   transformValues.fill(0);
   transformValues[0] = m_Controls.m_UseOptimizerScalesRigid2D->isChecked();
   transformValues[1] = m_Controls.m_ScalesRigid2DTransformScale1->text().toDouble();
   transformValues[2] = m_Controls.m_ScalesRigid2DTransformScaleTranslationX->text().toDouble();
   transformValues[3] = m_Controls.m_ScalesRigid2DTransformScaleTranslationY->text().toDouble();
   transformValues[4] = m_Controls.m_CenterForInitializerRigid2D->isChecked();
   transformValues[5] = m_Controls.m_MomentsRigid2D->isChecked();
   return transformValues;
 }
 
 void QmitkRigid2DTransformView::SetTransformParameters(itk::Array<double> transformValues)
 {
   m_Controls.m_UseOptimizerScalesRigid2D->setChecked(transformValues[0]);
   m_Controls.m_ScalesRigid2DTransformScale1->setText(QString::number(transformValues[1]));
   m_Controls.m_ScalesRigid2DTransformScaleTranslationX->setText(QString::number(transformValues[2]));
   m_Controls.m_ScalesRigid2DTransformScaleTranslationY->setText(QString::number(transformValues[3]));
   m_Controls.m_CenterForInitializerRigid2D->setChecked(transformValues[4]);
   m_Controls.m_MomentsRigid2D->setChecked(transformValues[5]);
   m_Controls.m_GeometryRigid2D->setChecked(!transformValues[5]);
 }
 
 QString QmitkRigid2DTransformView::GetName()
 {
   return "Rigid2D";
 }
 
 void QmitkRigid2DTransformView::SetupUI(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   QValidator* validatorLineEditInputFloat = new QDoubleValidator(0, 20000000, 8, this);
   m_Controls.m_ScalesRigid2DTransformScale1->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesRigid2DTransformScaleTranslationX->setValidator(validatorLineEditInputFloat);
   m_Controls.m_ScalesRigid2DTransformScaleTranslationY->setValidator(validatorLineEditInputFloat);
 }
 
 itk::Array<double> QmitkRigid2DTransformView::GetScales()
 {
   itk::Array<double> scales;
   scales.SetSize(3);
   scales.Fill(1.0);
   if (m_Controls.m_UseOptimizerScalesRigid2D->isChecked())
   {
     scales[0] = m_Controls.m_ScalesRigid2DTransformScale1->text().toDouble();
     scales[1] = m_Controls.m_ScalesRigid2DTransformScaleTranslationX->text().toDouble();
     scales[2] = m_Controls.m_ScalesRigid2DTransformScaleTranslationY->text().toDouble();
   }
   return scales;
 }
 
 vtkTransform* QmitkRigid2DTransformView::Transform(vtkMatrix4x4* /*vtkmatrix*/, vtkTransform* vtktransform, itk::Array<double> transformParams)
 {
   if (m_MovingImage.IsNotNull())
   {
     mitk::ScalarType angle = transformParams[0] * 45.0 / atan(1.0);
     vtktransform->PostMultiply();
     vtktransform->RotateZ(angle);
     vtktransform->Translate(transformParams[1], transformParams[2], 0);
     vtktransform->PreMultiply();
   }
   return vtktransform;
 }
 
 int QmitkRigid2DTransformView::GetNumberOfTransformParameters()
 {
   if (m_FixedImage.IsNotNull())
   {
     if (m_FixedImage->GetDimension() == 2)
       return 3;
     else
       return 0;
   }
   else
     return 0;
 }
diff --git a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkSimilarity2DTransformView.cpp b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkSimilarity2DTransformView.cpp
index 1d0d6335fb..a303046921 100644
--- a/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkSimilarity2DTransformView.cpp
+++ b/Modules/RigidRegistrationUI/RigidRegistrationTransforms/QmitkSimilarity2DTransformView.cpp
@@ -1,173 +1,181 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkSimilarity2DTransformView.h"
 #include "mitkImageAccessByItk.h"
 #include <mitkImageCast.h>
 #include <itkSimilarity2DTransform.h>
 #include <itkCenteredTransformInitializer.h>
 #include <QValidator>
 
 QmitkSimilarity2DTransformView::QmitkSimilarity2DTransformView(QWidget* parent, Qt::WindowFlags f ) : QmitkRigidRegistrationTransformsGUIBase(parent, f),
 m_CenterX(0), m_CenterY(0), m_CenterZ(0)
 {
 }
 
 QmitkSimilarity2DTransformView::~QmitkSimilarity2DTransformView()
 {
 }
 
 mitk::TransformParameters::TransformType QmitkSimilarity2DTransformView::GetTransformType()
 {
   return mitk::TransformParameters::SIMILARITY2DTRANSFORM;
 }
 
 itk::Object::Pointer QmitkSimilarity2DTransformView::GetTransform()
 {
   if (m_FixedImage.IsNotNull())
   {
-    AccessByItk(m_FixedImage, GetTransform2);
+    AccessFixedDimensionByItk(m_FixedImage, GetTransform2, 2);
     return m_TransformObject;
   }
   return NULL;
 }
 
 template < class TPixelType, unsigned int VImageDimension >
-itk::Object::Pointer QmitkSimilarity2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* /* itkImage1 */)
+itk::Object::Pointer QmitkSimilarity2DTransformView::GetTransform2(itk::Image<TPixelType, VImageDimension>* itkImage1)
 {
   if (VImageDimension == 2)
   {
     typedef typename itk::Image< TPixelType, 2 >  FixedImage2DType;
     typedef typename itk::Image< TPixelType, 2 >  MovingImage2DType;
-    typename FixedImage2DType::Pointer fixedImage2D;
-    mitk::CastToItkImage(m_FixedImage, fixedImage2D);
-    typename MovingImage2DType::Pointer movingImage2D;
-    mitk::CastToItkImage(m_MovingImage, movingImage2D);
+
+    // the fixedImage is the input parameter (fix for Bug #14626)
+    typename FixedImage2DType::Pointer fixedImage2D = itkImage1;
+
+    // the movingImage type is known, use the ImageToItk filter (fix for Bug #14626)
+    typename mitk::ImageToItk<MovingImage2DType>::Pointer movingImageToItk =
+        mitk::ImageToItk<MovingImage2DType>::New();
+    movingImageToItk->SetInput(m_MovingImage);
+    movingImageToItk->Update();
+    typename MovingImage2DType::Pointer movingImage2D = movingImageToItk->GetOutput();
+
+
     typename itk::Similarity2DTransform< double >::Pointer transformPointer = itk::Similarity2DTransform< double >::New();
     transformPointer->SetIdentity();
     if (m_Controls.m_CenterForInitializerSimilarity2D->isChecked())
     {
       typedef typename itk::Similarity2DTransform< double > Similarity2DTransformType;
       typedef typename itk::CenteredTransformInitializer<Similarity2DTransformType, FixedImage2DType, MovingImage2DType> TransformInitializerType;
       typename TransformInitializerType::Pointer transformInitializer = TransformInitializerType::New();
       transformInitializer->SetFixedImage( fixedImage2D );
       transformInitializer->SetMovingImage( movingImage2D );
       transformInitializer->SetTransform( transformPointer );
       if (m_Controls.m_MomentsSimilarity2D->isChecked())
       {
         transformInitializer->MomentsOn();
       }
       else
       {
         transformInitializer->GeometryOn();
       }
       transformInitializer->InitializeTransform();
     }
     transformPointer->SetScale( m_Controls.m_InitialScaleSimilarity2D->text().toFloat() );
     transformPointer->SetAngle( m_Controls.m_AngleSimilarity2D->text().toFloat() );
     m_TransformObject = transformPointer.GetPointer();
     return transformPointer.GetPointer();
   }
   return NULL;
 }
 
 itk::Array<double> QmitkSimilarity2DTransformView::GetTransformParameters()
 {
   itk::Array<double> transformValues;
   transformValues.SetSize(9);
   transformValues.fill(0);
   transformValues[0] = m_Controls.m_UseOptimizerScalesSimilarity2D->isChecked();
   transformValues[1] = m_Controls.m_ScalingScaleSimilarity2D->text().toDouble();
   transformValues[2] = m_Controls.m_RotationScaleSimilarity2D->text().toDouble();
   transformValues[3] = m_Controls.m_TranslationXScaleSimilarity2D->text().toDouble();
   transformValues[4] = m_Controls.m_TranslationYScaleSimilarity2D->text().toDouble();
   transformValues[5] = m_Controls.m_InitialScaleSimilarity2D->text().toFloat();
   transformValues[6] = m_Controls.m_AngleSimilarity2D->text().toFloat();
   transformValues[7] = m_Controls.m_CenterForInitializerSimilarity2D->isChecked();
   transformValues[8] = m_Controls.m_MomentsSimilarity2D->isChecked();
   return transformValues;
 }
 
 void QmitkSimilarity2DTransformView::SetTransformParameters(itk::Array<double> transformValues)
 {
   m_Controls.m_UseOptimizerScalesSimilarity2D->setChecked(transformValues[0]);
   m_Controls.m_ScalingScaleSimilarity2D->setText(QString::number(transformValues[1]));
   m_Controls.m_RotationScaleSimilarity2D->setText(QString::number(transformValues[2]));
   m_Controls.m_TranslationXScaleSimilarity2D->setText(QString::number(transformValues[3]));
   m_Controls.m_TranslationYScaleSimilarity2D->setText(QString::number(transformValues[4]));
   m_Controls.m_InitialScaleSimilarity2D->setText(QString::number(transformValues[5]));
   m_Controls.m_AngleSimilarity2D->setText(QString::number(transformValues[6]));
   m_Controls.m_CenterForInitializerSimilarity2D->setChecked(transformValues[7]);
   m_Controls.m_MomentsSimilarity2D->setChecked(transformValues[8]);
   m_Controls.m_GeometrySimilarity2D->setChecked(!transformValues[8]);
 }
 
 QString QmitkSimilarity2DTransformView::GetName()
 {
   return "Similarity2D";
 }
 
 void QmitkSimilarity2DTransformView::SetupUI(QWidget* parent)
 {
   m_Controls.setupUi(parent);
   QValidator* validatorLineEditInputFloat = new QDoubleValidator(0, 20000000, 8, this);
   m_Controls.m_ScalingScaleSimilarity2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_RotationScaleSimilarity2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_TranslationXScaleSimilarity2D->setValidator(validatorLineEditInputFloat);
   m_Controls.m_TranslationYScaleSimilarity2D->setValidator(validatorLineEditInputFloat);
 }
 
 itk::Array<double> QmitkSimilarity2DTransformView::GetScales()
 {
   itk::Array<double> scales;
   scales.SetSize(4);
   scales.Fill(1.0);
   if (m_Controls.m_UseOptimizerScalesSimilarity2D->isChecked())
   {
     scales[0] = m_Controls.m_ScalingScaleSimilarity2D->text().toDouble();
     scales[1] = m_Controls.m_RotationScaleSimilarity2D->text().toDouble();
     scales[2] = m_Controls.m_TranslationXScaleSimilarity2D->text().toDouble();
     scales[3] = m_Controls.m_TranslationYScaleSimilarity2D->text().toDouble();
   }
   return scales;
 }
 
 vtkTransform* QmitkSimilarity2DTransformView::Transform(vtkMatrix4x4* /* vtkmatrix */, vtkTransform* vtktransform, itk::Array<double> transformParams)
 {
   if (m_MovingImage.IsNotNull())
   {
     mitk::ScalarType angle = transformParams[1] * 45.0 / atan(1.0);
     vtktransform->PostMultiply();
     vtktransform->Scale(transformParams[0], transformParams[0], 1);
     vtktransform->RotateZ(angle);
     vtktransform->Translate(transformParams[2], transformParams[3], 0);
     vtktransform->PreMultiply();
   }
   return vtktransform;
 }
 
 int QmitkSimilarity2DTransformView::GetNumberOfTransformParameters()
 {
   if (m_FixedImage.IsNotNull())
   {
     if (m_FixedImage->GetDimension() == 2)
       return 4;
     else
       return 0;
   }
   else
     return 0;
 }