diff --git a/CMake/BuildConfigurations/DiffusionRelease.cmake b/CMake/BuildConfigurations/DiffusionRelease.cmake
index 7de513dd9a..c98f87ba1f 100644
--- a/CMake/BuildConfigurations/DiffusionRelease.cmake
+++ b/CMake/BuildConfigurations/DiffusionRelease.cmake
@@ -1,46 +1,48 @@
 message(STATUS "Configuring MITK Diffusion Release Build")
 
 # Enable non-optional external dependencies
 set(MITK_USE_Vigra ON CACHE BOOL "MITK Use Vigra Library" FORCE)
 set(MITK_USE_HDF5 ON CACHE BOOL "MITK Use HDF5 Library" FORCE)
 set(MITK_USE_MatchPoint ON CACHE BOOL "" FORCE)
 set(MITK_USE_DCMTK ON CACHE BOOL "" FORCE)
 set(MITK_USE_DCMQI ON CACHE BOOL "" FORCE)
 set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
 if(UNIX AND NOT APPLE)
   set(MITK_USE_Python ON CACHE BOOL "" FORCE)
+  set(MITK_USE_BetData ON CACHE BOOL "" FORCE)
+  set(BUILD_DiffusionPythonCmdApps ON CACHE BOOL "Build commandline tools for diffusion with python" FORCE)
 else()
   set(MITK_USE_Python OFF CACHE BOOL "" FORCE)
+  set(MITK_USE_BetData OFF CACHE BOOL "" FORCE)
+  set(BUILD_DiffusionPythonCmdApps OFF CACHE BOOL "Build commandline tools for diffusion with python" FORCE)
 endif()
-set(MITK_USE_BetData ON CACHE BOOL "" FORCE)
 
 # Disable all apps but MITK Diffusion
 set(MITK_BUILD_ALL_APPS OFF CACHE BOOL "Build all MITK applications" FORCE)
 set(MITK_BUILD_APP_CoreApp OFF CACHE BOOL "Build the MITK CoreApp" FORCE)
 set(MITK_BUILD_APP_Workbench OFF CACHE BOOL "Build the MITK Workbench" FORCE)
 set(MITK_BUILD_APP_Diffusion ON CACHE BOOL "Build MITK Diffusion" FORCE)
 
 # Activate Diffusion Mini Apps
 set(BUILD_DiffusionFiberProcessingCmdApps ON CACHE BOOL "Build commandline tools for diffusion fiber processing" FORCE)
 set(BUILD_DiffusionFiberfoxCmdApps ON CACHE BOOL "Build commandline tools for diffusion data simulation (Fiberfox)" FORCE)
 set(BUILD_DiffusionMiscCmdApps ON CACHE BOOL "Build miscellaneous commandline tools for diffusion" FORCE)
 set(BUILD_DiffusionQuantificationCmdApps ON CACHE BOOL "Build commandline tools for diffusion quantification (IVIM, ADC, ...)" FORCE)
 set(BUILD_DiffusionTractographyCmdApps ON CACHE BOOL "Build commandline tools for diffusion fiber tractography" FORCE)
 set(BUILD_DiffusionTractographyEvaluationCmdApps ON CACHE BOOL "Build commandline tools for diffusion fiber tractography evaluation" FORCE)
 set(BUILD_DiffusionConnectomicsCmdApps OFF CACHE BOOL "Build commandline tools for diffusion connectomics" FORCE)
-set(BUILD_DiffusionPythonCmdApps ON CACHE BOOL "Build commandline tools for diffusion with python" FORCE)
 
 # Build neither all plugins nor examples
 set(MITK_BUILD_ALL_PLUGINS OFF CACHE BOOL "Build all MITK plugins" FORCE)
 set(MITK_BUILD_EXAMPLES OFF CACHE BOOL "Build the MITK examples" FORCE)
 set(BUILD_TESTING OFF CACHE BOOL "Build the MITK tests" FORCE)
 
 # Activate in-application help generation
 set(MITK_DOXYGEN_GENERATE_QCH_FILES ON CACHE BOOL "Use doxygen to generate Qt compressed help files for MITK docs" FORCE)
 set(BLUEBERRY_USE_QT_HELP ON CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
 
 # Enable console window
 set(MITK_SHOW_CONSOLE_WINDOW ON CACHE BOOL "Use this to enable or disable the console window when starting MITK GUI Applications" FORCE)
 
 set(MITK_VTK_DEBUG_LEAKS OFF CACHE BOOL "" FORCE)
 set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE)
diff --git a/CMake/BuildConfigurations/DiffusionRelease.cmake b/CMake/BuildConfigurations/DiffusionRelease_NoPython.cmake
similarity index 89%
copy from CMake/BuildConfigurations/DiffusionRelease.cmake
copy to CMake/BuildConfigurations/DiffusionRelease_NoPython.cmake
index 7de513dd9a..0fb51dbc67 100644
--- a/CMake/BuildConfigurations/DiffusionRelease.cmake
+++ b/CMake/BuildConfigurations/DiffusionRelease_NoPython.cmake
@@ -1,46 +1,41 @@
 message(STATUS "Configuring MITK Diffusion Release Build")
 
 # Enable non-optional external dependencies
 set(MITK_USE_Vigra ON CACHE BOOL "MITK Use Vigra Library" FORCE)
 set(MITK_USE_HDF5 ON CACHE BOOL "MITK Use HDF5 Library" FORCE)
 set(MITK_USE_MatchPoint ON CACHE BOOL "" FORCE)
 set(MITK_USE_DCMTK ON CACHE BOOL "" FORCE)
 set(MITK_USE_DCMQI ON CACHE BOOL "" FORCE)
 set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
-if(UNIX AND NOT APPLE)
-  set(MITK_USE_Python ON CACHE BOOL "" FORCE)
-else()
-  set(MITK_USE_Python OFF CACHE BOOL "" FORCE)
-endif()
-set(MITK_USE_BetData ON CACHE BOOL "" FORCE)
+set(MITK_USE_Python OFF CACHE BOOL "" FORCE)
 
 # Disable all apps but MITK Diffusion
 set(MITK_BUILD_ALL_APPS OFF CACHE BOOL "Build all MITK applications" FORCE)
 set(MITK_BUILD_APP_CoreApp OFF CACHE BOOL "Build the MITK CoreApp" FORCE)
 set(MITK_BUILD_APP_Workbench OFF CACHE BOOL "Build the MITK Workbench" FORCE)
 set(MITK_BUILD_APP_Diffusion ON CACHE BOOL "Build MITK Diffusion" FORCE)
 
 # Activate Diffusion Mini Apps
 set(BUILD_DiffusionFiberProcessingCmdApps ON CACHE BOOL "Build commandline tools for diffusion fiber processing" FORCE)
 set(BUILD_DiffusionFiberfoxCmdApps ON CACHE BOOL "Build commandline tools for diffusion data simulation (Fiberfox)" FORCE)
 set(BUILD_DiffusionMiscCmdApps ON CACHE BOOL "Build miscellaneous commandline tools for diffusion" FORCE)
 set(BUILD_DiffusionQuantificationCmdApps ON CACHE BOOL "Build commandline tools for diffusion quantification (IVIM, ADC, ...)" FORCE)
 set(BUILD_DiffusionTractographyCmdApps ON CACHE BOOL "Build commandline tools for diffusion fiber tractography" FORCE)
 set(BUILD_DiffusionTractographyEvaluationCmdApps ON CACHE BOOL "Build commandline tools for diffusion fiber tractography evaluation" FORCE)
 set(BUILD_DiffusionConnectomicsCmdApps OFF CACHE BOOL "Build commandline tools for diffusion connectomics" FORCE)
-set(BUILD_DiffusionPythonCmdApps ON CACHE BOOL "Build commandline tools for diffusion with python" FORCE)
+set(BUILD_DiffusionPythonCmdApps OFF CACHE BOOL "Build commandline tools for diffusion with python" FORCE)
 
 # Build neither all plugins nor examples
 set(MITK_BUILD_ALL_PLUGINS OFF CACHE BOOL "Build all MITK plugins" FORCE)
 set(MITK_BUILD_EXAMPLES OFF CACHE BOOL "Build the MITK examples" FORCE)
 set(BUILD_TESTING OFF CACHE BOOL "Build the MITK tests" FORCE)
 
 # Activate in-application help generation
 set(MITK_DOXYGEN_GENERATE_QCH_FILES ON CACHE BOOL "Use doxygen to generate Qt compressed help files for MITK docs" FORCE)
 set(BLUEBERRY_USE_QT_HELP ON CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
 
 # Enable console window
 set(MITK_SHOW_CONSOLE_WINDOW ON CACHE BOOL "Use this to enable or disable the console window when starting MITK GUI Applications" FORCE)
 
 set(MITK_VTK_DEBUG_LEAKS OFF CACHE BOOL "" FORCE)
 set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE)
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp
index bded47d0da..7445144f1e 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Fiberfox/Fiberfox.cpp
@@ -1,282 +1,282 @@
 /*===================================================================
 
 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>
 
 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::String, "Output root:", "output folder and file prefix", us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.addArgument("", "i", mitkCommandLineParser::String, "Input:", "input tractogram or diffusion-weighted image", us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument("parameters", "p", mitkCommandLineParser::String, "Parameter file:", "fiberfox parameter file (.ffp)", us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument("template", "t", mitkCommandLineParser::String, "Template image:", "use parameters of the template image", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Output additional images:", "output volume fraction images etc.", us::Any());
   parser.addArgument("dont_apply_direction_matrix", "", mitkCommandLineParser::Bool, "Don't apply direction matrix:", "don't rotate gradients by image direction matrix", us::Any());
   parser.addArgument("fix_seed", "", mitkCommandLineParser::Bool, "Use fix random seed:", "always use same sequence of random numbers", 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 fix_seed = false;
   if (parsedArgs.count("fix_seed"))
     fix_seed = us::any_cast<bool>(parsedArgs["fix_seed"]);
 
   bool verbose = false;
   if (parsedArgs.count("verbose"))
     verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
   bool apply_direction_matrix = true;
   if (parsedArgs.count("dont_apply_direction_matrix"))
     apply_direction_matrix = false;
 
   FiberfoxParameters parameters;
   parameters.LoadParameters(paramName, fix_seed);
 
   // 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;
   }
 
   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::GetOriginalGradientContainer(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::GetOriginalGradientContainer(diffImg));
 
     tractsToDwiFilter->SetInputImage(itkVectorImagePointer);
   }
 
   if (verbose)
   {
     MITK_DEBUG << outName << ".ffp";
     parameters.m_Misc.m_OutputAdditionalImages = true;
     parameters.SaveParameters(outName+".ffp");
   }
   else
     parameters.m_Misc.m_OutputAdditionalImages = false;
   
   if (apply_direction_matrix)
   {
     MITK_INFO << "Applying direction matrix to gradient directions.";
     parameters.ApplyDirectionMatrix();
   }
   tractsToDwiFilter->SetParameters(parameters);
   tractsToDwiFilter->SetUseConstantRandSeed(fix_seed);
   tractsToDwiFilter->Update();
 
   mitk::Image::Pointer image = mitk::GrabItkImageMemory(tractsToDwiFilter->GetOutput());
   if (apply_direction_matrix)
     mitk::DiffusionPropertyHelper::SetGradientContainer(image, parameters.m_SignalGen.GetItkGradientContainer());
   else
     mitk::DiffusionPropertyHelper::SetOriginalGradientContainer(image, parameters.m_SignalGen.GetItkGradientContainer());
   mitk::DiffusionPropertyHelper::SetReferenceBValue(image, parameters.m_SignalGen.GetBvalue());
   mitk::DiffusionPropertyHelper::InitializeImage(image);
 
   if (file_extension=="")
     mitk::IOUtil::Save(image, "DWI_NIFTI", outName+".nii.gz");
   else if (file_extension==".nii" || file_extension==".nii.gz")
     mitk::IOUtil::Save(image, "DWI_NIFTI", outName+file_extension);
   else
     mitk::IOUtil::Save(image, outName+file_extension);
 
   if (verbose)
   {
     if (tractsToDwiFilter->GetTickImage().IsNotNull())
     {
       mitk::Image::Pointer mitkImage = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::Float2DImageType::Pointer itkImage = tractsToDwiFilter->GetTickImage();
       mitkImage = mitk::GrabItkImageMemory( itkImage.GetPointer() );
       mitk::IOUtil::Save(mitkImage, outName+"_Ticks.nii.gz");
     }
 
     if (tractsToDwiFilter->GetRfImage().IsNotNull())
     {
       mitk::Image::Pointer mitkImage = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::Float2DImageType::Pointer itkImage = tractsToDwiFilter->GetRfImage();
       mitkImage = mitk::GrabItkImageMemory( itkImage.GetPointer() );
-      mitk::IOUtil::Save(mitkImage, outName+"_TimrFromRf.nii.gz");
+      mitk::IOUtil::Save(mitkImage, outName+"_TimeFromRf.nii.gz");
     }
 
     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/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp
index 9a9d5c11b1..a4e9350324 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageDicomReaderService.cpp
@@ -1,327 +1,327 @@
 /*===================================================================
 
 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 __mitkDiffusionImageDicomReaderService_cpp
 #define __mitkDiffusionImageDicomReaderService_cpp
 
 #include "mitkDiffusionImageDicomReaderService.h"
 
 #include <iostream>
 #include <fstream>
 
 
 // Diffusion properties
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <mitkProperties.h>
 
 #include <itkImageRegionIterator.h>
 #include <itkMetaDataObject.h>
 #include "itksys/SystemTools.hxx"
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 #include <mitkDiffusionDICOMFileReader.h>
 #include <mitkDICOMTagBasedSorter.h>
 #include <mitkSortByImagePositionPatient.h>
 #include <mitkDICOMSortByTag.h>
 
 #include <mitkITKImageImport.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include <mitkIOUtil.h>
 #include <mitkLocaleSwitch.h>
 #include <itksys/Directory.hxx>
 #include <gdcmDirectory.h>
 #include <mitkStringProperty.h>
 
 namespace mitk
 {
 
 DiffusionImageDicomReaderService::
 DiffusionImageDicomReaderService(const DiffusionImageDicomReaderService & other)
   : AbstractFileReader(other)
 {
 }
 
 
 DiffusionImageDicomReaderService* DiffusionImageDicomReaderService::Clone() const
 {
   return new DiffusionImageDicomReaderService(*this);
 }
 
 
 DiffusionImageDicomReaderService::
 ~DiffusionImageDicomReaderService()
 {}
 
 DiffusionImageDicomReaderService::
 DiffusionImageDicomReaderService()
   : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE_DESCRIPTION() )
 {
   Options defaultOptions;
-  defaultOptions["Apply rotation to gradients"] = true;
+  defaultOptions["Apply image rotation to gradients"] = true;
   defaultOptions["Load recursive"] = false;
   defaultOptions["Split mosaic"] = true;
   this->SetDefaultOptions(defaultOptions);
 
   m_ServiceReg = this->RegisterService();
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> >
 DiffusionImageDicomReaderService::Read()
 {
   return InternalRead();
 }
 
 
 std::vector<itk::SmartPointer<mitk::BaseData> > DiffusionImageDicomReaderService::InternalRead()
 {
   std::vector<itk::SmartPointer<mitk::BaseData> > result_images;
   OutputType::Pointer outputForCache = OutputType::New();
   if ( this->GetInputLocation() == "")
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
   }
   else
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, nullptr );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     try
     {
       Options options = this->GetOptions();
       bool load_recursive = us::any_cast<bool>(options["Load recursive"]);
       bool split_mosaic = us::any_cast<bool>(options["Split mosaic"]);
 
       gdcm::Directory::FilenamesType complete_list;
       std::string folderName = itksys::SystemTools::GetFilenamePath( this->GetInputLocation() );
 
       if( load_recursive )
       {
         std::string subdir_prefix = "";
 
         itksys::Directory rootdir;
         rootdir.Load( folderName.c_str() );
 
         for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
         {
           std::string current_path = rootdir.GetFile(idx);
           std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
 
           MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath:   " << current_path;
           MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                                                       << " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
 
           // test for prefix
           if( itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
               && itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() ) )
           {
             gdcm::Directory d;
             d.Load( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) , false);
 
             MITK_INFO("dicom.load.subdir.attempt") << "In directory " << itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() );
 
             const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
             const unsigned int ntotalfiles = l1.size();
 
             for( unsigned int i=0; i< ntotalfiles; i++)
             {
               complete_list.push_back( l1.at(i) );
               m_ReadFiles.push_back( l1.at(i) );
             }
           }
         }
       }
       else
       {
         gdcm::Directory d;
         d.Load( folderName.c_str(), load_recursive ); // recursive !
         const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
         const unsigned int ntotalfiles = l1.size();
 
         for( unsigned int i=0; i< ntotalfiles; i++)
         {
           complete_list.push_back( l1.at(i) );
           m_ReadFiles.push_back( l1.at(i) );
         }
       }
 
       mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
       mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
       // Use tags as in Qmitk
       // all the things that split by tag in ClassicDicomSeriesReader
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
       // TODO handle as real vectors! cluster with configurable errors!
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x000e) ); // Series Instance UID
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
       //tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
       auto tag_sop_instance_uid = mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0018), nullptr ); // SOP instance UID (last resort, not really meaningful but decides clearly)
       auto tag_trigger_time = mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0018, 0x1060), tag_sop_instance_uid.GetPointer() ); // trigger time
       auto tag_aqcuisition_time = mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0032), tag_trigger_time.GetPointer()); // aqcuisition time
       auto tag_aqcuisition_number = mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012), tag_aqcuisition_time.GetPointer()); // aqcuisition number
       mitk::DICOMSortCriterion::ConstPointer sorting = mitk::SortByImagePositionPatient::New(tag_aqcuisition_number.GetPointer()).GetPointer();
       tagSorter->SetSortCriterion( sorting );
 
       // mosaic
       gdcmReader->SetResolveMosaic( split_mosaic );
       gdcmReader->AddSortingElement( tagSorter );
       gdcmReader->SetInputFiles( complete_list );
-      gdcmReader->SetApplyRotationToGradients(us::any_cast<bool>(options["Apply rotation to gradients"]));
+      gdcmReader->SetApplyRotationToGradients(us::any_cast<bool>(options["Apply image rotation to gradients"]));
       try
       {
         gdcmReader->AnalyzeInputFiles();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_ERROR << "Failed to analyze data. " << e.what();
       }
       catch( const std::exception &se)
       {
         MITK_ERROR << "Std Exception " << se.what();
       }
 
       gdcmReader->LoadImages();
 
       for( unsigned int o = 0; o < gdcmReader->GetNumberOfOutputs(); o++ )
       {
         mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(o).GetMitkImage();
 
         StringProperty::Pointer nameProp;
         if (gdcmReader->GetSeriesName(o)!="-")
           nameProp = StringProperty::New(gdcmReader->GetSeriesName(o));
         else if (gdcmReader->GetStudyName(o)!="-")
           nameProp = StringProperty::New(gdcmReader->GetStudyName(o));
         else
           nameProp = StringProperty::New(folderName);
 
         loaded_image->SetProperty("name", nameProp);
 
         std::string val = "-";
 
         if (gdcmReader->patient_ids().size()>o)
         {
           val = gdcmReader->patient_ids().at(o);
           loaded_image->GetPropertyList()->SetStringProperty("DICOM.patient_id",val.c_str());
         }
 
         if (gdcmReader->patient_names().size()>o)
         {
           val = gdcmReader->patient_names().at(o);
           loaded_image->GetPropertyList()->SetStringProperty("DICOM.patient_name",val.c_str());
         }
 
         if (gdcmReader->study_instance_uids().size()>o)
         {
           val = gdcmReader->study_instance_uids().at(o);
           loaded_image->GetPropertyList()->SetStringProperty("DICOM.study_instance_uid",val.c_str());
         }
 
         if (gdcmReader->series_instance_uids().size()>o)
         {
           val = gdcmReader->series_instance_uids().at(o);
           loaded_image->GetPropertyList()->SetStringProperty("DICOM.series_instance_uid",val.c_str());
         }
 
         if (gdcmReader->sop_instance_uids().size()>o)
         {
           val = gdcmReader->sop_instance_uids().at(o);
           loaded_image->GetPropertyList()->SetStringProperty("DICOM.sop_instance_uid",val.c_str());
         }
 
         if (gdcmReader->frame_of_reference_uids().size()>o)
         {
           val = gdcmReader->frame_of_reference_uids().at(o);
           loaded_image->GetPropertyList()->SetStringProperty("DICOM.frame_of_reference_uid",val.c_str());
         }
         result_images.push_back(loaded_image.GetPointer());
       }
 
 
       // Since we have already read the tree, we can store it in a cache variable
       // so that it can be assigned to the DataObject in GenerateData();
       m_OutputCache = outputForCache;
       m_CacheTime.Modified();
 
       try
       {
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
     }
     catch(std::exception& e)
     {
       try
       {
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
 
       MITK_INFO << "Std::Exception while reading file!!";
       MITK_INFO << e.what();
       throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
     }
     catch(...)
     {
       try
       {
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
 
       MITK_INFO << "Exception while reading file!!";
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
     }
   }
 
   return result_images;
 }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiReaderService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiReaderService.cpp
index 574a367854..5f3a38ac34 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiReaderService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNiftiReaderService.cpp
@@ -1,349 +1,349 @@
 /*===================================================================
 
 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 __mitkDiffusionImageNiftiReaderService_cpp
 #define __mitkDiffusionImageNiftiReaderService_cpp
 
 #include "mitkDiffusionImageNiftiReaderService.h"
 
 #include <iostream>
 #include <fstream>
 
 
 // Diffusion properties
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <mitkProperties.h>
 
 // ITK includes
 #include <itkImageRegionIterator.h>
 #include <itkMetaDataObject.h>
 #include "itksys/SystemTools.hxx"
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNiftiImageIO.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 
 #include <mitkITKImageImport.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include <mitkLocaleSwitch.h>
 #include "mitkIOUtil.h"
 #include <mitkDiffusionFunctionCollection.h>
 
 namespace mitk
 {
 
 DiffusionImageNiftiReaderService::
 DiffusionImageNiftiReaderService(const DiffusionImageNiftiReaderService & other)
   : AbstractFileReader(other)
 {
 }
 
 
 DiffusionImageNiftiReaderService* DiffusionImageNiftiReaderService::Clone() const
 {
   return new DiffusionImageNiftiReaderService(*this);
 }
 
 
 DiffusionImageNiftiReaderService::
 ~DiffusionImageNiftiReaderService()
 {}
 
 DiffusionImageNiftiReaderService::
 DiffusionImageNiftiReaderService(CustomMimeType mime_type, std::string mime_type_description ) : mitk::AbstractFileReader( mime_type, mime_type_description )
 {
   Options defaultOptions;
-  defaultOptions["Apply rotation to gradients"] = true;
+  defaultOptions["Apply image rotation to gradients"] = true;
   this->SetDefaultOptions(defaultOptions);
 
   m_ServiceReg = this->RegisterService();
 }
 
 //DiffusionImageNiftiReaderService::
 //DiffusionImageNiftiReaderService() : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION() )
 //{
 //  m_ServiceReg = this->RegisterService();
 //}
 
 std::vector<itk::SmartPointer<mitk::BaseData> >
 DiffusionImageNiftiReaderService::
 Read()
 {
   std::vector<itk::SmartPointer<mitk::BaseData> > result;
 
   // Since everything is completely read in GenerateOutputInformation() it is stored
   // in a cache variable. A timestamp is associated.
   // If the timestamp of the cache variable is newer than the MTime, we only need to
   // assign the cache variable to the DataObject.
   // Otherwise, the tree must be read again from the file and OuputInformation must
   // be updated!
 
   if(m_OutputCache.IsNull()) InternalRead();
 
   result.push_back(m_OutputCache.GetPointer());
   return result;
 }
 
 
 void DiffusionImageNiftiReaderService::InternalRead()
 {
   OutputType::Pointer outputForCache = OutputType::New();
   if ( this->GetInputLocation() == "")
   {
     throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
   }
   else
   {
     try
     {
       mitk::LocaleSwitch localeSwitch("C");
 
       MITK_INFO << "DiffusionImageNiftiReaderService: reading image information";
       VectorImageType::Pointer itkVectorImage;
 
       std::string ext = this->GetMimeType()->GetExtension( this->GetInputLocation() );
       ext = itksys::SystemTools::LowerCase( ext );
 
       if(ext == ".fsl" || ext == ".fslgz")
       {
         // create temporary file with correct ending for nifti-io
         std::string fname3 = "temp_dwi";
         fname3 += ext == ".fsl" ? ".nii" : ".nii.gz";
         itksys::SystemTools::CopyAFile(this->GetInputLocation().c_str(), fname3.c_str());
 
         // create reader and read file
         typedef itk::Image<DiffusionPixelType,4> ImageType4D;
         itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
         typedef itk::ImageFileReader<ImageType4D> FileReaderType;
         FileReaderType::Pointer reader = FileReaderType::New();
         reader->SetFileName(fname3);
         reader->SetImageIO(io2);
         reader->Update();
         ImageType4D::Pointer img4 = reader->GetOutput();
 
         // delete temporary file
         itksys::SystemTools::RemoveFile(fname3.c_str());
 
         // convert 4D file to vector image
         itkVectorImage = VectorImageType::New();
 
         VectorImageType::SpacingType spacing;
         ImageType4D::SpacingType spacing4 = img4->GetSpacing();
         for(int i=0; i<3; i++)
           spacing[i] = spacing4[i];
         itkVectorImage->SetSpacing( spacing );   // Set the image spacing
 
         VectorImageType::PointType origin;
         ImageType4D::PointType origin4 = img4->GetOrigin();
         for(int i=0; i<3; i++)
           origin[i] = origin4[i];
         itkVectorImage->SetOrigin( origin );     // Set the image origin
 
         VectorImageType::DirectionType direction;
         ImageType4D::DirectionType direction4 = img4->GetDirection();
         for(int i=0; i<3; i++)
           for(int j=0; j<3; j++)
             direction[i][j] = direction4[i][j];
         itkVectorImage->SetDirection( direction );  // Set the image direction
 
         VectorImageType::RegionType region;
         ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
 
         VectorImageType::RegionType::SizeType size;
         ImageType4D::RegionType::SizeType size4 = region4.GetSize();
 
         for(int i=0; i<3; i++)
           size[i] = size4[i];
 
         VectorImageType::RegionType::IndexType index;
         ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
         for(int i=0; i<3; i++)
           index[i] = index4[i];
 
         region.SetSize(size);
         region.SetIndex(index);
         itkVectorImage->SetRegions( region );
 
         itkVectorImage->SetVectorLength(size4[3]);
         itkVectorImage->Allocate();
 
         itk::ImageRegionIterator<VectorImageType>   it ( itkVectorImage,  itkVectorImage->GetLargestPossibleRegion() );
         typedef VectorImageType::PixelType VecPixType;
         for (it.GoToBegin(); !it.IsAtEnd(); ++it)
         {
           VecPixType vec = it.Get();
           VectorImageType::IndexType currentIndex = it.GetIndex();
           for(int i=0; i<3; i++)
             index4[i] = currentIndex[i];
           for(unsigned int ind=0; ind<vec.Size(); ind++)
           {
             index4[3] = ind;
             vec[ind] = img4->GetPixel(index4);
           }
           it.Set(vec);
         }
       }
       else if(ext == ".nii" || ext == ".nii.gz")
       {
         // create reader and read file
         typedef itk::Image<DiffusionPixelType,4> ImageType4D;
         itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
         typedef itk::ImageFileReader<ImageType4D> FileReaderType;
         FileReaderType::Pointer reader = FileReaderType::New();
         reader->SetFileName( this->GetInputLocation() );
         reader->SetImageIO(io2);
         reader->Update();
         ImageType4D::Pointer img4 = reader->GetOutput();
 
 
         // convert 4D file to vector image
         itkVectorImage = VectorImageType::New();
 
         VectorImageType::SpacingType spacing;
         ImageType4D::SpacingType spacing4 = img4->GetSpacing();
         for(int i=0; i<3; i++)
           spacing[i] = spacing4[i];
         itkVectorImage->SetSpacing( spacing );   // Set the image spacing
 
         VectorImageType::PointType origin;
         ImageType4D::PointType origin4 = img4->GetOrigin();
         for(int i=0; i<3; i++)
           origin[i] = origin4[i];
         itkVectorImage->SetOrigin( origin );     // Set the image origin
 
         VectorImageType::DirectionType direction;
         ImageType4D::DirectionType direction4 = img4->GetDirection();
         for(int i=0; i<3; i++)
           for(int j=0; j<3; j++)
             direction[i][j] = direction4[i][j];
         itkVectorImage->SetDirection( direction );  // Set the image direction
 
         VectorImageType::RegionType region;
         ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
 
         VectorImageType::RegionType::SizeType size;
         ImageType4D::RegionType::SizeType size4 = region4.GetSize();
 
         for(int i=0; i<3; i++)
           size[i] = size4[i];
 
         VectorImageType::RegionType::IndexType index;
         ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
         for(int i=0; i<3; i++)
           index[i] = index4[i];
 
         region.SetSize(size);
         region.SetIndex(index);
         itkVectorImage->SetRegions( region );
 
         itkVectorImage->SetVectorLength(size4[3]);
         itkVectorImage->Allocate();
 
         itk::ImageRegionIterator<VectorImageType>   it ( itkVectorImage,  itkVectorImage->GetLargestPossibleRegion() );
         typedef VectorImageType::PixelType VecPixType;
         for (it.GoToBegin(); !it.IsAtEnd(); ++it)
         {
           VecPixType vec = it.Get();
           VectorImageType::IndexType currentIndex = it.GetIndex();
           for(int i=0; i<3; i++)
             index4[i] = currentIndex[i];
           for(unsigned int ind=0; ind<vec.Size(); ind++)
           {
             index4[3] = ind;
             vec[ind] = img4->GetPixel(index4);
           }
           it.Set(vec);
         }
       }
 
       // Diffusion Image information START
       GradientDirectionContainerType::Pointer DiffusionVectors = GradientDirectionContainerType::New();
       MeasurementFrameType MeasurementFrame;
       double BValue = -1;
       // Diffusion Image information END
 
       if(ext == ".fsl" || ext == ".fslgz" || ext == ".nii" || ext == ".nii.gz")
       {
         std::string base_path = itksys::SystemTools::GetFilenamePath(this->GetInputLocation());
         std::string base = this->GetMimeType()->GetFilenameWithoutExtension(this->GetInputLocation());
         if (!base_path.empty())
         {
           base = base_path + "/" + base;
           base_path += "/";
         }
 
         // check for possible file names
         std::string bvals_file, bvecs_file;
         if (itksys::SystemTools::FileExists(base+".bvals"))
           bvals_file = base+".bvals";
         else if (itksys::SystemTools::FileExists(base+".bval"))
           bvals_file = base+".bval";
         else if (itksys::SystemTools::FileExists(base_path+"bvals"))
           bvals_file = base_path + "bvals";
         else if (itksys::SystemTools::FileExists(base_path+"bval"))
           bvals_file = base_path + "bval";
 
         if (itksys::SystemTools::FileExists(std::string(base+".bvecs").c_str()))
           bvecs_file = base+".bvecs";
         else if (itksys::SystemTools::FileExists(base+".bvec"))
           bvals_file = base+".bvec";
         else if (itksys::SystemTools::FileExists(base_path+"bvecs"))
           bvecs_file = base_path + "bvecs";
         else if (itksys::SystemTools::FileExists(base_path+"bvec"))
           bvecs_file = base_path + "bvec";
 
         DiffusionVectors = mitk::gradients::ReadBvalsBvecs(bvals_file, bvecs_file, BValue);
         MeasurementFrame.set_identity();
       }
 
       outputForCache = mitk::GrabItkImageMemory( itkVectorImage);
 
       // create BValueMap
       mitk::BValueMapProperty::BValueMap BValueMap = mitk::BValueMapProperty::CreateBValueMap(DiffusionVectors,BValue);
       mitk::DiffusionPropertyHelper::SetOriginalGradientContainer(outputForCache, DiffusionVectors);
       mitk::DiffusionPropertyHelper::SetMeasurementFrame(outputForCache, MeasurementFrame);
       mitk::DiffusionPropertyHelper::SetBValueMap(outputForCache, BValueMap);
       mitk::DiffusionPropertyHelper::SetReferenceBValue(outputForCache, BValue);
-      mitk::DiffusionPropertyHelper::SetApplyMatrixToGradients(outputForCache, us::any_cast<bool>(this->GetOptions()["Apply rotation to gradients"]));
+      mitk::DiffusionPropertyHelper::SetApplyMatrixToGradients(outputForCache, us::any_cast<bool>(this->GetOptions()["Apply image rotation to gradients"]));
       mitk::DiffusionPropertyHelper::InitializeImage(outputForCache);
 
       // Since we have already read the tree, we can store it in a cache variable
       // so that it can be assigned to the DataObject in GenerateData();
       m_OutputCache = outputForCache;
       m_CacheTime.Modified();
     }
     catch(std::exception& e)
     {
       MITK_INFO << "Std::Exception while reading file!!";
       MITK_INFO << e.what();
       throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
     }
     catch(...)
     {
       MITK_INFO << "Exception while reading file!!";
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
     }
   }
 }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdReaderService.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdReaderService.cpp
index 511d5b3760..455463e020 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdReaderService.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionImageNrrdReaderService.cpp
@@ -1,249 +1,249 @@
 /*===================================================================
 
 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 __mitkDiffusionImageNrrdReaderService_cpp
 #define __mitkDiffusionImageNrrdReaderService_cpp
 
 #include "mitkDiffusionImageNrrdReaderService.h"
 
 #include <iostream>
 #include <fstream>
 
 
 // Diffusion properties
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <mitkProperties.h>
 
 // ITK includes
 #include <itkImageRegionIterator.h>
 #include <itkMetaDataObject.h>
 #include "itksys/SystemTools.hxx"
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkDiffusionCoreIOMimeTypes.h"
 
 #include <mitkITKImageImport.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include "mitkIOUtil.h"
 #include <mitkLocaleSwitch.h>
 
 namespace mitk
 {
 
   DiffusionImageNrrdReaderService::
   DiffusionImageNrrdReaderService(const DiffusionImageNrrdReaderService & other)
     : AbstractFileReader(other)
   {
   }
 
 
   DiffusionImageNrrdReaderService* DiffusionImageNrrdReaderService::Clone() const
   {
     return new DiffusionImageNrrdReaderService(*this);
   }
 
 
   DiffusionImageNrrdReaderService::
   ~DiffusionImageNrrdReaderService()
   {}
 
   DiffusionImageNrrdReaderService::
   DiffusionImageNrrdReaderService()
     : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION() )
   {
     Options defaultOptions;
-    defaultOptions["Apply rotation to gradients"] = true;
+    defaultOptions["Apply image rotation to gradients"] = true;
     this->SetDefaultOptions(defaultOptions);
     m_ServiceReg = this->RegisterService();
   }
 
   std::vector<itk::SmartPointer<mitk::BaseData> >
   DiffusionImageNrrdReaderService::
   Read()
   {
     std::vector<itk::SmartPointer<mitk::BaseData> > result;
 
     // Since everything is completely read in GenerateOutputInformation() it is stored
     // in a cache variable. A timestamp is associated.
     // If the timestamp of the cache variable is newer than the MTime, we only need to
     // assign the cache variable to the DataObject.
     // Otherwise, the tree must be read again from the file and OuputInformation must
     // be updated!
 
     if(m_OutputCache.IsNull()) InternalRead();
 
     result.push_back(m_OutputCache.GetPointer());
     return result;
   }
 
 
   void DiffusionImageNrrdReaderService::InternalRead()
   {
     OutputType::Pointer outputForCache = OutputType::New();
     if ( this->GetInputLocation() == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
     }
     else
     {
       try
       {
         mitk::LocaleSwitch localeSwitch("C");
 
         MITK_INFO << "DiffusionImageNrrdReaderService: reading image information";
         VectorImageType::Pointer itkVectorImage;
 
         std::string ext = this->GetMimeType()->GetExtension( this->GetInputLocation() );
         ext = itksys::SystemTools::LowerCase( ext );
 
         if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
         {
           typedef itk::ImageFileReader<VectorImageType> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetFileName(this->GetInputLocation());
           itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
           reader->SetImageIO(io);
           reader->Update();
           itkVectorImage = reader->GetOutput();
         }
 
         // Diffusion Image information START
         GradientDirectionContainerType::Pointer DiffusionVectors = GradientDirectionContainerType::New();
         GradientDirectionContainerType::Pointer OriginalDiffusionVectors = GradientDirectionContainerType::New();
         MeasurementFrameType MeasurementFrame;
         float BValue = -1;
         // Diffusion Image information END
 
         if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
         {
 
           itk::MetaDataDictionary imgMetaDictionary =  itkVectorImage->GetMetaDataDictionary();
           std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
           std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
           std::string metaString;
 
           GradientDirectionType vect3d;
 
           int numberOfImages = 0;
           int numberOfGradientImages = 0;
           bool readb0 = false;
           double xx, xy, xz, yx, yy, yz, zx, zy, zz;
 
           for (; itKey != imgMetaKeys.end(); itKey ++)
           {
             double x,y,z;
 
             itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
             if (itKey->find("DWMRI_gradient") != std::string::npos)
             {
               sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
               vect3d[0] = x; vect3d[1] = y; vect3d[2] = z;
               DiffusionVectors->InsertElement( numberOfImages, vect3d );
               ++numberOfImages;
               // If the direction is 0.0, this is a reference image
               if (vect3d[0] == 0.0 &&
                   vect3d[1] == 0.0 &&
                   vect3d[2] == 0.0)
               {
                 continue;
               }
               ++numberOfGradientImages;;
             }
             else if (itKey->find("DWMRI_b-value") != std::string::npos)
             {
               readb0 = true;
               BValue = atof(metaString.c_str());
             }
             else if (itKey->find("measurement frame") != std::string::npos)
             {
               sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
 
               if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
                   yx>10e-10 || yy>10e-10 || yz>10e-10 ||
                   zx>10e-10 || zy>10e-10 || zz>10e-10 )
               {
                 MeasurementFrame(0,0) = xx;
                 MeasurementFrame(0,1) = xy;
                 MeasurementFrame(0,2) = xz;
                 MeasurementFrame(1,0) = yx;
                 MeasurementFrame(1,1) = yy;
                 MeasurementFrame(1,2) = yz;
                 MeasurementFrame(2,0) = zx;
                 MeasurementFrame(2,1) = zy;
                 MeasurementFrame(2,2) = zz;
               }
               else
               {
                 MeasurementFrame(0,0) = 1;
                 MeasurementFrame(0,1) = 0;
                 MeasurementFrame(0,2) = 0;
                 MeasurementFrame(1,0) = 0;
                 MeasurementFrame(1,1) = 1;
                 MeasurementFrame(1,2) = 0;
                 MeasurementFrame(2,0) = 0;
                 MeasurementFrame(2,1) = 0;
                 MeasurementFrame(2,2) = 1;
               }
             }
           }
 
           if(!readb0)
           {
             MITK_INFO << "BValue not specified in header file";
           }
 
         }
 
         outputForCache = mitk::GrabItkImageMemory( itkVectorImage);
 
         // create BValueMap
         mitk::BValueMapProperty::BValueMap BValueMap = mitk::BValueMapProperty::CreateBValueMap(DiffusionVectors,BValue);
         mitk::DiffusionPropertyHelper::SetOriginalGradientContainer(outputForCache, DiffusionVectors);
         mitk::DiffusionPropertyHelper::SetMeasurementFrame(outputForCache, MeasurementFrame);
         mitk::DiffusionPropertyHelper::SetBValueMap(outputForCache, BValueMap);
         mitk::DiffusionPropertyHelper::SetReferenceBValue(outputForCache, BValue);
-        mitk::DiffusionPropertyHelper::SetApplyMatrixToGradients(outputForCache, us::any_cast<bool>(this->GetOptions()["Apply rotation to gradients"]));
+        mitk::DiffusionPropertyHelper::SetApplyMatrixToGradients(outputForCache, us::any_cast<bool>(this->GetOptions()["Apply image rotation to gradients"]));
         mitk::DiffusionPropertyHelper::InitializeImage(outputForCache);
 
         // Since we have already read the tree, we can store it in a cache variable
         // so that it can be assigned to the DataObject in GenerateData();
         m_OutputCache = outputForCache;
         m_CacheTime.Modified();
 
       }
       catch(std::exception& e)
       {
         MITK_INFO << "Std::Exception while reading file!!";
         MITK_INFO << e.what();
         throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         MITK_INFO << "Exception while reading file!!";
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
       }
     }
   }
 
 } //namespace MITK
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/files.cmake b/Plugins/org.mitk.gui.qt.multilabelsegmentation/files.cmake
index 1272eb0b1a..d73169c874 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/files.cmake
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/files.cmake
@@ -1,102 +1,105 @@
 set(SRC_CPP_FILES
   QmitkMultiLabelSegmentationPreferencePage.cpp
 )
 
 set(INTERNAL_CPP_FILES
   mitkPluginActivator.cpp
   QmitkMultiLabelSegmentationView.cpp
   QmitkThresholdAction.cpp
   QmitkAutocropAction.cpp
   QmitkConvertSurfaceToLabelAction.cpp
   QmitkConvertMaskToLabelAction.cpp
   QmitkConvertToMultiLabelSegmentationAction.cpp
   QmitkCreateMultiLabelSegmentationAction.cpp
   QmitkLoadMultiLabelPresetAction.cpp
   QmitkCreateMultiLabelPresetAction.cpp
   Common/QmitkDataSelectionWidget.cpp
   SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.cpp
   SegmentationUtilities/QmitkSegmentationUtilityWidget.cpp
   SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
   SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.cpp
   SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
   SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
+  SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.cpp
 )
 
 set(UI_FILES
   src/internal/QmitkMultiLabelSegmentationControls.ui
   src/internal/Common/QmitkDataSelectionWidgetControls.ui
   src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesViewControls.ui
   src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidgetControls.ui
   src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidgetControls.ui
   src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidgetControls.ui
   src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidgetControls.ui
+  src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidgetControls.ui
 )
 
 set(MOC_H_FILES
   src/QmitkMultiLabelSegmentationPreferencePage.h
   src/internal/mitkPluginActivator.h
   src/internal/QmitkMultiLabelSegmentationView.h
   src/internal/QmitkThresholdAction.h
   src/internal/QmitkAutocropAction.h
   src/internal/QmitkConvertSurfaceToLabelAction.h
   src/internal/QmitkLoadMultiLabelPresetAction.h
   src/internal/QmitkCreateMultiLabelPresetAction.h
   src/internal/QmitkConvertMaskToLabelAction.h
   src/internal/QmitkConvertToMultiLabelSegmentationAction.h
   src/internal/QmitkCreateMultiLabelSegmentationAction.h
   src/internal/Common/QmitkDataSelectionWidget.h
   src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.h
   src/internal/SegmentationUtilities/QmitkSegmentationUtilityWidget.h
   src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.h
   src/internal/SegmentationUtilities/MorphologicalOperations/QmitkMorphologicalOperationsWidget.h
   src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.h
   src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.h
+  src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.h
 )
 
 set(CACHED_RESOURCE_FILES
   resources/BooleanDifference_48x48.png
   resources/BooleanIntersection_48x48.png
   resources/BooleanOperations_48x48.png
   resources/BooleanUnion_48x48.png
   resources/Closing_48x48.png
   resources/CTKWidgets_48x48.png
   resources/deformablePlane.png
   resources/Dilate_48x48.png
   resources/Erode_48x48.png
   resources/FillHoles_48x48.png
   resources/Icons.svg
   resources/ImageMasking_48x48.png
   resources/MorphologicalOperations_48x48.png
   resources/multilabelsegmentation.svg
   resources/multilabelsegmentation_utilities.svg
   resources/NewLabel_48x48.png
   resources/NewSegmentationSession_48x48.png
   resources/Opening_48x48.png
   resources/SurfaceToImage_48x48.png
   plugin.xml
 )
 
 set(QRC_FILES
   resources/multilabelsegmentation.qrc
   resources/MultiLabelSegmentationUtilities.qrc
   resources/MorphologicalOperationsWidget.qrc
   resources/BooleanOperationsWidget.qrc
 )
 
 set(CPP_FILES)
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 #usFunctionEmbedResources(
 #CPP_FILES
 # LIBRARY_NAME "liborg_mitk_gui_qt_multilabelsegmentation"
 #ROOT_DIR resources
 #FILES Interactions/SegmentationInteraction.xml
 #      Interactions/ConfigSegmentation.xml
 #)
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities.qrc b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities.qrc
index 4facd08489..44a56f1ae5 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities.qrc
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/resources/MultiLabelSegmentationUtilities.qrc
@@ -1,10 +1,11 @@
 <RCC>
-  <qresource prefix="/MultiLabelSegmentationUtilities">
-     <file>BooleanOperations_48x48.png</file>
-     <file>ImageMasking_48x48.png</file>
-     <file>MorphologicalOperations_48x48.png</file>
-     <file>SurfaceToImage_48x48.png</file>
-     <file>multilabelsegmentation_utilities.svg</file>
-     <file>CTKWidgets_48x48.png</file>
-  </qresource>
+    <qresource prefix="/MultiLabelSegmentationUtilities">
+        <file>BooleanOperations_48x48.png</file>
+        <file>ImageMasking_48x48.png</file>
+        <file>MorphologicalOperations_48x48.png</file>
+        <file>SurfaceToImage_48x48.png</file>
+        <file>multilabelsegmentation_utilities.svg</file>
+        <file>CTKWidgets_48x48.png</file>
+        <file>multilabelsegmentation.svg</file>
+    </qresource>
 </RCC>
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.cpp
new file mode 100644
index 0000000000..72bd4b6462
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.cpp
@@ -0,0 +1,69 @@
+/*===================================================================
+
+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 "QmitkConvertToMlWidget.h"
+#include "../../Common/QmitkDataSelectionWidget.h"
+#include <mitkException.h>
+#include <mitkSliceNavigationController.h>
+#include <cassert>
+#include <mitkImage.h>
+#include "src/internal/QmitkConvertToMultiLabelSegmentationAction.h"
+
+QmitkConvertToMlWidget::QmitkConvertToMlWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
+  : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
+{
+  m_Controls.setupUi(this);
+
+  m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::ImagePredicate);
+
+  connect(m_Controls.dataSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(SelectionChanged()));
+  connect(m_Controls.pushButton, SIGNAL(clicked()), this, SLOT(Convert()));
+}
+
+QmitkConvertToMlWidget::~QmitkConvertToMlWidget()
+{
+}
+
+void QmitkConvertToMlWidget::SelectionChanged()
+{
+  QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
+
+  mitk::DataNode::Pointer node0 = dataSelectionWidget->GetSelection(0);
+
+  if (node0.IsNotNull())
+  {
+    this->EnableButtons();
+  }
+  else
+  {
+    this->EnableButtons(false);
+  }
+}
+
+void QmitkConvertToMlWidget::EnableButtons(bool enable)
+{
+  m_Controls.pushButton->setEnabled(enable);
+}
+
+void QmitkConvertToMlWidget::Convert()
+{
+  auto node = m_Controls.dataSelectionWidget->GetSelection(0);
+
+  QmitkConvertToMultiLabelSegmentationAction converter;
+  QList<mitk::DataNode::Pointer> list; list.append(node);
+  converter.SetDataStorage(m_Controls.dataSelectionWidget->GetDataStorage());
+  converter.Run(list);
+}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.h b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.h
new file mode 100644
index 0000000000..a9e35e4243
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidget.h
@@ -0,0 +1,41 @@
+/*===================================================================
+
+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 QmitkConvertToMlWidget_h
+#define QmitkConvertToMlWidget_h
+
+#include "../QmitkSegmentationUtilityWidget.h"
+#include <ui_QmitkConvertToMlWidgetControls.h>
+
+class QmitkConvertToMlWidget : public QmitkSegmentationUtilityWidget
+{
+  Q_OBJECT
+
+public:
+  explicit QmitkConvertToMlWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent = nullptr);
+  ~QmitkConvertToMlWidget();
+
+private slots:
+  void SelectionChanged();
+  void Convert();
+
+private:
+  void EnableButtons(bool enable = true);
+
+  Ui::QmitkConvertToMlWidgetControls m_Controls;
+};
+
+#endif
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidgetControls.ui b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidgetControls.ui
new file mode 100644
index 0000000000..4fce705afb
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/ConvertToMl/QmitkConvertToMlWidgetControls.ui
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkConvertToMlWidgetControls</class>
+ <widget class="QWidget" name="QmitkConvertToMlWidgetControls">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>270</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QmitkDataSelectionWidget" name="dataSelectionWidget" native="true"/>
+   </item>
+   <item>
+    <widget class="QPushButton" name="pushButton">
+     <property name="text">
+      <string>Convert</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>273</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>QmitkDataSelectionWidget</class>
+   <extends>QWidget</extends>
+   <header>internal/Common/QmitkDataSelectionWidget.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources>
+  <include location="../../../../resources/BooleanOperationsWidget.qrc"/>
+ </resources>
+ <connections/>
+</ui>
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.cpp
index fa613d543d..11ad998f47 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.cpp
@@ -1,90 +1,98 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // #define ENABLE_CTK_WIDGETS_WIDGET
 
 #include "QmitkMultiLabelSegmentationUtilitiesView.h"
 #include "BooleanOperations/QmitkBooleanOperationsWidget.h"
 #include "MorphologicalOperations/QmitkMorphologicalOperationsWidget.h"
 #include "SurfaceToImage/QmitkSurfaceToImageWidget.h"
 #include "ImageMasking/QmitkImageMaskingWidget.h"
+#include "ConvertToMl/QmitkConvertToMlWidget.h"
 
 QmitkMultiLabelSegmentationUtilitiesView::QmitkMultiLabelSegmentationUtilitiesView() :
-m_BooleanOperationsWidget(nullptr),
-m_MorphologicalOperationsWidget(nullptr),
-m_SurfaceToImageWidget(nullptr),
-m_ImageMaskingWidget(nullptr)
+  m_BooleanOperationsWidget(nullptr),
+  m_MorphologicalOperationsWidget(nullptr),
+  m_SurfaceToImageWidget(nullptr),
+  m_ImageMaskingWidget(nullptr),
+  m_ConvertToMlWidget(nullptr)
 {
 }
 
 QmitkMultiLabelSegmentationUtilitiesView::~QmitkMultiLabelSegmentationUtilitiesView()
 {
 }
 
 void QmitkMultiLabelSegmentationUtilitiesView::CreateQtPartControl(QWidget* parent)
 {
   m_Controls.setupUi(parent);
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
 
   mitk::SliceNavigationController* timeNavigationController = renderWindowPart != nullptr
     ? renderWindowPart->GetTimeNavigationController()
     : nullptr;
 
   m_BooleanOperationsWidget = new QmitkBooleanOperationsWidget(timeNavigationController, parent);
 
   m_MorphologicalOperationsWidget = new QmitkMorphologicalOperationsWidget(timeNavigationController, parent);
 
   m_SurfaceToImageWidget = new QmitkSurfaceToImageWidget(timeNavigationController, parent);
 
   m_ImageMaskingWidget = new QmitkImageMaskingWidget(timeNavigationController, parent);
 
+  m_ConvertToMlWidget = new QmitkConvertToMlWidget(timeNavigationController, parent);
+
   this->AddUtilityWidget(m_BooleanOperationsWidget, QIcon(":/MultiLabelSegmentationUtilities/BooleanOperations_48x48.png"), "Boolean Operations");
 
   this->AddUtilityWidget(m_MorphologicalOperationsWidget, QIcon(":/MultiLabelSegmentationUtilities/MorphologicalOperations_48x48.png"), "Morphological Operations");
 
   this->AddUtilityWidget(m_SurfaceToImageWidget, QIcon(":/MultiLabelSegmentationUtilities/SurfaceToImage_48x48.png"), "Surface To Image");
 
   this->AddUtilityWidget(m_ImageMaskingWidget, QIcon(":/MultiLabelSegmentationUtilities/ImageMasking_48x48.png"), "Image Masking");
+
+  this->AddUtilityWidget(m_ConvertToMlWidget, QIcon(":/MultiLabelSegmentationUtilities/multilabelsegmentation.svg"), "Convert To MultiLabel");
 }
 
 void QmitkMultiLabelSegmentationUtilitiesView::AddUtilityWidget(QWidget* widget, const QIcon& icon, const QString& text)
 {
   m_Controls.toolBox->addItem(widget, icon, text);
 }
 
 void QmitkMultiLabelSegmentationUtilitiesView::SetFocus()
 {
   m_Controls.toolBox->setFocus();
 }
 
 void QmitkMultiLabelSegmentationUtilitiesView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   mitk::SliceNavigationController* timeNavigationController = renderWindowPart->GetTimeNavigationController();
 
   m_BooleanOperationsWidget->SetTimeNavigationController(timeNavigationController);
   m_MorphologicalOperationsWidget->SetTimeNavigationController(timeNavigationController);
   m_SurfaceToImageWidget->SetTimeNavigationController(timeNavigationController);
   m_ImageMaskingWidget->SetTimeNavigationController(timeNavigationController);
+  m_ConvertToMlWidget->SetTimeNavigationController(timeNavigationController);
 }
 
 void QmitkMultiLabelSegmentationUtilitiesView::RenderWindowPartDeactivated(mitk::IRenderWindowPart*)
 {
   m_BooleanOperationsWidget->SetTimeNavigationController(nullptr);
   m_MorphologicalOperationsWidget->SetTimeNavigationController(nullptr);
   m_SurfaceToImageWidget->SetTimeNavigationController(nullptr);
   m_ImageMaskingWidget->SetTimeNavigationController(nullptr);
+  m_ConvertToMlWidget->SetTimeNavigationController(nullptr);
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.h b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.h
index 865257ebe3..a770534960 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.h
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/QmitkMultiLabelSegmentationUtilitiesView.h
@@ -1,57 +1,61 @@
 /*===================================================================
 
 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 QmitkMultiLabelSegmentationUtilitiesView_h
 #define QmitkMultiLabelSegmentationUtilitiesView_h
 
 #include <ui_QmitkMultiLabelSegmentationUtilitiesViewControls.h>
 #include <mitkIRenderWindowPartListener.h>
 #include <QmitkAbstractView.h>
 
 class QmitkBooleanOperationsWidget;
 class QmitkSurfaceToImageWidget;
 class QmitkImageMaskingWidget;
 class QmitkMorphologicalOperationsWidget;
+class QmitkMorphologicalOperationsWidget;
+class QmitkConvertToMlWidget;
 
 class QmitkMultiLabelSegmentationUtilitiesView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
   QmitkMultiLabelSegmentationUtilitiesView();
   ~QmitkMultiLabelSegmentationUtilitiesView();
 
   void CreateQtPartControl(QWidget* parent);
   void SetFocus();
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart);
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart);
 
 private:
   void AddUtilityWidget(QWidget* widget, const QIcon& icon, const QString& text);
 
   QmitkBooleanOperationsWidget* m_BooleanOperationsWidget;
 
   QmitkMorphologicalOperationsWidget* m_MorphologicalOperationsWidget;
 
   QmitkSurfaceToImageWidget* m_SurfaceToImageWidget;
 
   QmitkImageMaskingWidget* m_ImageMaskingWidget;
 
+  QmitkConvertToMlWidget* m_ConvertToMlWidget;
+
   Ui::QmitkMultiLabelSegmentationUtilitiesViewControls m_Controls;
 };
 
 #endif