diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionCmdApps/CMakeLists.txt
index caec097f16..ffbde72f1d 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/CMakeLists.txt
@@ -1,20 +1,20 @@
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-DTI
   # INCLUDE_DIRS Helpers
-  DEPENDS MitkDiffusionCore MitkDiffusionCoreIO MitkDiffusionIO MitkFiberTracking MitkQuantification MitkConnectomics
+  DEPENDS MitkDiffusionCore MitkDiffusionIO MitkFiberTracking MitkQuantification MitkConnectomics
   PACKAGE_DEPENDS PUBLIC ITK
 )
 
 if(MODULE_IS_ENABLED)
   add_subdirectory(Connectomics)
   add_subdirectory(Fiberfox)
   add_subdirectory(FiberProcessing)
   add_subdirectory(Tractography)
   add_subdirectory(TractographyEvaluation)
   add_subdirectory(Misc)
   add_subdirectory(Quantification)
 
 if(MITK_USE_Python)
   add_subdirectory(Python)
 endif()
 endif()
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp
index 46f337b19e..26d4854584 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp
@@ -1,255 +1,253 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 #include "mitkCommandLineParser.h"
 
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkLexicalCast.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkFiberfoxParameters.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
-#include <mitkIOMimeTypes.h>
 
 using namespace mitk;
 
 /*!
 * \brief Command line interface to Fiberfox.
 * Simulate a diffusion-weighted image from a tractogram using the specified parameter file.
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setTitle("Fiberfox");
   parser.setCategory("Diffusion Simulation Tools");
   parser.setContributor("MIC");
   parser.setDescription("Command line interface to Fiberfox." " Simulate a diffusion-weighted image from a tractogram using the specified parameter file.");
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output root:", "output root", us::Any(), false);
   parser.addArgument("", "i", mitkCommandLineParser::String, "Input:", "Input tractogram or diffusion-weighted image.", us::Any(), false);
   parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter file:", "fiberfox parameter file (.ffp)", us::Any(), false);
   parser.addArgument("template", "t", mitkCommandLineParser::String, "Template image:", "Use parameters of the template diffusion-weighted image.", us::Any());
   parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Output additional images:", "output volume fraction images etc.", us::Any());
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   std::string outName = us::any_cast<std::string>(parsedArgs["o"]);
   std::string paramName = us::any_cast<std::string>(parsedArgs["parameters"]);
 
   std::string input="";
   if (parsedArgs.count("i"))
     input = us::any_cast<std::string>(parsedArgs["i"]);
 
   bool verbose = false;
   if (parsedArgs.count("verbose"))
     verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
   FiberfoxParameters parameters;
   parameters.LoadParameters(paramName);
 
   // Test if /path/dir is an existing directory:
   std::string file_extension = "";
   if( itksys::SystemTools::FileIsDirectory( outName ) )
   {
     while( *(--(outName.cend())) == '/')
     {
       outName.pop_back();
     }
     outName = outName + '/';
     parameters.m_Misc.m_OutputPath = outName;
     outName = outName + parameters.m_Misc.m_OutputPrefix; // using default m_OutputPrefix as initialized.
   }
   else
   {
     // outName is NOT an existing directory, so we need to remove all trailing slashes:
     while( *(--(outName.cend())) == '/')
     {
       outName.pop_back();
     }
 
     // now split up the given outName into directory and (prefix of) filename:
     if( ! itksys::SystemTools::GetFilenamePath( outName ).empty()
         && itksys::SystemTools::FileIsDirectory(itksys::SystemTools::GetFilenamePath( outName ) ) )
     {
       parameters.m_Misc.m_OutputPath = itksys::SystemTools::GetFilenamePath( outName ) + '/';
     }
     else
     {
       parameters.m_Misc.m_OutputPath = itksys::SystemTools::GetCurrentWorkingDirectory() + '/';
     }
 
     file_extension = itksys::SystemTools::GetFilenameExtension(outName);
     if( ! itksys::SystemTools::GetFilenameWithoutExtension( outName ).empty() )
     {
       parameters.m_Misc.m_OutputPrefix = itksys::SystemTools::GetFilenameWithoutExtension( outName );
     }
     else
     {
       parameters.m_Misc.m_OutputPrefix = "fiberfox";
     }
 
     outName = parameters.m_Misc.m_OutputPath + parameters.m_Misc.m_OutputPrefix;
   }
 
   // check if log file already exists and avoid overwriting existing files:
   std::string NameTest = outName;
   int c = 0;
   while( itksys::SystemTools::FileExists( outName + ".log" )
          && c <= std::numeric_limits<int>::max() )
   {
     outName = NameTest + "_" + boost::lexical_cast<std::string>(c);
     ++c;
   }
 
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images", "Fiberbundles"}, {});
   mitk::BaseData::Pointer inputData = mitk::IOUtil::Load(input, &functor)[0];
 
   itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
 
   if ( dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()) )   // simulate dataset from fibers
   {
     tractsToDwiFilter->SetFiberBundle(dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()));
 
     if (parsedArgs.count("template"))
     {
       MITK_INFO << "Loading template image";
       typedef itk::VectorImage< short, 3 >    ItkDwiType;
       typedef itk::Image< short, 3 >    ItkImageType;
       mitk::BaseData::Pointer templateData = mitk::IOUtil::Load(us::any_cast<std::string>(parsedArgs["template"]), &functor)[0];
       mitk::Image::Pointer template_image = dynamic_cast<mitk::Image*>(templateData.GetPointer());
 
       if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(template_image))
       {
         ItkDwiType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(template_image);
         parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
         parameters.SetBvalue(mitk::DiffusionPropertyHelper::GetReferenceBValue(template_image));
         parameters.SetGradienDirections(mitk::DiffusionPropertyHelper::GetGradientContainer(template_image));
       }
       else
       {
         ItkImageType::Pointer itkImagePointer = ItkImageType::New();
         mitk::CastToItkImage(template_image, itkImagePointer);
         parameters.m_SignalGen.m_ImageRegion = itkImagePointer->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkImagePointer->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkImagePointer->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkImagePointer->GetDirection();
       }
     }
   }
   else if ( dynamic_cast<mitk::Image*>(inputData.GetPointer()) )  // add artifacts to existing image
   {
     typedef itk::VectorImage< short, 3 >    ItkDwiType;
     mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(inputData.GetPointer());
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
     parameters.m_SignalGen.m_SignalScale = 1;
     parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
     parameters.SetBvalue(mitk::DiffusionPropertyHelper::GetReferenceBValue(diffImg));
     parameters.SetGradienDirections(mitk::DiffusionPropertyHelper::GetGradientContainer(diffImg));
 
     tractsToDwiFilter->SetInputImage(itkVectorImagePointer);
   }
 
   if (verbose)
   {
     MITK_DEBUG << outName << ".ffp";
     parameters.SaveParameters(outName+".ffp");
   }
   tractsToDwiFilter->SetParameters(parameters);
   tractsToDwiFilter->Update();
 
   mitk::Image::Pointer image = mitk::GrabItkImageMemory(tractsToDwiFilter->GetOutput());
   mitk::DiffusionPropertyHelper::SetGradientContainer(image, parameters.m_SignalGen.GetItkGradientContainer());
   mitk::DiffusionPropertyHelper::SetReferenceBValue(image, parameters.m_SignalGen.GetBvalue());
   mitk::DiffusionPropertyHelper::InitializeImage(image);
 
   if (file_extension=="")
-    mitk::IOUtil::Save(image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outName+".nii.gz");
+    mitk::IOUtil::Save(image, "DWI_NIFTI", outName+".nii.gz");
   else if (file_extension==".nii" || file_extension==".nii.gz")
-    mitk::IOUtil::Save(image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outName+file_extension);
+    mitk::IOUtil::Save(image, "DWI_NIFTI", outName+file_extension);
   else
     mitk::IOUtil::Save(image, outName+file_extension);
 
   if (verbose)
   {
     std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
     for (unsigned int k=0; k<volumeFractions.size(); k++)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(volumeFractions.at(k).GetPointer());
       image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Compartment"+boost::lexical_cast<std::string>(k+1)+".nii.gz");
     }
 
     if (tractsToDwiFilter->GetPhaseImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkPhase = tractsToDwiFilter->GetPhaseImage();
       image = mitk::GrabItkImageMemory( itkPhase.GetPointer() );
       mitk::IOUtil::Save(image, outName+"_Phase.nii.gz");
     }
 
     if (tractsToDwiFilter->GetKspaceImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkImage = tractsToDwiFilter->GetKspaceImage();
       image = mitk::GrabItkImageMemory( itkImage.GetPointer() );
       mitk::IOUtil::Save(image, outName+"_kSpace.nii.gz");
     }
 
     int c = 1;
     std::vector< itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer > output_real = tractsToDwiFilter->GetOutputImagesReal();
     for (auto real : output_real)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(real.GetPointer());
       image->SetVolume(real->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Coil-"+boost::lexical_cast<std::string>(c)+"-real.nii.gz");
       ++c;
     }
 
     c = 1;
     std::vector< itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer > output_imag = tractsToDwiFilter->GetOutputImagesImag();
     for (auto imag : output_imag)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(imag.GetPointer());
       image->SetVolume(imag->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Coil-"+boost::lexical_cast<std::string>(c)+"-imag.nii.gz");
       ++c;
     }
   }
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DImp.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DImp.cpp
index 226f5c5089..798a943a64 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DImp.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DImp.cpp
@@ -1,73 +1,72 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <itksys/SystemTools.hxx>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("DIMP");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("TEMPORARY: Converts DICOM to other image types");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string imageName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string outImage = us::any_cast<std::string>(parsedArgs["o"]);
 
   try
   {
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer source = mitk::IOUtil::Load<mitk::Image>(imageName, &functor);
 
     std::string ext = itksys::SystemTools::GetFilenameExtension(outImage);
     if (ext==".nii" || ext==".nii.gz")
-      mitk::IOUtil::Save(source, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outImage);
+      mitk::IOUtil::Save(source, "DWI_NIFTI", outImage);
     else
       mitk::IOUtil::Save(source, outImage);
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp
index 093bbaa12a..53f43b7fa3 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp
@@ -1,223 +1,222 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkMultiModalRigidDefaultRegistrationAlgorithm.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkAlgorithmHelper.h>
 #include <itkExtractDwiChannelFilter.h>
 #include <mitkRegistrationHelper.h>
 #include <mitkImageMappingHelper.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itkComposeImageFilter.h>
 #include <mitkITKImageImport.h>
 #include <mitkDiffusionImageCorrectionFilter.h>
 #include <mitkDiffusionDataIOHelper.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 
 typedef mitk::DiffusionPropertyHelper DPH;
 
 
 mitk::Image::Pointer apply_transform(mitk::Image::Pointer moving, mitk::Image::Pointer fixed_single, mitk::MAPRegistrationWrapper::Pointer reg, bool resample)
 {
   mitk::Image::Pointer registered_image;
   if (!resample)
   {
     registered_image = mitk::ImageMappingHelper::refineGeometry(moving, reg, true);
   }
   else
   {
     if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(moving))
     {
       registered_image = mitk::ImageMappingHelper::map(moving, reg, false, 0, fixed_single->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
     }
     else
     {
       typedef itk::Image<mitk::DiffusionPropertyHelper::DiffusionPixelType, 3> ITKDiffusionVolumeType;
       typedef itk::ComposeImageFilter < ITKDiffusionVolumeType > ComposeFilterType;
       auto composer = ComposeFilterType::New();
 
       auto itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(moving);
       for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i)
       {
         itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
         filter->SetInput( itkVectorImagePointer);
         filter->SetChannelIndex(i);
         filter->Update();
 
         mitk::Image::Pointer gradientVolume = mitk::Image::New();
         gradientVolume->InitializeByItk( filter->GetOutput() );
         gradientVolume->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
 
         mitk::Image::Pointer registered_mitk_image = mitk::ImageMappingHelper::map(gradientVolume, reg, false, 0, fixed_single->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
 
         auto registered_itk_image = ITKDiffusionVolumeType::New();
         mitk::CastToItkImage(registered_mitk_image, registered_itk_image);
         composer->SetInput(i, registered_itk_image);
       }
       composer->Update();
 
       registered_image = mitk::GrabItkImageMemory( composer->GetOutput() );
       mitk::DiffusionPropertyHelper::CopyProperties(moving, registered_image, true);
 
       typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
       CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
       corrector->SetImage( registered_image );
       corrector->CorrectDirections( mitk::MITKRegistrationHelper::getAffineMatrix(reg, false)->GetMatrix().GetVnlMatrix() );
     }
   }
 
   return registered_image;
 }
 
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("DREG");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("TEMPORARY: Rigid registration of two images");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "f", mitkCommandLineParser::InputFile, "Fixed:", "fixed image", us::Any(), false);
   parser.addArgument("", "m", mitkCommandLineParser::InputFile, "Moving:", "moving image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
   parser.addArgument("resample", "", mitkCommandLineParser::Bool, "Resample:", "resample moving image", false);
   parser.addArgument("coreg", "", mitkCommandLineParser::StringList, "", "additionally apply transform to these images", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string f = us::any_cast<std::string>(parsedArgs["f"]);
   std::string m = us::any_cast<std::string>(parsedArgs["m"]);
   std::string o = us::any_cast<std::string>(parsedArgs["o"]);
 
   bool resample = false;
   if (parsedArgs.count("resample"))
     resample = true;
 
   mitkCommandLineParser::StringContainerType coreg;
   if (parsedArgs.count("coreg"))
     coreg = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["coreg"]);
 
   try
   {
     typedef itk::Image< float, 3 > ItkFloatImageType;
 
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer fixed = mitk::IOUtil::Load<mitk::Image>(f, &functor);
     mitk::Image::Pointer moving = mitk::IOUtil::Load<mitk::Image>(m, &functor);
 
     mitk::Image::Pointer fixed_single = fixed;
     mitk::Image::Pointer moving_single = moving;
 
     mitk::MultiModalRigidDefaultRegistrationAlgorithm< ItkFloatImageType >::Pointer algo = mitk::MultiModalRigidDefaultRegistrationAlgorithm< ItkFloatImageType >::New();
     mitk::MITKAlgorithmHelper helper(algo);
 
     if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(fixed))
     {
       DPH::ImageType::Pointer itkVectorImagePointer = DPH::ImageType::New();
       mitk::CastToItkImage(fixed, itkVectorImagePointer);
 
       itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
       filter->SetInput( itkVectorImagePointer);
       filter->SetChannelIndex(0);
       filter->Update();
 
       fixed_single = mitk::Image::New();
       fixed_single->InitializeByItk( filter->GetOutput() );
       fixed_single->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
     }
 
     if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(moving))
     {
       DPH::ImageType::Pointer itkVectorImagePointer = DPH::ImageType::New();
       mitk::CastToItkImage(moving, itkVectorImagePointer);
 
       itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
       filter->SetInput( itkVectorImagePointer);
       filter->SetChannelIndex(0);
       filter->Update();
 
       moving_single = mitk::Image::New();
       moving_single->InitializeByItk( filter->GetOutput() );
       moving_single->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
     }
 
     helper.SetData(moving_single, fixed_single);
     mitk::MAPRegistrationWrapper::Pointer reg = helper.GetMITKRegistrationWrapper();
 
     mitk::Image::Pointer registered_image = apply_transform(moving, fixed_single, reg, resample);
     if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(registered_image))
     {
       mitk::DiffusionPropertyHelper::InitializeImage( registered_image );
 
       std::string file_extension = itksys::SystemTools::GetFilenameExtension(o);
       if (file_extension==".nii" || file_extension==".nii.gz")
-        mitk::IOUtil::Save(registered_image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), o);
+        mitk::IOUtil::Save(registered_image, "DWI_NIFTI", o);
       else
         mitk::IOUtil::Save(registered_image, o);
     }
     else
       mitk::IOUtil::Save(registered_image, o);
 
     std::string path = ist::GetFilenamePath(o) + "/";
     std::vector< std::string > file_names;
     auto coreg_images = mitk::DiffusionDataIOHelper::load_mitk_images(coreg, &file_names);
     for (unsigned int i=0; i<coreg_images.size(); ++i)
     {
       std::string ext = ist::GetFilenameExtension(file_names.at(i));
       std::string out_name = path + ist::GetFilenameWithoutExtension(file_names.at(i)) + "_registered" + ext;
 
       registered_image = apply_transform(coreg_images.at(i), fixed_single, reg, resample);
       if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(registered_image))
       {
         mitk::DiffusionPropertyHelper::InitializeImage( registered_image );
 
         if (ext==".nii" || ext==".nii.gz")
-          mitk::IOUtil::Save(registered_image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), out_name);
+          mitk::IOUtil::Save(registered_image, "DWI_NIFTI", out_name);
         else
           mitk::IOUtil::Save(registered_image, out_name);
       }
       else
         mitk::IOUtil::Save(registered_image, out_name);
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DmriDenoising.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DmriDenoising.cpp
index 107332ac54..5eb61e3f6b 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DmriDenoising.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DmriDenoising.cpp
@@ -1,235 +1,234 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 #include <itkTotalVariationDenoisingImageFilter.h>
 #include <itkNonLocalMeansDenoisingFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkPatchBasedDenoisingImageFilter.h>
 #include <itkVectorImageToImageFilter.h>
 #include <itkComposeImageFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <itkGaussianRandomSpatialNeighborSubsampler.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("DmriDenoising");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("dMRI denoising tool");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
 
   parser.beginGroup("1. Mandatory arguments:");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
   parser.addArgument("type", "", mitkCommandLineParser::Int, "Type:", "0 (TotalVariation), 1 (Gauss), 2 (NLM)", 0);
   parser.endGroup();
 
   parser.beginGroup("2. Total variation parameters:");
   parser.addArgument("tv_iterations", "", mitkCommandLineParser::Int, "Iterations:", "", 1);
   parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "", 0.1);
   parser.endGroup();
 
   parser.beginGroup("3. Gauss parameters:");
   parser.addArgument("variance", "", mitkCommandLineParser::Float, "Variance:", "", 1.0);
   parser.endGroup();
 
   parser.beginGroup("4. NLM parameters:");
   parser.addArgument("nlm_iterations", "", mitkCommandLineParser::Int, "Iterations:", "", 4);
   parser.addArgument("sampling_radius", "", mitkCommandLineParser::Int, "Sampling radius:", "", 4);
   parser.addArgument("patch_radius", "", mitkCommandLineParser::Int, "Patch radius:", "", 1);
   parser.addArgument("num_patches", "", mitkCommandLineParser::Int, "Num. patches:", "", 10);
   parser.endGroup();
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string imageName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string outImage = us::any_cast<std::string>(parsedArgs["o"]);
 
   int type = 0;
   if (parsedArgs.count("type"))
     type = us::any_cast<int>(parsedArgs["type"]);
 
   int tv_iterations = 1;
   if (parsedArgs.count("tv_iterations"))
     tv_iterations = us::any_cast<int>(parsedArgs["tv_iterations"]);
 
   float lambda = 0.1;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   float variance = 1.0;
   if (parsedArgs.count("variance"))
     variance = us::any_cast<float>(parsedArgs["variance"]);
 
   int nlm_iterations = 4;
   if (parsedArgs.count("nlm_iterations"))
     nlm_iterations = us::any_cast<int>(parsedArgs["nlm_iterations"]);
 
   int sampling_radius = 4;
   if (parsedArgs.count("sampling_radius"))
     sampling_radius = us::any_cast<int>(parsedArgs["sampling_radius"]);
 
   int patch_radius = 1;
   if (parsedArgs.count("patch_radius"))
     patch_radius = us::any_cast<int>(parsedArgs["patch_radius"]);
 
   int num_patches = 10;
   if (parsedArgs.count("num_patches"))
     num_patches = us::any_cast<int>(parsedArgs["num_patches"]);
 
   try
   {
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer input_image = mitk::IOUtil::Load<mitk::Image>(imageName, &functor);
 
     typedef short                                                                         DiffusionPixelType;
     typedef itk::VectorImage<DiffusionPixelType, 3>                                       DwiImageType;
     typedef itk::Image<DiffusionPixelType, 3>                                             DwiVolumeType;
     typedef itk::DiscreteGaussianImageFilter < DwiVolumeType, DwiVolumeType >             GaussianFilterType;
     typedef itk::PatchBasedDenoisingImageFilter < DwiVolumeType, DwiVolumeType >          NlmFilterType;
     typedef itk::VectorImageToImageFilter < DiffusionPixelType >                          ExtractFilterType;
     typedef itk::ComposeImageFilter < itk::Image<DiffusionPixelType, 3> >                 ComposeFilterType;
 
     if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(input_image))
       mitkThrow() << "Input is not a diffusion-weighted image!";
 
     DwiImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(input_image);
 
     mitk::Image::Pointer denoised_image = nullptr;
 
     switch (type)
     {
     case 0:
     {
       ComposeFilterType::Pointer composer = ComposeFilterType::New();
       for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i)
       {
         ExtractFilterType::Pointer extractor = ExtractFilterType::New();
         extractor->SetInput( itkVectorImagePointer );
         extractor->SetIndex( i );
         extractor->Update();
         DwiVolumeType::Pointer gradient_volume = extractor->GetOutput();
         itk::TotalVariationDenoisingImageFilter< DwiVolumeType, DwiVolumeType >::Pointer filter = itk::TotalVariationDenoisingImageFilter< DwiVolumeType, DwiVolumeType >::New();
         filter->SetInput(gradient_volume);
         filter->SetLambda(lambda);
         filter->SetNumberIterations(tv_iterations);
         filter->Update();
         composer->SetInput(i, filter->GetOutput());
       }
       composer->Update();
       denoised_image = mitk::GrabItkImageMemory(composer->GetOutput());
       break;
     }
     case 1:
     {
       ExtractFilterType::Pointer extractor = ExtractFilterType::New();
       extractor->SetInput( itkVectorImagePointer );
       ComposeFilterType::Pointer composer = ComposeFilterType::New();
       for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
       {
         extractor->SetIndex(i);
         extractor->Update();
         GaussianFilterType::Pointer filter = GaussianFilterType::New();
         filter->SetVariance(variance);
         filter->SetInput(extractor->GetOutput());
         filter->Update();
         composer->SetInput(i, filter->GetOutput());
       }
       composer->Update();
       denoised_image = mitk::GrabItkImageMemory(composer->GetOutput());
       break;
     }
     case 2:
     {
       typedef itk::Statistics::GaussianRandomSpatialNeighborSubsampler< NlmFilterType::PatchSampleType, DwiVolumeType::RegionType > SamplerType;
       // sampling the image to find similar patches
       SamplerType::Pointer sampler = SamplerType::New();
       sampler->SetRadius( sampling_radius );
       sampler->SetVariance( sampling_radius*sampling_radius );
       sampler->SetNumberOfResultsRequested( num_patches );
 
       MITK_INFO << "Starting NLM denoising";
       ExtractFilterType::Pointer extractor = ExtractFilterType::New();
       extractor->SetInput( itkVectorImagePointer );
       ComposeFilterType::Pointer composer = ComposeFilterType::New();
       for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
       {
         extractor->SetIndex(i);
         extractor->Update();
         NlmFilterType::Pointer filter = NlmFilterType::New();
         filter->SetInput(extractor->GetOutput());
         filter->SetPatchRadius(patch_radius);
         filter->SetNoiseModel(NlmFilterType::RICIAN);
         filter->UseSmoothDiscPatchWeightsOn();
         filter->UseFastTensorComputationsOn();
 
         filter->SetNumberOfIterations(nlm_iterations);
         filter->SetSmoothingWeight( 1 );
         filter->SetKernelBandwidthEstimation(true);
 
         filter->SetSampler( sampler );
         filter->Update();
         composer->SetInput(i, filter->GetOutput());
         MITK_INFO << "Gradient " << i << " finished";
       }
       composer->Update();
       denoised_image = mitk::GrabItkImageMemory(composer->GetOutput());
       break;
     }
     }
 
     mitk::DiffusionPropertyHelper::SetGradientContainer(denoised_image, mitk::DiffusionPropertyHelper::GetGradientContainer(input_image));
     mitk::DiffusionPropertyHelper::SetReferenceBValue(denoised_image, mitk::DiffusionPropertyHelper::GetReferenceBValue(input_image));
     mitk::DiffusionPropertyHelper::InitializeImage( denoised_image );
 
     std::string ext = itksys::SystemTools::GetFilenameExtension(outImage);
     if (ext==".nii" || ext==".nii.gz")
-      mitk::IOUtil::Save(denoised_image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outImage);
+      mitk::IOUtil::Save(denoised_image, "DWI_NIFTI", outImage);
     else
       mitk::IOUtil::Save(denoised_image, outImage);
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/HeadMotionCorrection.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/HeadMotionCorrection.cpp
index c8e78f42be..fc7166f24e 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/HeadMotionCorrection.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/HeadMotionCorrection.cpp
@@ -1,79 +1,78 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkDWIHeadMotionCorrectionFilter.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("HeadMotionCorrection");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("Simple affine head-motion correction tool");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string imageName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string outImage = us::any_cast<std::string>(parsedArgs["o"]);
 
   try
   {
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer in_image = mitk::IOUtil::Load<mitk::Image>(imageName, &functor);
 
     mitk::DWIHeadMotionCorrectionFilter::Pointer registerer = mitk::DWIHeadMotionCorrectionFilter::New();
     registerer->SetInput(in_image);
     registerer->Update();
     mitk::Image::Pointer out_image = registerer->GetCorrectedImage();
 
     std::string ext = itksys::SystemTools::GetFilenameExtension(outImage);
     if (ext==".nii" || ext==".nii.gz")
-      mitk::IOUtil::Save(out_image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outImage);
+      mitk::IOUtil::Save(out_image, "DWI_NIFTI", outImage);
     else
       mitk::IOUtil::Save(out_image, outImage);
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/ResampleGradients.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/ResampleGradients.cpp
index ee1fe6e755..dcd7211304 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/ResampleGradients.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/ResampleGradients.cpp
@@ -1,231 +1,230 @@
 /*===================================================================
 
 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 <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 #include <istream>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <mitkImageCast.h>
 #include <mitkBaseData.h>
 #include "mitkCommandLineParser.h"
 #include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkGradientDirectionsProperty.h>
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 #include <itkImage.h>
 #include <mitkImage.h>
 #include "itkDWIVoxelFunctor.h"
 #include <mitkDiffusionPropertyHelper.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 
 typedef short DiffusionPixelType;
 typedef itk::VectorImage< short, 3 > ItkDwiType;
 
 // itk includes
 #include "itkTimeProbe.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 #include "itkBrainMaskExtractionImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkVectorContainer.h"
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 #include <itkMergeDiffusionImagesFilter.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <itkDwiNormilzationFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkOdfImage.h>
 
 // Multishell includes
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 
 // Multishell Functors
 #include <itkADCAverageFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkADCFitFunctor.h>
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 //#include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include <mitkPointSet.h>
 #include <itkAdcImageFilter.h>
 #include <itkBrainMaskExtractionImageFilter.h>
 #include <mitkImageCast.h>
 #include <mitkRotationOperation.h>
 //#include <QTableWidgetItem>
 //#include <QTableWidget>
 #include <mitkInteractionConst.h>
 #include <mitkImageAccessByItk.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itkImageDuplicator.h>
 #include <itkMaskImageFilter.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <itkCropImageFilter.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkRemoveDwiChannelFilter.h>
 #include <itkExtractDwiChannelFilter.h>
 #include <mitkITKImageImport.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <itkImageDuplicator.h>
 #include <itkFlipImageFilter.h>
 #include <mitkITKImageImport.h>
 #include "mitkPreferenceListReaderOptionsFunctor.h"
 
 mitk::Image::Pointer DoReduceGradientDirections(mitk::Image::Pointer image, double BValue, unsigned int numOfGradientsToKeep, bool use_first_n)
 {
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) {
     std::cout << "Image is not a Diffusion Weighted Image" << std::endl;
     //return;
   }
 
   typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
   typedef mitk::BValueMapProperty::BValueMap BValueMap;
 
   BValueMap shellSlectionMap;
   BValueMap originalShellMap = mitk::DiffusionPropertyHelper::GetBValueMap(image);
 
   std::vector<unsigned int> newNumGradientDirections;
 
   //Keeps 1 b0 gradient
   double B0Value = 0;
   shellSlectionMap[B0Value] = originalShellMap[B0Value];
   unsigned int num = 1;
   newNumGradientDirections.push_back(num);
 
   //BValue = 1000;
   shellSlectionMap[BValue] = originalShellMap[BValue];
   //numOfGradientsToKeep = 32;
   newNumGradientDirections.push_back(numOfGradientsToKeep);
 
 
   if (newNumGradientDirections.empty()) {
     std::cout << "newNumGradientDirections is empty" << std::endl;
     //return;
   }
 
   auto gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(image);
 
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
   std::cout << "1" << std::endl;
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
   filter->SetOriginalGradientDirections(gradientContainer);
   filter->SetNumGradientDirections(newNumGradientDirections);
   filter->SetOriginalBValueMap(originalShellMap);
   filter->SetShellSelectionBValueMap(shellSlectionMap);
   filter->SetUseFirstN(use_first_n);
   filter->Update();
   std::cout << "2" << std::endl;
 
   if( filter->GetOutput() == nullptr) {
     std::cout << "filter get output is nullptr" << std::endl;
   }
 
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( filter->GetOutput() );
   mitk::DiffusionPropertyHelper::CopyProperties(image, newImage, true);
   mitk::DiffusionPropertyHelper::SetGradientContainer(newImage, filter->GetGradientDirections());
   mitk::DiffusionPropertyHelper::InitializeImage( newImage );
 
   return newImage;
 }
 
 
 
 /*!
 \brief Resample gradients of input DWI image.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Resample Gradients");
     parser.setCategory("Preprocessing Tools");
     parser.setDescription("Resample gradients of input DWI image. You can select one b-value shell and the number of gradients within this shell you want to have. It will also keep one b0 image.");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("", "i", mitkCommandLineParser::String, "Input:", "input image", us::Any(), false);
     parser.addArgument("", "o", mitkCommandLineParser::String, "Output:", "output image", us::Any(), false);
     parser.addArgument("b_value", "", mitkCommandLineParser::Float, "b-value:", "float", 1000, false);
     parser.addArgument("num_gradients", "", mitkCommandLineParser::Int, "Nr of gradients:", "integer", 32, false);
     parser.addArgument("use_first_n", "", mitkCommandLineParser::Bool, "Use first N:", "no optimization, simply use first n gradients", 0);
 
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
 
     std::string inFileName = us::any_cast<std::string>(parsedArgs["i"]);
     std::string outFileName = us::any_cast<std::string>(parsedArgs["o"]);
     double bValue = us::any_cast<float>(parsedArgs["b_value"]);
     unsigned int nrOfGradients = us::any_cast<int>(parsedArgs["num_gradients"]);
     bool use_first_n = false;
     if (parsedArgs.count("use_first_n"))
       use_first_n = true;
 
     try
     {
         mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({ "Diffusion Weighted Images" }, {});
         mitk::Image::Pointer mitkImage = mitk::IOUtil::Load<mitk::Image>(inFileName, &functor);
         mitk::Image::Pointer newImage = DoReduceGradientDirections(mitkImage, bValue, nrOfGradients, use_first_n);
         //mitk::IOUtil::Save(newImage, outFileName); //save as dwi image
-        mitk::IOUtil::Save(newImage, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outFileName);  //save as nifti image
+        mitk::IOUtil::Save(newImage, "DWI_NIFTI", outFileName);  //save as nifti image
 
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/RoundBvalues.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/RoundBvalues.cpp
index ecd48a7c9a..eddb71f855 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/RoundBvalues.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/RoundBvalues.cpp
@@ -1,107 +1,106 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("RoundBvalues");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("Round b-values");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("n", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
   parser.addArgument("to_nearest", "", mitkCommandLineParser::Int, "To nearest:", "integer", 1000);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string imageName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string outImage = us::any_cast<std::string>(parsedArgs["o"]);
 
   int to_nearest = 1000;
   if (parsedArgs.count("to_nearest"))
     to_nearest = us::any_cast<int>(parsedArgs["to_nearest"]);
 
   try
   {
     typedef mitk::DiffusionPropertyHelper PropHelper;
 
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer in_image = mitk::IOUtil::Load<mitk::Image>(imageName, &functor);
 
     if (!PropHelper::IsDiffusionWeightedImage(in_image))
     {
       mitkThrow() << "Input is not a diffusion weighted image: " << imageName;
     }
 
     typedef itk::DwiGradientLengthCorrectionFilter FilterType;
 
     auto itkVectorImagePointer = PropHelper::GetItkVectorImage(in_image);
 
     FilterType::Pointer filter = FilterType::New();
     filter->SetRoundingValue(to_nearest);
     filter->SetReferenceBValue(PropHelper::GetReferenceBValue(in_image));
     filter->SetReferenceGradientDirectionContainer(PropHelper::GetGradientContainer(in_image));
     filter->Update();
 
     mitk::Image::Pointer newImage = mitk::Image::New();
     newImage->InitializeByItk( itkVectorImagePointer.GetPointer() );
     newImage->SetImportVolume( itkVectorImagePointer->GetBufferPointer(), 0, 0, mitk::Image::CopyMemory);
     itkVectorImagePointer->GetPixelContainer()->ContainerManageMemoryOff();
 
     PropHelper::CopyProperties(in_image, newImage, true);
     PropHelper::SetReferenceBValue(newImage, filter->GetNewBValue());
     PropHelper::SetGradientContainer(newImage, filter->GetOutputGradientDirectionContainer());
     PropHelper::InitializeImage(newImage);
 
     std::string ext = itksys::SystemTools::GetFilenameExtension(outImage);
     if (ext==".nii" || ext==".nii.gz")
-      mitk::IOUtil::Save(newImage, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), outImage);
+      mitk::IOUtil::Save(newImage, "DWI_NIFTI", outImage);
     else
       mitk::IOUtil::Save(newImage, outImage);
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Python/BrainExtraction.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Python/BrainExtraction.cpp
index 6dd083d6ab..5fd181b408 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Python/BrainExtraction.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Python/BrainExtraction.cpp
@@ -1,180 +1,179 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkDiffusionPropertyHelper.h>
 #include <itksys/SystemTools.hxx>
 #include <itkB0ImageExtractionToSeparateImageFilter.h>
 #include <mitkIPythonService.h>
 #include <mitkImageCast.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <BetData.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
 #include <boost/algorithm/string.hpp>
 
 typedef mitk::DiffusionPropertyHelper DPH;
 typedef itksys::SystemTools ist;
 
 std::string GetPythonFile(std::string filename, std::string exec_dir)
 {
   std::string out = "";
   for (auto dir : mitk::bet::relative_search_dirs)
   {
     if ( ist::FileExists( exec_dir + dir + filename) )
     {
       out = exec_dir + dir + filename;
       return out;
     }
     if ( ist::FileExists( ist::GetCurrentWorkingDirectory() + dir + filename) )
     {
       out = ist::GetCurrentWorkingDirectory() + dir + filename;
       return out;
     }
   }
   for (auto dir : mitk::bet::absolute_search_dirs)
   {
     if ( ist::FileExists( dir + filename) )
     {
       out = dir + filename;
       return out;
     }
   }
 
   return out;
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("BrainExtraction");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("Performs brain extraction using a deep learning model");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output root", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string i = us::any_cast<std::string>(parsedArgs["i"]);
   std::string o = us::any_cast<std::string>(parsedArgs["o"]);
 
   std::string exec_dir = ist::GetFilenamePath(argv[0]);
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
   mitk::Image::Pointer mitk_image = mitk::IOUtil::Load<mitk::Image>(i, &functor);
 
   bool missing_file = false;
   std::string missing_file_string = "";
   if ( GetPythonFile("run_mitk.py", exec_dir).empty() )
   {
     missing_file_string += "Brain extraction script file missing: run_mitk.py\n\n";
     missing_file = true;
   }
 
   if ( GetPythonFile("model_final.model", exec_dir).empty() )
   {
     missing_file_string += "Brain extraction model file missing: model_final.model\n\n";
     missing_file = true;
   }
 
   if ( GetPythonFile("basic_config_just_like_braintumor.py", exec_dir).empty() )
   {
     missing_file_string += "Config file missing: basic_config_just_like_braintumor.py\n\n";
     missing_file = true;
   }
 
   if (missing_file)
   {
     mitkThrow() << missing_file_string;
   }
 
   us::ModuleContext* context = us::GetModuleContext();
   us::ServiceReference<mitk::IPythonService> m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
   mitk::IPythonService* m_PythonService = dynamic_cast<mitk::IPythonService*> ( context->GetService<mitk::IPythonService>(m_PythonServiceRef) );
   mitk::IPythonService::ForceLoadModule();
 
   m_PythonService->AddAbsoluteSearchDirs(mitk::bet::absolute_search_dirs);
   m_PythonService->AddRelativeSearchDirs(mitk::bet::relative_search_dirs);
   m_PythonService->Execute("paths=[]");
 
   // set input files (model and config)
   m_PythonService->Execute("model_file=\""+GetPythonFile("model_final.model", exec_dir)+"\"");
   m_PythonService->Execute("config_file=\""+GetPythonFile("basic_config_just_like_braintumor.py", exec_dir)+"\"");
 
   // copy input  image to python
   m_PythonService->CopyToPythonAsSimpleItkImage( mitk_image, "in_image");
 
   // run segmentation script
   m_PythonService->ExecuteScript( GetPythonFile("run_mitk.py", exec_dir) );
 
   // clean up after running script (better way than deleting individual variables?)
   if(m_PythonService->DoesVariableExist("in_image"))
     m_PythonService->Execute("del in_image");
 
   // check for errors
   if(!m_PythonService->GetVariable("error_string").empty())
     mitkThrow() << m_PythonService->GetVariable("error_string");
 
   // get output images and add to datastorage
   std::string output_variables = m_PythonService->GetVariable("output_variables");
   std::vector<std::string> outputs;
   boost::split(outputs, output_variables, boost::is_any_of(","));
 
   std::string output_types = m_PythonService->GetVariable("output_types");
   std::vector<std::string> types;
   boost::split(types, output_types, boost::is_any_of(","));
 
   for (unsigned int i=0; i<outputs.size(); ++i)
   {
     if (m_PythonService->DoesVariableExist(outputs.at(i)))
     {
       mitk::Image::Pointer image = m_PythonService->CopySimpleItkImageFromPython(outputs.at(i));
 
       if(types.at(i)=="input" && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(mitk_image))
       {
         mitk::DiffusionPropertyHelper::CopyProperties(mitk_image, image, true);
         mitk::DiffusionPropertyHelper::InitializeImage(image);
       }
 
       mitk::DataNode::Pointer corrected_node = mitk::DataNode::New();
       corrected_node->SetData( image );
       std::string name = o + "_";
       name += outputs.at(i);
 
       if(types.at(i)=="input" && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(mitk_image))
-        mitk::IOUtil::Save(image, mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME(), name+".nii.gz");
+        mitk::IOUtil::Save(image, "DWI_NIFTI", name+".nii.gz");
       else
         mitk::IOUtil::Save(image, name+".nii.gz");
     }
   }
 
   MITK_INFO << "Finished brain extraction";
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Quantification/QballReconstruction.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Quantification/QballReconstruction.cpp
index 9d468702aa..e98e4078b9 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Quantification/QballReconstruction.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Quantification/QballReconstruction.cpp
@@ -1,268 +1,266 @@
 /*===================================================================
 
 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 <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include <mitkLexicalCast.h>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkIOUtil.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itkDiffusionMultiShellQballReconstructionImageFilter.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
-#include <mitkDiffusionCoreIOMimeTypes.h>
-#include <mitkIOMimeTypes.h>
 
 template<int L>
 void TemplatedMultishellQBallReconstruction(float lambda, mitk::Image::Pointer dwi, bool output_sampled, int threshold, std::string outfilename)
 {
   typedef itk::DiffusionMultiShellQballReconstructionImageFilter<short,short,float,L,ODF_SAMPLING_SIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   auto bMap = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
   auto it1 = bMap.rbegin();
   auto it2 = bMap.rbegin();
   ++it2;
 
   // Get average distance
   int avdistance = 0;
   for(; it2 != bMap.rend(); ++it1, ++it2)
     avdistance += static_cast<int>(it1->first - it2->first);
   avdistance /= bMap.size()-1;
 
   // Check if all shells are using the same averae distance
   it1 = bMap.rbegin();
   it2 = bMap.rbegin();
   ++it2;
   for(; it2 != bMap.rend(); ++it1,++it2)
   {
     if(avdistance != static_cast<int>(it1->first - it2->first))
     {
       mitkThrow() << "Shells are not equidistant.";
     }
   }
 
   auto itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(dwi);
   filter->SetBValueMap(bMap);
   filter->SetGradientImage(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer, mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
   filter->SetThreshold(static_cast<short>(threshold));
   filter->SetLambda(static_cast<double>(lambda));
   filter->Update();
 
   mitk::OdfImage::Pointer image = mitk::OdfImage::New();
   mitk::Image::Pointer coeffsImage = dynamic_cast<mitk::Image*>(mitk::ShImage::New().GetPointer());
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
   coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
 
   std::string coeffout = outfilename;
   coeffout += ".nii.gz";
-  mitk::IOUtil::Save(coeffsImage, mitk::DiffusionCoreIOMimeTypes::SH_MIMETYPE_NAME(), coeffout);
+  mitk::IOUtil::Save(coeffsImage, "SH_IMAGE", coeffout);
 
   outfilename += ".odf";
   if (output_sampled)
     mitk::IOUtil::Save(image, outfilename);
 }
 
 template<int L>
 void TemplatedCsaQBallReconstruction(float lambda, mitk::Image::Pointer dwi, bool output_sampled, int threshold, std::string outfilename)
 {
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,ODF_SAMPLING_SIZE> FilterType;
   auto itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(dwi);
 
   FilterType::Pointer filter = FilterType::New();
   filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
   filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
   filter->SetThreshold(static_cast<short>(threshold));
   filter->SetLambda(static_cast<double>(lambda));
 //  filter->SetUseMrtrixBasis(mrTrix);
   filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
   filter->Update();
 
   mitk::OdfImage::Pointer image = mitk::OdfImage::New();
   mitk::Image::Pointer coeffsImage = dynamic_cast<mitk::Image*>(mitk::ShImage::New().GetPointer());
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
   coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
 
   std::string coeffout = outfilename;
   coeffout += ".nii.gz";
-  mitk::IOUtil::Save(coeffsImage, mitk::DiffusionCoreIOMimeTypes::SH_MIMETYPE_NAME(), coeffout);
+  mitk::IOUtil::Save(coeffsImage, "SH_IMAGE", coeffout);
 
   outfilename += ".odf";
   if (output_sampled)
     mitk::IOUtil::Save(image, outfilename);
 }
 
 
 /**
  * Perform Q-ball reconstruction using a spherical harmonics basis
  */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input image", "input raw dwi (.dwi or .nii/.nii.gz)", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output image", "output image", us::Any(), false);
   parser.addArgument("sh_order", "", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order", 4);
   parser.addArgument("b0_threshold", "", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0);
   parser.addArgument("round_bvalues", "", mitkCommandLineParser::Int, "Round b-values", "round to specified integer", 0);
   parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda", "ragularization factor lambda", 0.006);
   parser.addArgument("output_sampled", "", mitkCommandLineParser::Bool, "Output sampled ODFs", "output file containing the sampled ODFs");
 
   parser.setCategory("Signal Modelling");
   parser.setTitle("Qball Reconstruction");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inFileName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string outfilename = us::any_cast<std::string>(parsedArgs["o"]);
   if (itksys::SystemTools::GetFilenamePath(outfilename).size()>0)
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
   else
     outfilename = itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
 
   int threshold = 0;
   if (parsedArgs.count("b0_threshold"))
     threshold = us::any_cast<int>(parsedArgs["b0_threshold"]);
 
   int round_bvalues = 0;
   if (parsedArgs.count("round_bvalues"))
     round_bvalues = us::any_cast<int>(parsedArgs["round_bvalues"]);
 
   int shOrder = 4;
   if (parsedArgs.count("sh_order"))
     shOrder = us::any_cast<int>(parsedArgs["sh_order"]);
 
   float lambda = 0.006f;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   bool outCoeffs = false;
   if (parsedArgs.count("output_coeffs"))
     outCoeffs = us::any_cast<bool>(parsedArgs["output_coeffs"]);
 
 //  bool mrTrix = false;
 //  if (parsedArgs.count("mrtrix"))
 //    mrTrix = us::any_cast<bool>(parsedArgs["mrtrix"]);
 
   try
   {
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     std::vector< mitk::BaseData::Pointer > infile = mitk::IOUtil::Load(inFileName, &functor);
 
     mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
 
     if (round_bvalues>0)
     {
       MITK_INFO << "Rounding b-values";
       typedef itk::DwiGradientLengthCorrectionFilter FilterType;
       FilterType::Pointer filter = FilterType::New();
       filter->SetRoundingValue(round_bvalues);
       filter->SetReferenceBValue(static_cast<double>(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi)));
       filter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
       filter->Update();
       mitk::DiffusionPropertyHelper::SetReferenceBValue(dwi, static_cast<float>(filter->GetNewBValue()));
       mitk::DiffusionPropertyHelper::CopyProperties(dwi, dwi, true);
       mitk::DiffusionPropertyHelper::SetGradientContainer(dwi, filter->GetOutputGradientDirectionContainer());
       mitk::DiffusionPropertyHelper::InitializeImage(dwi);
     }
 
     auto bMap = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
     if(bMap.size()!=4 && bMap.size()!=2)
       mitkThrow() << "Only three equidistant shells or a single shell are supported. Found " << bMap.size();
 
     MITK_INFO << "Averaging redundant gradients";
     mitk::DiffusionPropertyHelper::AverageRedundantGradients(dwi, 0.001);
 
     MITK_INFO << "SH order: " << shOrder;
     MITK_INFO << "lambda: " << lambda;
     MITK_INFO << "B0 threshold: " << threshold;
     MITK_INFO << "Round bvalues: " << round_bvalues;
     switch ( shOrder )
     {
     case 4:
     {
       if(bMap.size()==2)
         TemplatedCsaQBallReconstruction<4>(lambda, dwi, outCoeffs, threshold, outfilename);
       else if(bMap.size()==4)
         TemplatedMultishellQBallReconstruction<4>(lambda, dwi, outCoeffs, threshold, outfilename);
       break;
     }
     case 6:
     {
       if(bMap.size()==2)
         TemplatedCsaQBallReconstruction<6>(lambda, dwi, outCoeffs, threshold, outfilename);
       else if(bMap.size()==4)
         TemplatedMultishellQBallReconstruction<6>(lambda, dwi, outCoeffs, threshold, outfilename);
       break;
     }
     case 8:
     {
       if(bMap.size()==2)
         TemplatedCsaQBallReconstruction<8>(lambda, dwi, outCoeffs, threshold, outfilename);
       else if(bMap.size()==4)
         TemplatedMultishellQBallReconstruction<8>(lambda, dwi, outCoeffs, threshold, outfilename);
       break;
     }
     case 10:
     {
       if(bMap.size()==2)
         TemplatedCsaQBallReconstruction<10>(lambda, dwi, outCoeffs, threshold, outfilename);
       else if(bMap.size()==4)
         TemplatedMultishellQBallReconstruction<10>(lambda, dwi, outCoeffs, threshold, outfilename);
       break;
     }
     case 12:
     {
       if(bMap.size()==2)
         TemplatedCsaQBallReconstruction<12>(lambda, dwi, outCoeffs, threshold, outfilename);
       else if(bMap.size()==4)
         TemplatedMultishellQBallReconstruction<12>(lambda, dwi, outCoeffs, threshold, outfilename);
       break;
     }
     default:
     {
       mitkThrow() << "SH order not supported";
     }
     }
   }
   catch ( itk::ExceptionObject &err)
   {
     std::cout << "Exception: " << err;
   }
   catch ( std::exception err)
   {
     std::cout << "Exception: " << err.what();
   }
   catch ( ... )
   {
     std::cout << "Exception!";
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.h b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.h
index 1427a9e1c0..80441a180d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.h
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.h
@@ -1,119 +1,118 @@
 /*===================================================================
 
 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 MITKDiffusionCoreIOMimeTypes_H
 #define MITKDiffusionCoreIOMimeTypes_H
 
 #include "mitkCustomMimeType.h"
-#include <MitkDiffusionCoreIOExports.h>
 #include <string>
 
 namespace mitk {
 
-class MITKDIFFUSIONCOREIO_EXPORT DiffusionCoreIOMimeTypes
+class DiffusionCoreIOMimeTypes
 {
 public:
 
   class  DiffusionImageNrrdMimeType : public CustomMimeType
   {
   public:
     DiffusionImageNrrdMimeType();
     bool AppliesTo(const std::string &path) const override;
     DiffusionImageNrrdMimeType* Clone() const override;
   };
 
   class  DiffusionImageNiftiMimeType : public CustomMimeType
   {
   public:
     DiffusionImageNiftiMimeType();
     bool AppliesTo(const std::string &path) const override;
     DiffusionImageNiftiMimeType* Clone() const override;
   };
 
   class  DiffusionImageFslMimeType : public CustomMimeType
   {
   public:
     DiffusionImageFslMimeType();
     bool AppliesTo(const std::string &path) const override;
     DiffusionImageFslMimeType* Clone() const override;
   };
 
   class  DiffusionImageDicomMimeType : public CustomMimeType
   {
   public:
     DiffusionImageDicomMimeType();
     bool AppliesTo(const std::string &path) const override;
     DiffusionImageDicomMimeType* Clone() const override;
   };
 
   class  PeakImageMimeType : public CustomMimeType
   {
   public:
     PeakImageMimeType();
     bool AppliesTo(const std::string &path) const override;
     PeakImageMimeType* Clone() const override;
   };
 
   class  SHImageMimeType : public CustomMimeType
   {
   public:
     SHImageMimeType();
     bool AppliesTo(const std::string &path) const override;
     SHImageMimeType* Clone() const override;
   };
 
   // Get all Diffusion Mime Types
   static std::vector<CustomMimeType*> Get();
 
   // ------------------------- Image formats (ITK based) --------------------------
 
   static DiffusionImageNrrdMimeType DWI_NRRD_MIMETYPE();
   static DiffusionImageNiftiMimeType DWI_NIFTI_MIMETYPE();
   static DiffusionImageFslMimeType DWI_FSL_MIMETYPE();
   static DiffusionImageDicomMimeType DWI_DICOM_MIMETYPE();
   static PeakImageMimeType PEAK_MIMETYPE();
   static CustomMimeType DTI_MIMETYPE(); // dti
   static CustomMimeType ODF_MIMETYPE(); // odf, qbi
   static SHImageMimeType SH_MIMETYPE(); // spherical harmonics coefficients
 
   static std::string PEAK_MIMETYPE_NAME();
   static std::string DWI_NRRD_MIMETYPE_NAME();
   static std::string DWI_NIFTI_MIMETYPE_NAME();
   static std::string DWI_FSL_MIMETYPE_NAME();
   static std::string DWI_DICOM_MIMETYPE_NAME();
   static std::string DTI_MIMETYPE_NAME();
   static std::string ODF_MIMETYPE_NAME();
   static std::string SH_MIMETYPE_NAME();
 
   static std::string PEAK_MIMETYPE_DESCRIPTION();
   static std::string DWI_NRRD_MIMETYPE_DESCRIPTION();
   static std::string DWI_NIFTI_MIMETYPE_DESCRIPTION();
   static std::string DWI_FSL_MIMETYPE_DESCRIPTION();
   static std::string DWI_DICOM_MIMETYPE_DESCRIPTION();
   static std::string DTI_MIMETYPE_DESCRIPTION();
   static std::string ODF_MIMETYPE_DESCRIPTION();
   static std::string SH_MIMETYPE_DESCRIPTION();
 
 private:
 
   // purposely not implemented
   DiffusionCoreIOMimeTypes();
   DiffusionCoreIOMimeTypes(const DiffusionCoreIOMimeTypes&);
 };
 
 }
 
 #endif // MITKDiffusionCoreIOMimeTypes_H