diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp
index fdfa5244ac..f74f74be5c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiWriterService.cpp
@@ -1,301 +1,301 @@
 /*===================================================================
 
 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 __mitkDiffusionImageNiftiWriterService__cpp
 #define __mitkDiffusionImageNiftiWriterService__cpp
 
 #include "mitkDiffusionImageNiftiWriterService.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include "mitkImageCast.h"
 #include <mitkLocaleSwitch.h>
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService(const mitk::DiffusionImageNiftiWriterService& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::DiffusionImageNiftiWriterService::~DiffusionImageNiftiWriterService()
 {}
 
 void mitk::DiffusionImageNiftiWriterService::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to DiffusionImageNiftiWriterService is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   mitk::LocaleSwitch localeSwitch("C");
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
     sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
   }
 
   for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
   {
     sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
     /*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
     std::string(keybuffer),tmp))
     continue;*/
 
     sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
       mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = this->GetMimeType()->GetExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .nii.gz
   if( ext == "")
   {
     ext = ".nii.gz";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
   if (ext == ".nii" || ext == ".nii.gz")
   {
     MITK_INFO << "Writing Nifti-Image";
 
     typedef itk::Image<short,4> ImageType4D;
     ImageType4D::Pointer img4 = ImageType4D::New();
 
     ImageType::SpacingType spacing = itkImg->GetSpacing();
     ImageType4D::SpacingType spacing4;
     for(int i=0; i<3; i++)
       spacing4[i] = spacing[i];
     spacing4[3] = 1;
     img4->SetSpacing( spacing4 );   // Set the image spacing
 
     ImageType::PointType origin = itkImg->GetOrigin();
     ImageType4D::PointType origin4;
     for(int i=0; i<3; i++)
       origin4[i] = origin[i];
     origin4[3] = 0;
     img4->SetOrigin( origin4 );     // Set the image origin
 
     ImageType::DirectionType direction = itkImg->GetDirection();
     ImageType4D::DirectionType direction4;
     for(int i=0; i<3; i++)
       for(int j=0; j<3; j++)
         direction4[i][j] = direction[i][j];
     for(int i=0; i<4; i++)
       direction4[i][3] = 0;
     for(int i=0; i<4; i++)
       direction4[3][i] = 0;
     direction4[3][3] = 1;
     img4->SetDirection( direction4 );  // Set the image direction
 
     ImageType::RegionType region = itkImg->GetLargestPossibleRegion();
     ImageType4D::RegionType region4;
 
     ImageType::RegionType::SizeType size = region.GetSize();
     ImageType4D::RegionType::SizeType size4;
 
     for(int i=0; i<3; i++)
       size4[i] = size[i];
     size4[3] = itkImg->GetVectorLength();
 
     ImageType::RegionType::IndexType index = region.GetIndex();
     ImageType4D::RegionType::IndexType index4;
     for(int i=0; i<3; i++)
       index4[i] = index[i];
     index4[3] = 0;
 
     region4.SetSize(size4);
     region4.SetIndex(index4);
     img4->SetRegions( region4 );
 
     img4->Allocate();
 
     itk::ImageRegionIterator<ImageType>   it (itkImg, itkImg->GetLargestPossibleRegion() );
     typedef ImageType::PixelType VecPixType;
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       ImageType::IndexType currentIndex = it.GetIndex();
       for(unsigned int ind=0; ind<vec.Size(); ind++)
       {
 
         for(int i=0; i<3; i++)
           index4[i] = currentIndex[i];
         index4[3] = ind;
         img4->SetPixel(index4, vec[ind]);
       }
     }
 
     itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
 
     typedef itk::ImageFileWriter<ImageType4D> WriterType4;
     WriterType4::Pointer nrrdWriter4 = WriterType4::New();
     nrrdWriter4->UseInputMetaDataDictionaryOn();
     nrrdWriter4->SetInput( img4 );
     nrrdWriter4->SetFileName(this->GetOutputLocation());
     nrrdWriter4->UseCompressionOn();
     nrrdWriter4->SetImageIO(io4);
     try
     {
       nrrdWriter4->Update();
     }
-    catch (const itk::ExceptionObject& e)
+    catch (itk::ExceptionObject& e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
     if(mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size())
     {
       MITK_INFO << "Saving original gradient directions";
       std::ofstream myfile;
 
       std::string base_path = itksys::SystemTools::GetFilenamePath(this->GetOutputLocation());
       std::string fname = this->GetMimeType()->GetFilenameWithoutExtension(this->GetOutputLocation());
       MITK_INFO << this->GetOutputLocation();
       if (!base_path.empty())
           fname = base_path + "/" + fname;
 
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = this->GetMimeType()->GetFilenameWithoutExtension(this->GetOutputLocation());
       if (!base_path.empty())
           fname2 = base_path + "/" + fname2;
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
     }
     else if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       MITK_INFO << "Original gradient directions not found. Saving modified gradient directions";
       std::ofstream myfile;
       std::string fname = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
     }
   }
 }
 
 mitk::DiffusionImageNiftiWriterService* mitk::DiffusionImageNiftiWriterService::Clone() const
 {
   return new DiffusionImageNiftiWriterService(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNiftiWriterService::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
 #endif //__mitkDiffusionImageNiftiWriterService__cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp
index bd315d7063..6f55b17b04 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdWriterService.cpp
@@ -1,173 +1,173 @@
 /*===================================================================
 
 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 __mitkDiffusionImageNrrdWriterService__cpp
 #define __mitkDiffusionImageNrrdWriterService__cpp
 
 #include "mitkDiffusionImageNrrdWriterService.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include "mitkImageCast.h"
 #include <mitkLocaleSwitch.h>
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService(const mitk::DiffusionImageNrrdWriterService& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::DiffusionImageNrrdWriterService::~DiffusionImageNrrdWriterService()
 {}
 
 void mitk::DiffusionImageNrrdWriterService::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to DiffusionImageNrrdWriterService is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   mitk::LocaleSwitch localeSwitch("C");
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if (mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size())
   {
       MITK_INFO << "Saving original gradient directions";
       sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
       itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
 
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
         sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(0),
           mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(2));
 
         itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       }
   }
   else if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
       MITK_INFO << "Original gradient directions not found. Saving modified gradient directions";
       sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
       itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
 
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
         sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
           mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
         itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       }
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = this->GetMimeType()->GetExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .nrrd
   if( ext == "")
   {
     ext = ".nrrd";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
 
   if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
 
     typedef itk::ImageFileWriter<ImageType> WriterType;
     WriterType::Pointer nrrdWriter = WriterType::New();
     nrrdWriter->UseInputMetaDataDictionaryOn();
     nrrdWriter->SetInput( itkImg );
     nrrdWriter->SetImageIO(io);
     nrrdWriter->SetFileName(this->GetOutputLocation());
     nrrdWriter->UseCompressionOn();
     nrrdWriter->SetImageIO(io);
     try
     {
       nrrdWriter->Update();
     }
-    catch (const itk::ExceptionObject& e)
+    catch (itk::ExceptionObject& e)
     {
       std::cout << e << std::endl;
       throw;
     }
   }
 }
 
 mitk::DiffusionImageNrrdWriterService* mitk::DiffusionImageNrrdWriterService::Clone() const
 {
   return new DiffusionImageNrrdWriterService(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNrrdWriterService::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
 #endif //__mitkDiffusionImageNrrdWriterService__cpp
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp
index 9b2ee7ea83..e7ca02f4e4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageWriter.cpp
@@ -1,99 +1,99 @@
 /*===================================================================
 
 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 "mitkNrrdTensorImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itkDiffusionTensor3D.h"
 #include "mitkImageCast.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include <mitkLocaleSwitch.h>
 
 
 mitk::NrrdTensorImageWriter::NrrdTensorImageWriter()
   : AbstractFileWriter(mitk::TensorImage::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DTI_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DTI_MIMETYPE_DESCRIPTION() )
 {
   RegisterService();
 }
 
 mitk::NrrdTensorImageWriter::NrrdTensorImageWriter(const mitk::NrrdTensorImageWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
 
 mitk::NrrdTensorImageWriter::~NrrdTensorImageWriter()
 {}
 
 
 void mitk::NrrdTensorImageWriter::Write()
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull() )
   {
     MITK_ERROR <<"Sorry, input to NrrdTensorImageWriter is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!" ;
     return ;
   }
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
   typedef itk::ImageFileWriter<TensorImage::ItkTensorImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
 
   TensorImage::ItkTensorImageType::Pointer outimage = TensorImage::ItkTensorImageType::New();
   CastToItkImage(input, outimage);
 
   nrrdWriter->SetInput( outimage );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(this->GetOutputLocation().c_str());
   nrrdWriter->UseCompressionOn();
 
   try
   {
     nrrdWriter->Update();
   }
-  catch (const itk::ExceptionObject& e)
+  catch (itk::ExceptionObject &e)
   {
     std::cout << e << std::endl;
   }
 }
 
 mitk::NrrdTensorImageWriter* mitk::NrrdTensorImageWriter::Clone() const
 {
   return new NrrdTensorImageWriter(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::NrrdTensorImageWriter::GetConfidenceLevel() const
 {
   InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
   if (input.IsNull() )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
diff --git a/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp b/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp
index 28833a1370..3b0156fb46 100644
--- a/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp
+++ b/Modules/MatchPointRegistration/autoload/IO/mitkMAPRegistrationWrapperIO.cpp
@@ -1,319 +1,319 @@
 /*===================================================================
 
 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 <iostream>
 #include <fstream>
 
 #include <clocale>
 
 #include "mapRegistration.h"
 #include "mapRegistrationFileWriter.h"
 #include "mapRegistrationFileReader.h"
 #include "mapLazyFileFieldKernelLoader.h"
 
 #include <mitkCustomMimeType.h>
 #include <mitkIOMimeTypes.h>
 
 #include "mitkMAPRegistrationWrapperIO.h"
 #include "mitkMAPRegistrationWrapper.h"
 
 namespace mitk
 {
 
   /** Helper structure to change (and reset) the
   * local settings in a function scope*/
   struct LocaleSwitch
   {
     LocaleSwitch(const std::string& newLocale)
       : m_OldLocale(std::setlocale(LC_ALL, nullptr))
       , m_NewLocale(newLocale)
     {
       if (m_OldLocale == nullptr)
       {
         m_OldLocale = "";
       }
       else if (m_NewLocale != m_OldLocale)
       {
         // set the locale
         if (std::setlocale(LC_ALL, m_NewLocale.c_str()) == nullptr)
         {
           MITK_INFO << "Could not set locale " << m_NewLocale;
           m_OldLocale = nullptr;
         }
       }
     }
 
     ~LocaleSwitch()
     {
       if (m_OldLocale != nullptr && std::setlocale(LC_ALL, m_OldLocale) == nullptr)
       {
         MITK_INFO << "Could not reset locale " << m_OldLocale;
       }
     }
 
   private:
     const char* m_OldLocale;
     const std::string m_NewLocale;
   };
 
   /** Helper class that allows to use an functor in multiple combinations of
   * moving and target dimensions on a passed MAPRegistrationWrapper instance.\n
   * DimHelperSub is used DimHelper to iterate in a row of the dimension
   * combination matrix.
   */
   template< unsigned int i, unsigned int j, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelperSub
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& data)
     {
       if (TFunctor<i,j>::Execute(obj, data))
       {
         return true;
       }
       return DimHelperSub<i,j-1,TFunctor>::Execute(obj, data);
     }
   };
 
   /** Specialized template version of DimSubHelper that indicates the end
   * of the row in the dimension combination matrix, thus does nothing.
   */
   template< unsigned int i, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelperSub<i,1,TFunctor >
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper*, const map::core::String&)
     {
       //just unwind. Go to the next "row" with DimHelper
       return false;
     }
   };
 
   /** Helper class that allows to use an functor in multiple combinations of
   * moving and target dimensions on a passed MAPRegistrationWrapper instance.\n
   * It is helpful if you want to ensure that all combinations are checked/touched
   * (e.g. 3D 3D, 3D 2D, 2D 3D, 2D 2D) without generating a large switch yard.
   * Think of n*m matrix (indicating the posible combinations). DimHelper walks from
   * one row to the next and uses DimHelperSub to iterate in a row.\n
   * For every element of the matrix the functor is executed on the passed object.
   */
   template< unsigned int i,  unsigned int j, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelper{
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& data = "")
     {
       if (DimHelperSub<i,j,TFunctor>::Execute(obj, data))
       {
         return true;
       }
       return DimHelper<i-1,j,TFunctor>::Execute(obj, data);
     }
   };
 
   /** Specialized template version of DimHelper that indicates the end
   * of the dimension combination matrix, thus does nothing.
   */
   template< unsigned int j, template < unsigned int,  unsigned int> class TFunctor>
   class DimHelper<1,j, TFunctor >
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper*, const map::core::String&)
     {
       //just unwind. We are done.
       return false;
     }
   };
 
   /** Functor that checks of the dimension of the registration is supported and can
   * be written.
   */
   template<unsigned int i, unsigned int j>
   class CanWrite
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& = "")
     {
       bool result = false;
 
       result = dynamic_cast<const map::core::Registration<i,j> *>(obj->GetRegistration()) != nullptr;
 
       return result;
     }
   };
 
   /** Functor that writes the registration to a file if it has the right dimensionality.
   */
   template<unsigned int i, unsigned int j>
   class WriteReg
   {
   public:
     static bool Execute(const mitk::MAPRegistrationWrapper* obj, const map::core::String& data)
     {
       const map::core::Registration<i,j>* pReg = dynamic_cast<const map::core::Registration<i,j>*>(obj->GetRegistration());
       if (pReg == nullptr)
       {
         return false;
       }
 
       typedef map::io::RegistrationFileWriter<i,j> WriterType;
       typename WriterType::Pointer writer = WriterType::New();
 
       writer->setExpandLazyKernels(false);
 
       try
       {
         writer->write(pReg,data);
       }
-      catch (const itk::ExceptionObject& e)
+      catch (itk::ExceptionObject &e)
       {
         std::cout << e << std::endl;
         throw;
       }
 
       return true;
     }
   };
 
   MAPRegistrationWrapperIO::MAPRegistrationWrapperIO(const MAPRegistrationWrapperIO& other)
     : AbstractFileIO(other)
   {
   }
 
   MAPRegistrationWrapperIO::MAPRegistrationWrapperIO() : AbstractFileIO(mitk::MAPRegistrationWrapper::GetStaticNameOfClass())
   {
     std::string category = "MatchPoint Registration File";
     CustomMimeType customMimeType;
     customMimeType.SetCategory(category);
     customMimeType.AddExtension("mapr");
     this->AbstractFileIOWriter::SetMimeType(customMimeType);
     this->AbstractFileIOWriter::SetDescription(category);
 
     customMimeType.AddExtension("mapr.xml");
     customMimeType.AddExtension("MAPR");
     customMimeType.AddExtension("MAPR.XML");
     this->AbstractFileIOReader::SetMimeType(customMimeType);
     this->AbstractFileIOReader::SetDescription(category);
 
     this->RegisterService();
   }
 
 
   void MAPRegistrationWrapperIO::Write()
   {
     bool success = false;
     const BaseData* input = this->GetInput();
     if (input == nullptr)
     {
       mitkThrow() << "Cannot write data. Data pointer is nullptr.";
     }
 
     const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast<const mitk::MAPRegistrationWrapper*>(input);
     if (wrapper == nullptr)
     {
       mitkThrow() << "Cannot write data. Data pointer is not a Registration wrapper.";
     }
 
     std::ostream* writeStream = this->GetOutputStream();
     std::string fileName = this->GetOutputLocation();
     if (writeStream)
     {
       fileName = this->GetLocalFileName();
     }
 
     // Switch the current locale to "C"
     LocaleSwitch localeSwitch("C");
 
     try
     {
       success = DimHelper<3,3,WriteReg>::Execute(wrapper, fileName);
     }
     catch (const std::exception& e)
     {
       mitkThrow() << e.what();
     }
 
     if (!success)
     {
       mitkThrow() << "Cannot write registration. Currently only registrations up to 4D are supported.";
     }
   }
 
   AbstractFileIO::ConfidenceLevel MAPRegistrationWrapperIO::GetWriterConfidenceLevel() const
   {
     const mitk::MAPRegistrationWrapper* regWrapper =  dynamic_cast<const mitk::MAPRegistrationWrapper*>(this->GetInput());
 
     if (regWrapper == nullptr)
     {
       return IFileWriter::Unsupported;
     }
 
     // Check if the registration dimension is supported
     if (! DimHelper<3,3,CanWrite>::Execute(regWrapper))
     {
       return IFileWriter::Unsupported;
     };
 
     return IFileWriter::Supported;
   }
 
   std::vector<BaseData::Pointer >  MAPRegistrationWrapperIO::Read()
   {
     std::vector<BaseData::Pointer > result;
 
     LocaleSwitch("C");
 
     std::string fileName = this->GetLocalFileName();
     if ( fileName.empty() )
     {
       mitkThrow() << "Cannot read file. Filename has not been set!";
     }
 
     /* Remove the following kernel loader provider because in MITK no lazy file loading should be used
     due to conflicts with session loading (end there usage of temporary directories)*/
     map::io::RegistrationFileReader::LoaderStackType::unregisterProvider(map::io::LazyFileFieldKernelLoader<2,2>::getStaticProviderName());
     map::io::RegistrationFileReader::LoaderStackType::unregisterProvider(map::io::LazyFileFieldKernelLoader<3,3>::getStaticProviderName());
 
     map::io::RegistrationFileReader::Pointer spReader = map::io::RegistrationFileReader::New();
     spReader->setPreferLazyLoading(true);
     map::core::RegistrationBase::Pointer spReg = spReader->read(fileName);
     mitk::MAPRegistrationWrapper::Pointer spRegWrapper = mitk::MAPRegistrationWrapper::New();
     spRegWrapper->SetRegistration(spReg);
 
     result.push_back(spRegWrapper.GetPointer());
     return result;
   }
 
   AbstractFileIO::ConfidenceLevel MAPRegistrationWrapperIO::GetReaderConfidenceLevel() const
   {
     AbstractFileIO::ConfidenceLevel result = IFileReader::Unsupported;
 
     std::string fileName = this->GetLocalFileName();
     std::ifstream in( fileName.c_str() );
     if ( in.good() )
     {
       result = IFileReader::Supported;
     }
 
     in.close();
     return result;
   }
 
   MAPRegistrationWrapperIO* MAPRegistrationWrapperIO::IOClone() const
   {
     return new MAPRegistrationWrapperIO(*this);
   }
 
 }