diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkBatchedRegistration.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkBatchedRegistration.cpp
index a5b169a137..0e368038d0 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkBatchedRegistration.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkBatchedRegistration.cpp
@@ -1,118 +1,118 @@
 #include "mitkBatchedRegistration.h"
 #include "mitkPyramidImageRegistrationMethod.h"
 #include "mitkDiffusionImage.h"
 
 #include <mitkRotationOperation.h>
+
 #include <itkScalableAffineTransform.h>
+#include <vnl/vnl_inverse.h>
+// VTK
+#include <vtkTransform.h>
 
 mitk::BatchedRegistration::BatchedRegistration() :
   m_RegisteredImagesValid(false)
 {
 }
 
 void mitk::BatchedRegistration::SetFixedImage(mitk::Image::Pointer& fixedImage)
 {
   m_FixedImage = fixedImage;
 }
 
 void mitk::BatchedRegistration::SetMovingReferenceImage(Image::Pointer &movingImage)
 {
   m_MovingReference = movingImage;
   m_RegisteredImagesValid = false;
 }
 
 void mitk::BatchedRegistration::SetBatch(std::vector<mitk::Image::Pointer> imageBatch)
 {
   m_ImageBatch.clear();
   m_ImageBatch = imageBatch;
 }
 
 std::vector<mitk::Image::Pointer> mitk::BatchedRegistration::GetRegisteredImages()
 {
   if (!m_RegisteredImagesValid)
   {
     m_RegisteredImages.clear();
     // First transform moving reference image
     TransformType transf = GetTransformation(m_FixedImage, m_MovingReference);
     // store it as first element in vector
     ApplyTransformationToImage(m_MovingReference,transf);
     m_RegisteredImages.push_back(m_MovingReference);
     // apply transformation to whole batch
     std::vector<mitk::Image::Pointer>::const_iterator itEnd = m_ImageBatch.end();
     for (std::vector<mitk::Image::Pointer>::iterator it = m_ImageBatch.begin(); it != itEnd; ++it)
     {
       ApplyTransformationToImage(*it,transf);
       m_RegisteredImages.push_back(*it);
     }
   }
   return m_RegisteredImages;
 }
 
 void mitk::BatchedRegistration::ApplyTransformationToImage(mitk::Image::Pointer &img, const mitk::BatchedRegistration::TransformType &transformation) const
 {
- // TODO: perform some magic!
-  mitk::Vector3D translateVector;
-  translateVector[0] = transformation.get(0,3);
-  translateVector[1] = transformation.get(1,3);
-  translateVector[2] = transformation.get(2,3);
-  img->GetGeometry()->Translate(translateVector);
-
   itk::ScalableAffineTransform<mitk::ScalarType,3>::Pointer rotationTransform;
-  itk::Matrix<mitk::ScalarType, 3,3> rotationMatrix;
-  for (int i = 0; i < 3;++i)
-    for (int j = 0; j < 3;++j)
-      rotationMatrix[i][j] = transformation.get(i,j);
+  vtkMatrix4x4* transformationMatrix = vtkMatrix4x4::New();
+  for (int i = 0; i < 4;++i)
+    for (int j = 0; j < 4;++j)
+      transformationMatrix->Element[i][j] = transformation.get(i,j);
+
   rotationTransform  = itk::ScalableAffineTransform<mitk::ScalarType,3>::New();
-  rotationTransform->SetMatrix(rotationMatrix);
+
   itk::ScalableAffineTransform<mitk::ScalarType,3>::Pointer geometryTransform = img->GetGeometry()->GetIndexToWorldTransform();
-  geometryTransform->Compose(rotationTransform);
-  img->GetGeometry()->SetIndexToWorldTransform(geometryTransform);
+  img->GetGeometry()->Compose( transformationMatrix); //SetIndexToWorldTransform(geometryTransform);
 
   if (dynamic_cast<mitk::DiffusionImage<short>*> (img.GetPointer()) != NULL)
   {
-   // apply transformation to image geometry as well as to all gradients !?
+    // apply transformation to image geometry as well as to all gradients !?
   }
   else
   {
     // do regular stuff
   }
 }
 
 mitk::BatchedRegistration::TransformType mitk::BatchedRegistration::GetTransformation(mitk::Image::Pointer fixedImage, mitk::Image::Pointer movingImage, mitk::Image::Pointer mask)
 {
 
   mitk::PyramidImageRegistrationMethod::Pointer registrationMethod = mitk::PyramidImageRegistrationMethod::New();
   registrationMethod->SetFixedImage( fixedImage );
 
   if (mask.IsNotNull())
   {
     registrationMethod->SetFixedImageMask(mask);
     registrationMethod->SetUseFixedImageMask(true);
   }
+  else
+  {
+    registrationMethod->SetUseFixedImageMask(false);
+  }
+
   registrationMethod->SetTransformToRigid();
   registrationMethod->SetCrossModalityOn();
   registrationMethod->SetMovingImage(movingImage);
   registrationMethod->Update();
 
-  // TODO fancy shit, where you query and create a transformation type object thingy
-
   TransformType transformation;
   mitk::PyramidImageRegistrationMethod::TransformMatrixType rotationMatrix;
   rotationMatrix = registrationMethod->GetLastRotationMatrix().transpose();
   double param[6];
   registrationMethod->GetParameters(param); // first three: euler angles, last three translation
   for (unsigned int i = 0; i < 3; i++)
   {
     for (unsigned int j = 0; j < 3; ++j)
     {
       double value = rotationMatrix.get(i,j);
       transformation.set(i,j, value);
     }
   }
   transformation.set(0,3,-param[3]);
   transformation.set(1,3,-param[4]);
   transformation.set(2,3,-param[5]);
   transformation.set(3,3,1);
-
+  //transformation =vnl_inverse<double>(transformation);
   return transformation;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkPyramidImageRegistrationMethod.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkPyramidImageRegistrationMethod.h
index 5feae091eb..058db4c92f 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkPyramidImageRegistrationMethod.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkPyramidImageRegistrationMethod.h
@@ -1,486 +1,485 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef MITKPYRAMIDIMAGEREGISTRATION_H
 #define MITKPYRAMIDIMAGEREGISTRATION_H
 
 #include <DiffusionCoreExports.h>
 
 #include <itkObject.h>
 #include "itkImageMaskSpatialObject.h"
 #include "itkNotImageFilter.h"
 #include <vnl/vnl_matrix_fixed.h>
 
 #include "mitkImage.h"
 #include "mitkBaseProcess.h"
 
 #include "mitkPyramidRegistrationMethodHelper.h"
 #include <itkWindowedSincInterpolateImageFunction.h>
 
 #include "mitkImageToItk.h"
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 
 
 namespace mitk
 {
 
 /**
  * @brief The PyramidImageRegistration class implements a multi-scale registration method
  *
  * The PyramidImageRegistration class is suitable for aligning (f.e.) brain MR images. The method offers two
  * transform types
  *   - Rigid: optimizing translation and rotation only and
  *   - Affine ( default ): with scaling in addition ( 12 DOF )
  *
  * The error metric is internally chosen based on the selected task type ( @sa SetCrossModalityOn )
  * It uses
  *   - MattesMutualInformation for CrossModality=on ( default ) and
  *   - NormalizedCorrelation for CrossModality=off.
  */
 class DiffusionCore_EXPORT PyramidImageRegistrationMethod :
     public itk::Object
 {
 public:
 
   /** Typedefs */
   mitkClassMacro(PyramidImageRegistrationMethod, itk::Object)
 
   /** Smart pointer support */
   itkNewMacro(Self)
 
   /** Typedef for the transformation matrix, corresponds to the InternalMatrixType from ITK transforms */
   typedef vnl_matrix_fixed< double, 3, 3> TransformMatrixType;
 
   /** Registration is between modalities - will take MattesMutualInformation as error metric */
   void SetCrossModalityOn()
   {
     m_CrossModalityRegistration = true;
   }
 
   /** Registration is between modalities - will take NormalizedCorrelation as error metric */
   void SetCrossModalityOff()
   {
     m_CrossModalityRegistration = false;
   }
 
   /** Turn the cross-modality on/off */
   void SetCrossModality(bool flag)
   {
     if( flag )
       this->SetCrossModalityOn();
     else
       this->SetCrossModalityOff();
   }
 
   /** Controll the verbosity of the registration output
    *
    * for true, each iteration step of the optimizer is watched and passed to the std::cout
    */
   void SetVerbose(bool flag)
   {
     if( flag )
       this->SetVerboseOn();
     else
       this->SetVerboseOff();
   }
 
   /** Turn verbosity on, \sa SetVerbose */
   void SetVerboseOn()
   {
     m_Verbose = true;
   }
 
   /** Turn verbosity off, \sa SetVerbose */
   void SetVerboseOff()
   {
     m_Verbose = false;
   }
 
   /** A rigid ( 6dof : translation + rotation ) transform is optimized */
   void SetTransformToRigid()
   {
     m_UseAffineTransform = false;
   }
 
   /** An affine ( 12dof : Rigid + scale + skew ) transform is optimized */
   void SetTransformToAffine()
   {
     m_UseAffineTransform = true;
   }
 
   /** Input image, the reference one */
   void SetFixedImage( mitk::Image::Pointer );
 
   /** Input image, the one to be transformed */
   void SetMovingImage( mitk::Image::Pointer );
 
 
   /** Fixed image mask, excludes the masked voxels from the registration metric*/
   void SetFixedImageMask( mitk::Image::Pointer mask);
 
   void Update();
 
   /**
    * @brief Get the number of parameters optimized ( 12 or 6 )
    *
    * @return number of paramters
    */
   unsigned int GetNumberOfParameters()
   {
     unsigned int retValue = 12;
     if(!m_UseAffineTransform)
       retValue = 6;
 
     return retValue;
   }
 
   /**
    * @brief Copies the estimated parameters to the given array
    * @param paramArray, target array for copy, make sure to allocate enough space
    */
   void GetParameters( double* paramArray)
   {
     if( m_EstimatedParameters == NULL )
     {
       mitkThrow() << "No parameters were estimated yet, call Update() first.";
     }
 
     unsigned int dim = 12;
     if( !m_UseAffineTransform )
       dim = 6;
 
     for( unsigned int i=0; i<dim; i++)
     {
       *(paramArray+i) = m_EstimatedParameters[i];
     }
   }
 
   /**
    * @brief Control the interpolator used for resampling.
    *
    * The class uses the
    *  - Linear interpolator on default ( flag = false )
    *  - WindowedSinc interpolator if called with true
    */
   void SetUseAdvancedInterpolation( bool flag)
   {
     m_UseWindowedSincInterpolator = flag;
   }
 
   /**
    * @brief Set if fixed image mask is used to exclude a region.
    * @param flag , true if mask is to be used, false if mask is to be ignored (default)
    */
   void SetUseFixedImageMask( bool flag)
   {
     m_UseMask = flag;
   }
 
   /**
    * @brief Returns the moving image transformed according to the estimated transformation and resampled
    * to the geometry of the fixed image
    *
    */
   mitk::Image::Pointer GetResampledMovingImage();
 
   /**
    * @brief Get the rotation part of the transformation as a vnl_fixed_matrix<double, 3,3>
    *
    * It returns identity if the internal parameters are not-yet allocated ( i.e. the filter did not run yet )
    *
    * @return \sa TransformMatrixType
    */
   TransformMatrixType GetLastRotationMatrix();
 
 
 protected:
   PyramidImageRegistrationMethod();
 
   ~PyramidImageRegistrationMethod();
 
   /** Fixed image, used as reference for registration */
   mitk::Image::Pointer m_FixedImage;
 
   /** Moving image, will be transformed */
   mitk::Image::Pointer m_MovingImage;
 
   mitk::Image::Pointer m_FixedImageMask;
 
   bool m_CrossModalityRegistration;
 
   bool m_UseAffineTransform;
 
   bool m_UseWindowedSincInterpolator;
 
   bool m_UseMask;
 
   double* m_EstimatedParameters;
 
   /** Control the verbosity of the regsitistration output */
   bool m_Verbose;
 
   template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
   void RegisterTwoImages(itk::Image<TPixel1, VImageDimension1>* itkImage1, itk::Image<TPixel2, VImageDimension2>* itkImage2)
   {
     typedef typename itk::Image< TPixel1, VImageDimension1> FixedImageType;
     typedef typename itk::Image< TPixel2, VImageDimension2> MovingImageType;
     typedef typename itk::MultiResolutionImageRegistrationMethod< FixedImageType, MovingImageType > RegistrationType;
     typedef itk::RegularStepGradientDescentOptimizer OptimizerType;
 
     typedef itk::AffineTransform< double >  AffineTransformType;
     typedef itk::Euler3DTransform< double >  RigidTransformType;
     typedef itk::MatrixOffsetTransformBase< double, VImageDimension1, VImageDimension2 > BaseTransformType;
 
     typedef typename itk::MattesMutualInformationImageToImageMetric< FixedImageType, MovingImageType > MMIMetricType;
     typedef typename itk::NormalizedCorrelationImageToImageMetric< FixedImageType, MovingImageType > NCMetricType;
     typedef typename itk::ImageToImageMetric< FixedImageType, MovingImageType> BaseMetricType;
 
     typename itk::LinearInterpolateImageFunction<MovingImageType, double>::Pointer interpolator =
         itk::LinearInterpolateImageFunction<MovingImageType, double>::New();
 
 
     typename BaseMetricType::Pointer metric;
 
     if( m_CrossModalityRegistration )
     {
       metric = MMIMetricType::New();
     }
     else
     {
       metric = NCMetricType::New();
     }
 
 
 
     // initial parameter dimension ( affine = default )
     unsigned int paramDim = 12;
     typename BaseTransformType::Pointer transform;
     if( m_UseAffineTransform )
     {
       transform = AffineTransformType::New();
     }
     else
     {
       transform = RigidTransformType::New();
       paramDim = 6;
     }
 
     typename BaseTransformType::ParametersType initialParams(paramDim);
 
     initialParams.Fill(0);
     if( m_UseAffineTransform )
     {
       initialParams[0] = initialParams[4] = initialParams[8] = 1;
     }
 
 
     typename FixedImageType::Pointer referenceImage = itkImage1;
     typename MovingImageType::Pointer movingImage = itkImage2;
     typename FixedImageType::RegionType maskedRegion = referenceImage->GetLargestPossibleRegion();
 
     typename RegistrationType::Pointer registration = RegistrationType::New();
     unsigned int max_pyramid_lvl = 3;
     unsigned int max_schedule_val = 4;
     typename FixedImageType::RegionType::SizeType image_size = referenceImage->GetLargestPossibleRegion().GetSize();
     unsigned int min_value = std::min( image_size[0], std::min( image_size[1], image_size[2]));
 
     // condition for the top level pyramid image
     float optmaxstep = 6;
     float optminstep = 0.05f;
     unsigned int iterations = 100;
     if( min_value / max_schedule_val < 12 )
     {
       max_schedule_val /= 2;
       optmaxstep *= 0.25f;
       optminstep *= 0.1f;
     }
 
     typename RegistrationType::ScheduleType fixedSchedule(max_pyramid_lvl,3);
     fixedSchedule.Fill(1);
 
     fixedSchedule[0][0] = max_schedule_val;
     fixedSchedule[0][1] = max_schedule_val;
     fixedSchedule[0][2] = max_schedule_val;
 
     for( unsigned int i=1; i<max_pyramid_lvl; i++)
     {
       fixedSchedule[i][0] = std::max( fixedSchedule[i-1][0]/2, 1u);
       fixedSchedule[i][1] = std::max( fixedSchedule[i-1][1]/2, 1u);
       fixedSchedule[i][2] = std::max( fixedSchedule[i-1][2]/2, 1u);
     }
 
     typename OptimizerType::Pointer optimizer = OptimizerType::New();
     typename OptimizerType::ScalesType optScales( paramDim );
     optScales.Fill(10.0);
 
     optScales[paramDim-3] = 1.0/1000;
     optScales[paramDim-2] = 1.0/1000;
     optScales[paramDim-1] = 1.0/1000;
 
     optimizer->SetScales( optScales );
     optimizer->SetInitialPosition( initialParams );
     optimizer->SetNumberOfIterations( iterations );
     optimizer->SetGradientMagnitudeTolerance( 1e-4 );
     optimizer->SetRelaxationFactor( 0.7 );
     optimizer->SetMaximumStepLength( optmaxstep );
     optimizer->SetMinimumStepLength( optminstep );
 
     // add observer tag if verbose */
     unsigned long vopt_tag = 0;
     if(m_Verbose)
     {
       MITK_INFO << "  :: Starting at " << initialParams;
       MITK_INFO << "  :: Scales  =  " << optScales;
 
       OptimizerIterationCommand< OptimizerType >::Pointer iterationObserver =
           OptimizerIterationCommand<OptimizerType>::New();
 
       vopt_tag = optimizer->AddObserver( itk::IterationEvent(), iterationObserver );
     }
 
 
     // INPUT IMAGES
     registration->SetFixedImage( referenceImage );
     registration->SetFixedImageRegion( maskedRegion );
     registration->SetMovingImage( movingImage );
     registration->SetSchedules( fixedSchedule, fixedSchedule);
     // SET MASKED AREA
     typedef itk::Image<unsigned char, 3> BinaryImageType;
     BinaryImageType::Pointer itkFixedImageMask = BinaryImageType::New();
     itk::ImageMaskSpatialObject< 3 >::Pointer fixedMaskSpatialObject = itk::ImageMaskSpatialObject< 3 >::New();
     if (m_UseMask)
     {
       CastToItkImage(m_FixedImageMask,itkFixedImageMask);
       itk::NotImageFilter<BinaryImageType, BinaryImageType>::Pointer notFilter = itk::NotImageFilter<BinaryImageType, BinaryImageType>::New();
       notFilter->SetInput(itkFixedImageMask);
       notFilter->Update();
-
       fixedMaskSpatialObject->SetImage( notFilter->GetOutput() );
       metric->SetFixedImageMask( fixedMaskSpatialObject );
     }
     // OTHER INPUTS
     registration->SetMetric( metric );
     registration->SetOptimizer( optimizer );
     registration->SetTransform( transform.GetPointer() );
     registration->SetInterpolator( interpolator );
     registration->SetInitialTransformParameters( initialParams );
 
     typename PyramidOptControlCommand<RegistrationType>::Pointer pyramid_observer =
         PyramidOptControlCommand<RegistrationType>::New();
 
     registration->AddObserver( itk::IterationEvent(), pyramid_observer );
 
     try
     {
       registration->Update();
     }
     catch (itk::ExceptionObject &e)
     {
       MITK_ERROR << "[Registration Update] Caught ITK exception: ";
       mitkThrow() << "Registration failed with exception: " << e.what();
     }
 
     if( m_EstimatedParameters != NULL)
     {
       delete [] m_EstimatedParameters;
     }
 
     m_EstimatedParameters = new double[paramDim];
 
     typename BaseTransformType::ParametersType finalParameters = registration->GetLastTransformParameters();
     for( unsigned int i=0; i<paramDim; i++)
     {
       m_EstimatedParameters[i] = finalParameters[i];
     }
 
     // remove optimizer tag if used
     if( vopt_tag )
     {
       optimizer->RemoveObserver( vopt_tag );
     }
 
 
   }
 
   template< typename TPixel, unsigned int VDimension>
   void ResampleMitkImage( itk::Image<TPixel, VDimension>* itkImage,
                           mitk::Image::Pointer& outputImage )
   {
     typedef typename itk::Image< TPixel, VDimension> ImageType;
     typedef typename itk::ResampleImageFilter<  ImageType, ImageType, double> ResampleImageFilterType;
 
     typedef itk::LinearInterpolateImageFunction< ImageType, double > InterpolatorType;
     typename InterpolatorType::Pointer linear_interpolator = InterpolatorType::New();
 
     typedef itk::WindowedSincInterpolateImageFunction< ImageType, 7> WindowedSincInterpolatorType;
     typename WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
     typename mitk::ImageToItk< ImageType >::Pointer reference_image = mitk::ImageToItk< ImageType >::New();
     reference_image->SetInput( this->m_FixedImage );
     reference_image->Update();
 
     typedef itk::MatrixOffsetTransformBase< double, 3, 3> BaseTransformType;
     BaseTransformType::Pointer base_transform = BaseTransformType::New();
 
     if( this->m_UseAffineTransform )
     {
         typedef itk::AffineTransform< double > TransformType;
         TransformType::Pointer transform = TransformType::New();
 
         TransformType::ParametersType affine_params( TransformType::ParametersDimension );
         this->GetParameters( &affine_params[0] );
 
         transform->SetParameters( affine_params );
 
         base_transform = transform;
     }
     // Rigid
     else
     {
         typedef itk::Euler3DTransform< double > RigidTransformType;
         RigidTransformType::Pointer rtransform = RigidTransformType::New();
 
         RigidTransformType::ParametersType rigid_params( RigidTransformType::ParametersDimension  );
         this->GetParameters( &rigid_params[0] );
 
         rtransform->SetParameters( rigid_params );
 
         base_transform = rtransform;
     }
 
     typename ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
     resampler->SetInterpolator( linear_interpolator );
     if( m_UseWindowedSincInterpolator )
       resampler->SetInterpolator( sinc_interpolator );
 
     resampler->SetInput( itkImage );
     resampler->SetTransform( base_transform );
     resampler->SetReferenceImage( reference_image->GetOutput() );
     resampler->UseReferenceImageOn();
 
     resampler->Update();
 
 
     mitk::GrabItkImageMemory( resampler->GetOutput(), outputImage);
 
   }
 
 };
 
 } // end namespace
 
 #endif // MITKPYRAMIDIMAGEREGISTRATION_H