diff --git a/Modules/DiffusionIO/Mapper/mitkCompositeMapper.cpp b/Modules/DiffusionCore/Rendering/mitkCompositeMapper.cpp
similarity index 100%
rename from Modules/DiffusionIO/Mapper/mitkCompositeMapper.cpp
rename to Modules/DiffusionCore/Rendering/mitkCompositeMapper.cpp
diff --git a/Modules/DiffusionIO/Mapper/mitkCompositeMapper.h b/Modules/DiffusionCore/Rendering/mitkCompositeMapper.h
similarity index 97%
rename from Modules/DiffusionIO/Mapper/mitkCompositeMapper.h
rename to Modules/DiffusionCore/Rendering/mitkCompositeMapper.h
index a6c3b7f..40c0e5a 100644
--- a/Modules/DiffusionIO/Mapper/mitkCompositeMapper.h
+++ b/Modules/DiffusionCore/Rendering/mitkCompositeMapper.h
@@ -1,162 +1,163 @@
 /*===================================================================
 
 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 COMPOSITEMAPPER_H_HEADER_INCLUDED
 #define COMPOSITEMAPPER_H_HEADER_INCLUDED
 
 #include "mitkGLMapper.h"
 #include "mitkVtkMapper.h"
 #include "mitkOdfImage.h"
 #include "mitkImageVtkMapper2D.h"
 #include "mitkOdfVtkMapper2D.h"
 #include "mitkLevelWindowProperty.h"
+#include <MitkDiffusionCoreExports.h>
 
 namespace mitk {
 
   class CopyImageMapper2D : public ImageVtkMapper2D
   {
   public:
     mitkClassMacro(CopyImageMapper2D,ImageVtkMapper2D);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     friend class CompositeMapper;
   };
 
   //##Documentation
   //## @brief Composite pattern for combination of different mappers
   //## @ingroup Mapper
-  class CompositeMapper : public VtkMapper
+  class MITKDIFFUSIONCORE_EXPORT CompositeMapper : public VtkMapper
   {
   public:
 
     mitkClassMacro(CompositeMapper,VtkMapper);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     void MitkRenderOverlay(BaseRenderer* renderer) override
     {
       m_ImgMapper->MitkRenderOverlay(renderer);
       m_OdfMapper->MitkRenderOverlay(renderer);
     }
 
     void MitkRenderOpaqueGeometry(BaseRenderer* renderer) override
     {
       m_ImgMapper->MitkRenderOpaqueGeometry(renderer);
       m_OdfMapper->MitkRenderOpaqueGeometry(renderer);
       if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
       {
         renderer->Modified();
       }
     }
 
     void MitkRenderTranslucentGeometry(BaseRenderer* renderer) override
     {
       m_ImgMapper->MitkRenderTranslucentGeometry(renderer);
       m_OdfMapper->MitkRenderTranslucentGeometry(renderer);
     }
 
     void MitkRenderVolumetricGeometry(BaseRenderer* renderer) override
     {
       m_ImgMapper->MitkRenderVolumetricGeometry(renderer);
       m_OdfMapper->MitkRenderVolumetricGeometry(renderer);
     }
 
     void SetDataNode(DataNode* node) override
     {
       m_DataNode = node;
       m_ImgMapper->SetDataNode(node);
       m_OdfMapper->SetDataNode(node);
     }
 
     mitk::ImageVtkMapper2D::Pointer GetImageMapper()
     {
       ImageVtkMapper2D* retval = m_ImgMapper;
       return retval;
     }
 
     bool HasVtkProp( const vtkProp* prop, BaseRenderer* renderer ) override
     {
       return m_OdfMapper->HasVtkProp(prop, renderer);
     }
 
     void ReleaseGraphicsResources(mitk::BaseRenderer* renderer) override
     {
       m_ImgMapper->ReleaseGraphicsResources(renderer);
       m_OdfMapper->ReleaseGraphicsResources(renderer);
     }
 
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false )
     {
       mitk::OdfVtkMapper2D<float,ODF_SAMPLING_SIZE>::SetDefaultProperties(node, renderer, overwrite);
       mitk::CopyImageMapper2D::SetDefaultProperties(node, renderer, overwrite);
 
       mitk::LevelWindow opaclevwin;
       opaclevwin.SetRangeMinMax(0,255);
       opaclevwin.SetWindowBounds(0,0);
       mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
       node->AddProperty( "opaclevelwindow", prop );
     }
 
     bool IsLODEnabled( BaseRenderer * renderer ) const override
     {
       return m_ImgMapper->IsLODEnabled(renderer) || m_OdfMapper->IsLODEnabled(renderer);
     }
 
     vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override
     {
       m_PropAssembly = vtkSmartPointer<vtkPropAssembly>::New();
       m_PropAssembly->AddPart( m_OdfMapper->GetVtkProp(renderer));
       m_PropAssembly->AddPart( m_ImgMapper->GetVtkProp(renderer));
       return m_PropAssembly;
     }
 
   protected:
 
     void Update(mitk::BaseRenderer* renderer) override
     {
       m_OdfMapper->Update(renderer);
       GenerateDataForRenderer(renderer);
     }
 
     void GenerateDataForRenderer(mitk::BaseRenderer* renderer) override
     {
       m_ImgMapper->GenerateDataForRenderer(renderer);
 //      if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) > 0 )
 //      {
 //        m_OdfMapper->GenerateDataForRenderer(renderer);
 //      }
     }
 
     CompositeMapper();
 
     ~CompositeMapper() override;
 
   private:
 
     mitk::OdfVtkMapper2D<float,ODF_SAMPLING_SIZE>::Pointer m_OdfMapper;
     mitk::CopyImageMapper2D::Pointer m_ImgMapper;
     vtkSmartPointer<vtkPropAssembly> m_PropAssembly;
 
   };
 
 } // namespace mitk
 
 
 
 #endif /* COMPOSITEMAPPER_H_HEADER_INCLUDED */
 
diff --git a/Modules/DiffusionIO/Mapper/mitkFiberBundleMapper2D.cpp b/Modules/DiffusionCore/Rendering/mitkFiberBundleMapper2D.cpp
similarity index 100%
rename from Modules/DiffusionIO/Mapper/mitkFiberBundleMapper2D.cpp
rename to Modules/DiffusionCore/Rendering/mitkFiberBundleMapper2D.cpp
diff --git a/Modules/DiffusionIO/Mapper/mitkFiberBundleMapper2D.h b/Modules/DiffusionCore/Rendering/mitkFiberBundleMapper2D.h
similarity index 95%
rename from Modules/DiffusionIO/Mapper/mitkFiberBundleMapper2D.h
rename to Modules/DiffusionCore/Rendering/mitkFiberBundleMapper2D.h
index c1daaf5..147a724 100644
--- a/Modules/DiffusionIO/Mapper/mitkFiberBundleMapper2D.h
+++ b/Modules/DiffusionCore/Rendering/mitkFiberBundleMapper2D.h
@@ -1,86 +1,87 @@
 /*===================================================================
 
 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 FiberBundleMAPPER2D_H_HEADER_INCLUDED
 #define FiberBundleMAPPER2D_H_HEADER_INCLUDED
 
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 #include <mitkVtkMapper.h>
 #include <mitkFiberBundle.h>
 #include <vtkSmartPointer.h>
+#include <MitkDiffusionCoreExports.h>
 
 #define MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER vtkOpenGLPolyDataMapper
 
 class vtkActor;
 class mitkBaseRenderer;
 class MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 namespace mitk {
 
 struct IShaderRepository;
 
-class FiberBundleMapper2D : public VtkMapper
+class MITKDIFFUSIONCORE_EXPORT FiberBundleMapper2D : public VtkMapper
 {
 
 public:
   mitkClassMacro(FiberBundleMapper2D, VtkMapper);
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   mitk::FiberBundle* GetInput();
   void Update(mitk::BaseRenderer * renderer) override;
   static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false );
   vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override;
 
   class  FBXLocalStorage : public mitk::Mapper::BaseLocalStorage
   {
   public:
     vtkSmartPointer<vtkActor> m_Actor;
     vtkSmartPointer<MITKFIBERBUNDLEMAPPER2D_POLYDATAMAPPER> m_Mapper;
     itk::TimeStamp m_LastUpdateTime;
     FBXLocalStorage();
 
     ~FBXLocalStorage() override
     {
     }
   };
 
   /** \brief This member holds all three LocalStorages for the three 2D render windows. */
   mitk::LocalStorageHandler<FBXLocalStorage> m_LocalStorageHandler;
 
 protected:
   FiberBundleMapper2D();
   ~FiberBundleMapper2D() override;
 
   /** Does the actual resampling, without rendering. */
   void GenerateDataForRenderer(mitk::BaseRenderer*) override;
 
   void UpdateShaderParameter(mitk::BaseRenderer*);
 
 private:
   vtkSmartPointer<vtkLookupTable> m_lut;
 
   int     m_LineWidth;
 };
 
 
 }//end namespace
 
 #endif
diff --git a/Modules/DiffusionIO/Mapper/mitkFiberBundleMapper3D.cpp b/Modules/DiffusionCore/Rendering/mitkFiberBundleMapper3D.cpp
similarity index 100%
rename from Modules/DiffusionIO/Mapper/mitkFiberBundleMapper3D.cpp
rename to Modules/DiffusionCore/Rendering/mitkFiberBundleMapper3D.cpp
diff --git a/Modules/DiffusionIO/Mapper/mitkFiberBundleMapper3D.h b/Modules/DiffusionCore/Rendering/mitkFiberBundleMapper3D.h
similarity index 95%
rename from Modules/DiffusionIO/Mapper/mitkFiberBundleMapper3D.h
rename to Modules/DiffusionCore/Rendering/mitkFiberBundleMapper3D.h
index fa70e4f..96b6490 100644
--- a/Modules/DiffusionIO/Mapper/mitkFiberBundleMapper3D.h
+++ b/Modules/DiffusionCore/Rendering/mitkFiberBundleMapper3D.h
@@ -1,92 +1,94 @@
 /*===================================================================
 
 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 FiberBundleMapper3D_H_HEADER_INCLUDED
 #define FiberBundleMapper3D_H_HEADER_INCLUDED
 
 #include <mitkVtkMapper.h>
 #include <mitkFiberBundle.h>
 #include <vtkOpenGLPolyDataMapper.h>
 #include <vtkSmartPointer.h>
+#include <MitkDiffusionCoreExports.h>
+
 class vtkPropAssembly;
 class vtkPolyDataMapper;
 class vtkLookupTable;
 class vtkOpenGLActor;
 
 namespace mitk {
 
 //##Documentation
 //## @brief Mapper for FiberBundle
 //## @ingroup Mapper
 
-class FiberBundleMapper3D : public VtkMapper
+class MITKDIFFUSIONCORE_EXPORT FiberBundleMapper3D : public VtkMapper
 {
 public:
 
   mitkClassMacro(FiberBundleMapper3D, VtkMapper)
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   const FiberBundle* GetInput();
   vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override; //looks like depricated.. should be replaced bz GetViewProp()
   static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false );
   void GenerateDataForRenderer(mitk::BaseRenderer* renderer) override;
 
   class  LocalStorage3D : public mitk::Mapper::BaseLocalStorage
   {
   public:
     vtkSmartPointer<vtkActor> m_FiberActor;
     vtkSmartPointer<vtkOpenGLPolyDataMapper> m_FiberMapper;
     vtkSmartPointer<vtkPropAssembly> m_FiberAssembly;
 
     itk::TimeStamp m_LastUpdateTime;
     LocalStorage3D();
 
     ~LocalStorage3D() override
     {
     }
   };
 
   /** \brief This member holds all three LocalStorages for the 3D render window(s). */
   mitk::LocalStorageHandler<LocalStorage3D> m_LocalStorageHandler;
 
 
 protected:
 
   FiberBundleMapper3D();
   ~FiberBundleMapper3D() override;
   void InternalGenerateData(mitk::BaseRenderer *renderer);
 
   void UpdateShaderParameter(mitk::BaseRenderer*);
 
 private:
   vtkSmartPointer<vtkLookupTable> m_lut;
   float   m_TubeRadius;
   int     m_TubeSides;
   int     m_LineWidth;
   float   m_RibbonWidth;
   vtkSmartPointer<vtkPolyData> m_FiberPolyData;
   mitk::FiberBundle* m_FiberBundle;
 };
 
 } // end namespace mitk
 
 
 
 
 #endif /* FiberBundleMapper3D_H_HEADER_INCLUDED */
 
diff --git a/Modules/DiffusionIO/Mapper/mitkPeakImageMapper2D.cpp b/Modules/DiffusionCore/Rendering/mitkPeakImageMapper2D.cpp
similarity index 100%
rename from Modules/DiffusionIO/Mapper/mitkPeakImageMapper2D.cpp
rename to Modules/DiffusionCore/Rendering/mitkPeakImageMapper2D.cpp
diff --git a/Modules/DiffusionIO/Mapper/mitkPeakImageMapper2D.h b/Modules/DiffusionCore/Rendering/mitkPeakImageMapper2D.h
similarity index 95%
rename from Modules/DiffusionIO/Mapper/mitkPeakImageMapper2D.h
rename to Modules/DiffusionCore/Rendering/mitkPeakImageMapper2D.h
index 39e97b8..237d969 100644
--- a/Modules/DiffusionIO/Mapper/mitkPeakImageMapper2D.h
+++ b/Modules/DiffusionCore/Rendering/mitkPeakImageMapper2D.h
@@ -1,85 +1,86 @@
 /*===================================================================
 
 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 PeakImageMapper2D_H_HEADER_INCLUDED
 #define PeakImageMapper2D_H_HEADER_INCLUDED
 
 //MITK Rendering
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 #include <mitkVtkMapper.h>
 #include <mitkPeakImage.h>
 #include <vtkSmartPointer.h>
+#include <MitkDiffusionCoreExports.h>
 
 #define MITKPeakImageMapper2D_POLYDATAMAPPER vtkOpenGLPolyDataMapper
 
 class vtkActor;
 class mitkBaseRenderer;
 class MITKPeakImageMapper2D_POLYDATAMAPPER;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 
 
 namespace mitk {
 
 struct IShaderRepository;
 
-class PeakImageMapper2D : public VtkMapper
+class MITKDIFFUSIONCORE_EXPORT PeakImageMapper2D : public VtkMapper
 {
 
 public:
     mitkClassMacro(PeakImageMapper2D, VtkMapper)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     mitk::PeakImage* GetInput();
     void Update(mitk::BaseRenderer * renderer) override;
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false );
     void UpdateVtkTransform(mitk::BaseRenderer *renderer) override;
     vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override;
 
     class  LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
         vtkSmartPointer<vtkActor> m_PointActor;
         vtkSmartPointer<MITKPeakImageMapper2D_POLYDATAMAPPER> m_Mapper;
 
         itk::TimeStamp m_LastUpdateTime;
         LocalStorage();
 
         ~LocalStorage() override
         {
         }
     };
 
     /** \brief This member holds all three LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<LocalStorage> m_LocalStorageHandler;
 
 protected:
     PeakImageMapper2D();
     ~PeakImageMapper2D() override;
     void GenerateDataForRenderer(mitk::BaseRenderer*) override;
 
 private:
     vtkSmartPointer<vtkLookupTable> m_lut;
 };
 
 
 }//end namespace
 
 #endif
diff --git a/Modules/DiffusionIO/Mapper/mitkPeakImageMapper3D.cpp b/Modules/DiffusionCore/Rendering/mitkPeakImageMapper3D.cpp
similarity index 100%
rename from Modules/DiffusionIO/Mapper/mitkPeakImageMapper3D.cpp
rename to Modules/DiffusionCore/Rendering/mitkPeakImageMapper3D.cpp
diff --git a/Modules/DiffusionIO/Mapper/mitkPeakImageMapper3D.h b/Modules/DiffusionCore/Rendering/mitkPeakImageMapper3D.h
similarity index 95%
rename from Modules/DiffusionIO/Mapper/mitkPeakImageMapper3D.h
rename to Modules/DiffusionCore/Rendering/mitkPeakImageMapper3D.h
index 09891ba..8c33d9e 100644
--- a/Modules/DiffusionIO/Mapper/mitkPeakImageMapper3D.h
+++ b/Modules/DiffusionCore/Rendering/mitkPeakImageMapper3D.h
@@ -1,85 +1,86 @@
 /*===================================================================
 
 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 PeakImageMapper3D_H_HEADER_INCLUDED
 #define PeakImageMapper3D_H_HEADER_INCLUDED
 
 //MITK Rendering
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 #include <mitkVtkMapper.h>
 #include <mitkPeakImage.h>
 #include <vtkSmartPointer.h>
+#include <MitkDiffusionCoreExports.h>
 
 #define MITKPeakImageMapper3D_POLYDATAMAPPER vtkOpenGLPolyDataMapper
 
 class vtkActor;
 class mitkBaseRenderer;
 class MITKPeakImageMapper3D_POLYDATAMAPPER;
 class vtkCutter;
 class vtkPlane;
 class vtkPolyData;
 
 
 
 namespace mitk {
 
 struct IShaderRepository;
 
-class PeakImageMapper3D : public VtkMapper
+class MITKDIFFUSIONCORE_EXPORT PeakImageMapper3D : public VtkMapper
 {
 
 public:
     mitkClassMacro(PeakImageMapper3D, VtkMapper)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     mitk::PeakImage* GetInput();
     void Update(mitk::BaseRenderer * renderer) override;
     static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false );
     void UpdateVtkTransform(mitk::BaseRenderer *renderer) override;
     vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) override;
 
     class  LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
         vtkSmartPointer<vtkActor> m_Actor;
         vtkSmartPointer<MITKPeakImageMapper3D_POLYDATAMAPPER> m_Mapper;
         vtkSmartPointer<vtkPropAssembly> m_Assembly;
 
         itk::TimeStamp m_LastUpdateTime;
         LocalStorage();
 
         ~LocalStorage() override
         {
         }
     };
 
     mitk::LocalStorageHandler<LocalStorage> m_LocalStorageHandler;
 
 protected:
     PeakImageMapper3D();
     ~PeakImageMapper3D() override;
     void GenerateDataForRenderer(mitk::BaseRenderer*) override;
 
 private:
     vtkSmartPointer<vtkLookupTable> m_lut;
 };
 
 
 }//end namespace
 
 #endif
diff --git a/Modules/DiffusionCore/files.cmake b/Modules/DiffusionCore/files.cmake
index 7895686..193b6be 100644
--- a/Modules/DiffusionCore/files.cmake
+++ b/Modules/DiffusionCore/files.cmake
@@ -1,166 +1,163 @@
 set(CPP_FILES
 
+  mitkDiffusionFunctionCollection.cpp
+
   # DicomImport
   # DicomImport/mitkGroupDiffusionHeadersFilter.cpp
   DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
 
   DicomImport/mitkDiffusionDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
   DicomImport/mitkDiffusionHeaderSiemensMosaicDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
 
-  # DataStructures -> DWI
+  # DataStructures
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCreationFilter.cpp
+  IODataStructures/mitkOdfImage.cpp
+  IODataStructures/mitkShImage.cpp
+  IODataStructures/mitkTensorImage.cpp
+  IODataStructures/mitkPeakImage.cpp
+  IODataStructures/mitkFiberBundle.cpp
+  IODataStructures/mitkTrackvis.cpp
+  IODataStructures/mitkPlanarFigureComposite.cpp
+  IODataStructures/mitkTractographyForest.cpp
 
   # Properties
   IODataStructures/Properties/mitkBValueMapProperty.cpp
   IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
   IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
   IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
   IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
 
   # Serializer
   IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
   IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
   IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
 
-  IODataStructures/mitkOdfImage.cpp
-  IODataStructures/mitkShImage.cpp
-  IODataStructures/mitkTensorImage.cpp
-  IODataStructures/mitkPeakImage.cpp
-
-  IODataStructures/mitkFiberBundle.cpp
-  IODataStructures/mitkTrackvis.cpp
-  IODataStructures/mitkPlanarFigureComposite.cpp
-  IODataStructures/mitkTractographyForest.cpp
-
+  # Mapper etc.
   Rendering/vtkMaskedProgrammableGlyphFilter.cpp
   Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
   Rendering/vtkOdfSource.cxx
   Rendering/vtkThickPlane.cxx
   Rendering/mitkOdfNormalizationMethodProperty.cpp
   Rendering/mitkOdfScaleByProperty.cpp
+  Rendering/mitkFiberBundleMapper2D.cpp
+  Rendering/mitkFiberBundleMapper3D.cpp
+  Rendering/mitkPeakImageMapper2D.cpp
+  Rendering/mitkPeakImageMapper3D.cpp
+  Rendering/mitkCompositeMapper.cpp
 
   # Algorithms
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
   Algorithms/itkDwiGradientLengthCorrectionFilter.cpp
-
-  # Registration Algorithms & Co.
   Algorithms/Registration/mitkRegistrationWrapper.cpp
   Algorithms/Registration/mitkPyramidImageRegistrationMethod.cpp
   # Algorithms/Registration/mitkRegistrationMethodITK4.cpp
   Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
-
-
-  # MultishellProcessing
   Algorithms/Reconstruction/MultishellProcessing/itkADCAverageFunctor.cpp
   Algorithms/Reconstruction/MultishellProcessing/itkADCFitFunctor.cpp
   Algorithms/Reconstruction/MultishellProcessing/itkKurtosisFitFunctor.cpp
   Algorithms/Reconstruction/MultishellProcessing/itkBiExpFitFunctor.cpp
-
-  # Function Collection
-  mitkDiffusionFunctionCollection.cpp
 )
 
 set(H_FILES
-  # function Collection
   mitkDiffusionFunctionCollection.h
 
   # Rendering
   Rendering/mitkOdfVtkMapper2D.h
 
   # Reconstruction
   Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
   Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
   Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
   Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
   Algorithms/Reconstruction/itkPointShell.h
   Algorithms/Reconstruction/itkOrientationDistributionFunction.h
   Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
   Algorithms/Reconstruction/itkDiffusionKurtosisReconstructionImageFilter.h
   Algorithms/Reconstruction/itkBallAndSticksImageFilter.h
   Algorithms/Reconstruction/itkMultiTensorImageFilter.h
 
   # Fitting functions
   Algorithms/Reconstruction/FittingFunctions/mitkAbstractFitter.h
   Algorithms/Reconstruction/FittingFunctions/mitkMultiTensorFitter.h
   Algorithms/Reconstruction/FittingFunctions/mitkBallStickFitter.h
 
 
   # MultishellProcessing
   Algorithms/Reconstruction/MultishellProcessing/itkRadialMultishellToSingleshellImageFilter.h
   Algorithms/Reconstruction/MultishellProcessing/itkDWIVoxelFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkADCAverageFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkKurtosisFitFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkBiExpFitFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkADCFitFunctor.h
 
   IODataStructures/mitkFiberBundle.h
   IODataStructures/mitkTrackvis.h
   IODataStructures/mitkPlanarFigureComposite.h
   IODataStructures/mitkTractographyForest.h
 
   IODataStructures/Properties/mitkBValueMapProperty.h
   IODataStructures/Properties/mitkGradientDirectionsProperty.h
   IODataStructures/Properties/mitkMeasurementFrameProperty.h
   IODataStructures/Properties/mitkDiffusionPropertyHelper.h
 
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageTransformedCreationFilter.h
 
   # Algorithms
   Algorithms/itkDiffusionOdfGeneralizedFaImageFilter.h
   Algorithms/itkDiffusionOdfPrepareVisualizationImageFilter.h
   Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
   Algorithms/itkTensorDerivedMeasurementsFilter.h
   Algorithms/itkBrainMaskExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionToSeparateImageFilter.h
   Algorithms/itkTensorImageToDiffusionImageFilter.h
   Algorithms/itkTensorToL2NormImageFilter.h
   Algorithms/itkGaussianInterpolateImageFunction.h
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
   Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
   Algorithms/itkCartesianToPolarVectorImageFilter.h
   Algorithms/itkPolarToCartesianVectorImageFilter.h
   Algorithms/itkDistanceMapFilter.h
   Algorithms/itkResidualImageFilter.h
   Algorithms/itkExtractChannelFromRgbaImageFilter.h
   Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
   Algorithms/itkMergeDiffusionImagesFilter.h
   Algorithms/itkShCoefficientImageImporter.h
   Algorithms/itkShCoefficientImageExporter.h
   Algorithms/itkOdfMaximaExtractionFilter.h
   Algorithms/itkResampleDwiImageFilter.h
   Algorithms/itkDwiGradientLengthCorrectionFilter.h
   Algorithms/itkAdcImageFilter.h
   Algorithms/itkDwiNormilzationFilter.h
   Algorithms/itkSplitDWImageFilter.h
   Algorithms/itkRemoveDwiChannelFilter.h
   Algorithms/itkExtractDwiChannelFilter.h
   Algorithms/itkFlipPeaksFilter.h
   Algorithms/itkShToOdfImageFilter.h
   Algorithms/itkFourDToVectorImageFilter.h
   Algorithms/itkVectorImageToFourDImageFilter.h
   Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
   Algorithms/itkNonLocalMeansDenoisingFilter.h
   Algorithms/itkVectorImageToImageFilter.h
   Algorithms/itkSplitVectorImageFilter.h
   Algorithms/itkRegularizedIVIMLocalVariationImageFilter.h
   Algorithms/itkRegularizedIVIMReconstructionFilter.h
   Algorithms/itkRegularizedIVIMReconstructionSingleIteration.h
 )
 
 set( TOOL_FILES
 )
 
diff --git a/Modules/DiffusionIO/CMakeLists.txt b/Modules/DiffusionIO/CMakeLists.txt
index bc668ab..4fcc91b 100644
--- a/Modules/DiffusionIO/CMakeLists.txt
+++ b/Modules/DiffusionIO/CMakeLists.txt
@@ -1,10 +1,10 @@
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-Diffusion
-  INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR} Mapper ReaderWriter ObjectFactories
+  INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR} ReaderWriter ObjectFactories
   DEPENDS MitkConnectomics MitkDiffusionCore MitkSceneSerialization
   AUTOLOAD_WITH MitkCore
   PACKAGE_DEPENDS 
     PUBLIC DCMTK
     PRIVATE tinyxml
 )
 
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReaderService.cpp b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReader.cpp
similarity index 94%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReaderService.cpp
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReader.cpp
index 4a28e24..795ca2a 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReaderService.cpp
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReader.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
+#ifndef __mitkDiffusionImageDicomReader_cpp
+#define __mitkDiffusionImageDicomReader_cpp
 
-#include "mitkDiffusionImageDicomReaderService.h"
+#include "mitkDiffusionImageDicomReader.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 "mitkDiffusionIOMimeTypes.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)
+DiffusionImageDicomReader::
+DiffusionImageDicomReader(const DiffusionImageDicomReader & other)
   : AbstractFileReader(other)
 {
 }
 
 
-DiffusionImageDicomReaderService* DiffusionImageDicomReaderService::Clone() const
+DiffusionImageDicomReader* DiffusionImageDicomReader::Clone() const
 {
-  return new DiffusionImageDicomReaderService(*this);
+  return new DiffusionImageDicomReader(*this);
 }
 
 
-DiffusionImageDicomReaderService::
-~DiffusionImageDicomReaderService()
+DiffusionImageDicomReader::
+~DiffusionImageDicomReader()
 {}
 
-DiffusionImageDicomReaderService::
-DiffusionImageDicomReaderService()
+DiffusionImageDicomReader::
+DiffusionImageDicomReader()
   : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_DICOM_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_DICOM_MIMETYPE_DESCRIPTION() )
 {
   Options defaultOptions;
   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()
+DiffusionImageDicomReader::Read()
 {
   return InternalRead();
 }
 
 
-std::vector<itk::SmartPointer<mitk::BaseData> > DiffusionImageDicomReaderService::InternalRead()
+std::vector<itk::SmartPointer<mitk::BaseData> > DiffusionImageDicomReader::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 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/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReaderService.h b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReader.h
similarity index 78%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReaderService.h
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReader.h
index e74fcfe..6983763 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReaderService.h
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageDicomReader.h
@@ -1,73 +1,73 @@
 /*===================================================================
 
 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_h
-#define __mitkDiffusionImageDicomReaderService_h
+#ifndef __mitkDiffusionImageDicomReader_h
+#define __mitkDiffusionImageDicomReader_h
 
 #include "mitkCommon.h"
 
 // MITK includes
 #include "mitkImageSource.h"
 #include "mitkFileReader.h"
 
 #include <mitkDiffusionPropertyHelper.h>
 
 // ITK includes
 #include "itkVectorImage.h"
 #include "mitkAbstractFileReader.h"
 
 
 
 namespace mitk
 {
 
   /** \brief
   */
 
-  class DiffusionImageDicomReaderService : public mitk::AbstractFileReader
+  class DiffusionImageDicomReader : public mitk::AbstractFileReader
   {
   public:
 
-    DiffusionImageDicomReaderService(const DiffusionImageDicomReaderService & other);
-    DiffusionImageDicomReaderService();
-    ~DiffusionImageDicomReaderService() override;
+    DiffusionImageDicomReader(const DiffusionImageDicomReader & other);
+    DiffusionImageDicomReader();
+    ~DiffusionImageDicomReader() override;
 
     using AbstractFileReader::Read;
     std::vector<itk::SmartPointer<BaseData> > Read() override;
 
     typedef short                                                           DiffusionPixelType;
 
     typedef mitk::Image                                                     OutputType;
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
     OutputType::Pointer m_OutputCache;
     itk::TimeStamp m_CacheTime;
 
     std::vector<itk::SmartPointer<BaseData> > InternalRead();
 
   private:
 
-    DiffusionImageDicomReaderService* Clone() const override;
+    DiffusionImageDicomReader* Clone() const override;
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkDiffusionImageDicomReaderService_h
+#endif // __mitkDiffusionImageDicomReader_h
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReaderService.cpp b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReader.cpp
similarity index 94%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReaderService.cpp
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReader.cpp
index be7e583..9452914 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReaderService.cpp
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReader.cpp
@@ -1,342 +1,342 @@
 /*===================================================================
 
 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
+#ifndef __mitkDiffusionImageNiftiReader_cpp
+#define __mitkDiffusionImageNiftiReader_cpp
 
-#include "mitkDiffusionImageNiftiReaderService.h"
+#include "mitkDiffusionImageNiftiReader.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 "mitkDiffusionIOMimeTypes.h"
 
 #include <mitkITKImageImport.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include <mitkLocaleSwitch.h>
 #include "mitkIOUtil.h"
 #include <mitkDiffusionFunctionCollection.h>
 #include <vtkNIFTIImageReader.h>
 #include <vtkNIFTIImageHeader.h>
 #include <vtkImageIterator.h>
 
 namespace mitk
 {
 
-DiffusionImageNiftiReaderService::
-DiffusionImageNiftiReaderService(const DiffusionImageNiftiReaderService & other)
+DiffusionImageNiftiReader::
+DiffusionImageNiftiReader(const DiffusionImageNiftiReader & other)
   : AbstractFileReader(other)
 {
 }
 
 
-DiffusionImageNiftiReaderService* DiffusionImageNiftiReaderService::Clone() const
+DiffusionImageNiftiReader* DiffusionImageNiftiReader::Clone() const
 {
-  return new DiffusionImageNiftiReaderService(*this);
+  return new DiffusionImageNiftiReader(*this);
 }
 
 
-DiffusionImageNiftiReaderService::
-~DiffusionImageNiftiReaderService()
+DiffusionImageNiftiReader::
+~DiffusionImageNiftiReader()
 {}
 
-DiffusionImageNiftiReaderService::
-DiffusionImageNiftiReaderService()
+DiffusionImageNiftiReader::
+DiffusionImageNiftiReader()
   : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION() )
 
 {
   Options defaultOptions;
   defaultOptions["Apply image rotation to gradients"] = true;
   this->SetDefaultOptions(defaultOptions);
 
   m_ServiceReg = this->RegisterService();
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> >
-DiffusionImageNiftiReaderService::
+DiffusionImageNiftiReader::
 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()
+void DiffusionImageNiftiReader::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";
+      MITK_INFO << "DiffusionImageNiftiReader: reading image information";
       VectorImageType::Pointer itkVectorImage;
 
       std::string ext = this->GetMimeType()->GetExtension( this->GetInputLocation() );
       ext = itksys::SystemTools::LowerCase( ext );
 
       if(ext == ".nii" || ext == ".nii.gz")
       {
         // create reader and read file
         typedef itk::Image<DiffusionPixelType,4> ImageType4D;
         itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
 
         ImageType4D::Pointer img4 = ImageType4D::New();
         if (io2->CanReadFile(this->GetInputLocation().c_str()))
         {
           typedef itk::ImageFileReader<ImageType4D> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetFileName( this->GetInputLocation() );
           reader->SetImageIO(io2);
           reader->Update();
           img4 = reader->GetOutput();
         }
         else
         {
           vtkSmartPointer<vtkNIFTIImageReader> reader = vtkSmartPointer<vtkNIFTIImageReader>::New();
           if (reader->CanReadFile(this->GetInputLocation().c_str()))
           {
             reader->SetFileName(this->GetInputLocation().c_str());
             reader->SetTimeAsVector(true);
             reader->Update();
             auto vtk_image = reader->GetOutput();
             auto header = reader->GetNIFTIHeader();
             auto dim = header->GetDim(0);
             auto matrix = reader->GetQFormMatrix();
             if (matrix == nullptr)
               matrix = reader->GetSFormMatrix();
             itk::Matrix<double, 4, 4> direction; direction.SetIdentity();
             itk::Matrix<double, 4, 4> ras_lps; ras_lps.SetIdentity();
             ras_lps[0][0] = -1;
             ras_lps[1][1] = -1;
             if (matrix != nullptr)
             {
               for (int r=0; r<dim; r++)
                   for (int c=0; c<dim; c++)
                       direction[r][c] = matrix->GetElement(r, c);
             }
             direction = direction*ras_lps;
 
             itk::Vector< double, 4 > spacing; spacing.Fill(1.0);
             vtk_image->GetSpacing(spacing.GetDataPointer());
 
             itk::Point< double, 4 > origin; origin.Fill(0.0);
             vtk_image->GetOrigin(origin.GetDataPointer());
 
             itk::ImageRegion< 4 > region;
             for (int i=0; i<4; ++i)
               if (i<dim)
                 region.SetSize(i, header->GetDim(i+1));
               else
                 region.SetSize(i, 1);
 
             img4->SetSpacing( spacing );
             img4->SetOrigin( origin );
             img4->SetDirection( direction );
             img4->SetRegions( region );
             img4->Allocate();
             img4->FillBuffer(0);
 
             switch (header->GetDim(0)) {
             case 4:
               for (int g=0; g<header->GetDim(4); g++)
                 for (int z=0; z<header->GetDim(3); z++)
                   for (int y=0; y<header->GetDim(2); y++)
                     for (int x=0; x<header->GetDim(1); x++)
                     {
                       double val = vtk_image->GetScalarComponentAsDouble(x, y, z, g);
 
                       ImageType4D::IndexType idx;
                       idx[0] = x;
                       idx[1] = y;
                       idx[2] = z;
                       idx[3] = g;
                       img4->SetPixel(idx, val);
                     }
               break;
             default:
               mitkThrow() << "Image dimension " << header->GetDim(0) << " not supported!";
               break;
             }
           }
         }
 
         // 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 == ".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 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 file!");
     }
   }
 }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReaderService.h b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReader.h
similarity index 78%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReaderService.h
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReader.h
index 9faf34b..fd2dc3a 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReaderService.h
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReader.h
@@ -1,73 +1,73 @@
 /*===================================================================
 
 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_h
-#define __mitkDiffusionImageNrrdReaderService_h
+#ifndef __mitkDiffusionImageNiftiReader_h
+#define __mitkDiffusionImageNiftiReader_h
 
 #include "mitkCommon.h"
 
 // MITK includes
 #include "mitkImageSource.h"
 #include "mitkFileReader.h"
 
 #include <mitkDiffusionPropertyHelper.h>
 
 // ITK includes
 #include "itkVectorImage.h"
 #include "mitkAbstractFileReader.h"
 
 
 
 namespace mitk
 {
 
   /** \brief
   */
 
-  class DiffusionImageNrrdReaderService : public mitk::AbstractFileReader
+  class DiffusionImageNiftiReader : public mitk::AbstractFileReader
   {
   public:
 
-    DiffusionImageNrrdReaderService(const DiffusionImageNrrdReaderService & other);
-    DiffusionImageNrrdReaderService();
-    ~DiffusionImageNrrdReaderService() override;
+    DiffusionImageNiftiReader(const DiffusionImageNiftiReader & other);
+    DiffusionImageNiftiReader();
+    ~DiffusionImageNiftiReader() override;
 
     using AbstractFileReader::Read;
     std::vector<itk::SmartPointer<BaseData> > Read() override;
 
     typedef short                                                           DiffusionPixelType;
 
     typedef mitk::Image                                                     OutputType;
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
     OutputType::Pointer m_OutputCache;
     itk::TimeStamp m_CacheTime;
 
     void InternalRead();
 
   private:
 
-    DiffusionImageNrrdReaderService* Clone() const override;
+    DiffusionImageNiftiReader* Clone() const override;
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkDiffusionImageNrrdReaderService_h
+#endif // __mitkDiffusionImageNiftiReader_h
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriterService.cpp b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriter.cpp
similarity index 90%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriterService.cpp
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriter.cpp
index a856b20..6896dc7 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriterService.cpp
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriter.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 __mitkDiffusionImageNiftiWriterService__cpp
-#define __mitkDiffusionImageNiftiWriterService__cpp
+#ifndef __mitkDiffusionImageNiftiWriter__cpp
+#define __mitkDiffusionImageNiftiWriter__cpp
 
-#include "mitkDiffusionImageNiftiWriterService.h"
+#include "mitkDiffusionImageNiftiWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionIOMimeTypes.h"
 #include "mitkImageCast.h"
 #include <mitkLocaleSwitch.h>
 
 #include <iostream>
 #include <fstream>
 #include <mitkDiffusionFunctionCollection.h>
 
-mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService()
+mitk::DiffusionImageNiftiWriter::DiffusionImageNiftiWriter()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
-mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService(const mitk::DiffusionImageNiftiWriterService& other)
+mitk::DiffusionImageNiftiWriter::DiffusionImageNiftiWriter(const mitk::DiffusionImageNiftiWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
-mitk::DiffusionImageNiftiWriterService::~DiffusionImageNiftiWriterService()
+mitk::DiffusionImageNiftiWriter::~DiffusionImageNiftiWriter()
 {}
 
-void mitk::DiffusionImageNiftiWriterService::Write()
+void mitk::DiffusionImageNiftiWriter::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
-    MITK_ERROR <<"Sorry, input to DiffusionImageNiftiWriterService is nullptr!";
+    MITK_ERROR <<"Sorry, input to DiffusionImageNiftiWriter is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   mitk::LocaleSwitch localeSwitch("C");
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
     sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
   }
 
   for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
   {
     sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
     /*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
     std::string(keybuffer),tmp))
     continue;*/
 
     sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
       mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = this->GetMimeType()->GetExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .nii.gz
   if( ext == "")
   {
     ext = ".nii.gz";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
   if (ext == ".nii" || ext == ".nii.gz")
   {
     MITK_INFO << "Writing Nifti-Image";
 
     typedef itk::Image<short,4> ImageType4D;
     ImageType4D::Pointer img4 = ImageType4D::New();
 
     ImageType::SpacingType spacing = itkImg->GetSpacing();
     ImageType4D::SpacingType spacing4;
     for(int i=0; i<3; i++)
       spacing4[i] = spacing[i];
     spacing4[3] = 1;
     img4->SetSpacing( spacing4 );   // Set the image spacing
 
     ImageType::PointType origin = itkImg->GetOrigin();
     ImageType4D::PointType origin4;
     for(int i=0; i<3; i++)
       origin4[i] = origin[i];
     origin4[3] = 0;
     img4->SetOrigin( origin4 );     // Set the image origin
 
     ImageType::DirectionType direction = itkImg->GetDirection();
     ImageType4D::DirectionType direction4;
     for(int i=0; i<3; i++)
       for(int j=0; j<3; j++)
         direction4[i][j] = direction[i][j];
     for(int i=0; i<4; i++)
       direction4[i][3] = 0;
     for(int i=0; i<4; i++)
       direction4[3][i] = 0;
     direction4[3][3] = 1;
     img4->SetDirection( direction4 );  // Set the image direction
 
     ImageType::RegionType region = itkImg->GetLargestPossibleRegion();
     ImageType4D::RegionType region4;
 
     ImageType::RegionType::SizeType size = region.GetSize();
     ImageType4D::RegionType::SizeType size4;
 
     for(int i=0; i<3; i++)
       size4[i] = size[i];
     size4[3] = itkImg->GetVectorLength();
 
     ImageType::RegionType::IndexType index = region.GetIndex();
     ImageType4D::RegionType::IndexType index4;
     for(int i=0; i<3; i++)
       index4[i] = index[i];
     index4[3] = 0;
 
     region4.SetSize(size4);
     region4.SetIndex(index4);
     img4->SetRegions( region4 );
 
     img4->Allocate();
 
     itk::ImageRegionIterator<ImageType>   it (itkImg, itkImg->GetLargestPossibleRegion() );
     typedef ImageType::PixelType VecPixType;
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       ImageType::IndexType currentIndex = it.GetIndex();
       for(unsigned int ind=0; ind<vec.Size(); ind++)
       {
 
         for(int i=0; i<3; i++)
           index4[i] = currentIndex[i];
         index4[3] = ind;
         img4->SetPixel(index4, vec[ind]);
       }
     }
 
     itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
 
     typedef itk::ImageFileWriter<ImageType4D> WriterType4;
     WriterType4::Pointer nrrdWriter4 = WriterType4::New();
     nrrdWriter4->UseInputMetaDataDictionaryOn();
     nrrdWriter4->SetInput( img4 );
     nrrdWriter4->SetFileName(this->GetOutputLocation());
     nrrdWriter4->UseCompressionOn();
     nrrdWriter4->SetImageIO(io4);
     try
     {
       nrrdWriter4->Update();
     }
     catch (const itk::ExceptionObject& e)
     {
       std::cout << e.GetDescription() << std::endl;
       throw;
     }
 
 
     std::string base_path = itksys::SystemTools::GetFilenamePath(this->GetOutputLocation());
     std::string bvals_file = this->GetMimeType()->GetFilenameWithoutExtension(this->GetOutputLocation());
     if (!base_path.empty())
         bvals_file = base_path + "/" + bvals_file;
     bvals_file += ".bvals";
 
     std::string bvecs_file = this->GetMimeType()->GetFilenameWithoutExtension(this->GetOutputLocation());
     if (!base_path.empty())
         bvecs_file = base_path + "/" + bvecs_file;
     bvecs_file += ".bvecs";
 
     if(mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size())
     {
       MITK_INFO << "Saving original gradient directions";
       mitk::gradients::WriteBvalsBvecs(bvals_file, bvecs_file, mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input), mitk::DiffusionPropertyHelper::GetReferenceBValue(input));
     }
     else if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       MITK_INFO << "Original gradient directions not found. Saving modified gradient directions";
       mitk::gradients::WriteBvalsBvecs(bvals_file, bvecs_file, mitk::DiffusionPropertyHelper::GetGradientContainer(input), mitk::DiffusionPropertyHelper::GetReferenceBValue(input));
     }
   }
 }
 
-mitk::DiffusionImageNiftiWriterService* mitk::DiffusionImageNiftiWriterService::Clone() const
+mitk::DiffusionImageNiftiWriter* mitk::DiffusionImageNiftiWriter::Clone() const
 {
-  return new DiffusionImageNiftiWriterService(*this);
+  return new DiffusionImageNiftiWriter(*this);
 }
 
-mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNiftiWriterService::GetConfidenceLevel() const
+mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNiftiWriter::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
-#endif //__mitkDiffusionImageNiftiWriterService__cpp
+#endif //__mitkDiffusionImageNiftiWriter__cpp
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriterService.h b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriter.h
similarity index 75%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriterService.h
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriter.h
index f9d193a..f407f58 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriterService.h
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriter.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 _MITK_DiffusionImageNrrdWriterService__H_
-#define _MITK_DiffusionImageNrrdWriterService__H_
+#ifndef _MITK_DiffusionImageNiftiWriter__H_
+#define _MITK_DiffusionImageNiftiWriter__H_
 
 #include <mitkAbstractFileWriter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
-class DiffusionImageNrrdWriterService : public mitk::AbstractFileWriter
+class DiffusionImageNiftiWriter : public mitk::AbstractFileWriter
 {
 public:
 
-    DiffusionImageNrrdWriterService();
-    ~DiffusionImageNrrdWriterService() override;
+    DiffusionImageNiftiWriter();
+    ~DiffusionImageNiftiWriter() override;
 
     using AbstractFileWriter::Write;
     void Write() override;
 
     ConfidenceLevel GetConfidenceLevel() const override;
 
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
 
-    DiffusionImageNrrdWriterService(const DiffusionImageNrrdWriterService& other);
-    mitk::DiffusionImageNrrdWriterService* Clone() const override;
+    DiffusionImageNiftiWriter(const DiffusionImageNiftiWriter& other);
+    mitk::DiffusionImageNiftiWriter* Clone() const override;
 
 
 };
 
 
 } // end of namespace mitk
 
 #endif
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReaderService.cpp b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReader.cpp
similarity index 91%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReaderService.cpp
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReader.cpp
index 05ae996..a689a2a 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReaderService.cpp
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReader.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
+#ifndef __mitkDiffusionImageNrrdReader_cpp
+#define __mitkDiffusionImageNrrdReader_cpp
 
-#include "mitkDiffusionImageNrrdReaderService.h"
+#include "mitkDiffusionImageNrrdReader.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 "mitkDiffusionIOMimeTypes.h"
 
 #include <mitkITKImageImport.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include "mitkIOUtil.h"
 #include <mitkLocaleSwitch.h>
 
 namespace mitk
 {
 
-  DiffusionImageNrrdReaderService::
-  DiffusionImageNrrdReaderService(const DiffusionImageNrrdReaderService & other)
+  DiffusionImageNrrdReader::
+  DiffusionImageNrrdReader(const DiffusionImageNrrdReader & other)
     : AbstractFileReader(other)
   {
   }
 
 
-  DiffusionImageNrrdReaderService* DiffusionImageNrrdReaderService::Clone() const
+  DiffusionImageNrrdReader* DiffusionImageNrrdReader::Clone() const
   {
-    return new DiffusionImageNrrdReaderService(*this);
+    return new DiffusionImageNrrdReader(*this);
   }
 
 
-  DiffusionImageNrrdReaderService::
-  ~DiffusionImageNrrdReaderService()
+  DiffusionImageNrrdReader::
+  ~DiffusionImageNrrdReader()
   {}
 
-  DiffusionImageNrrdReaderService::
-  DiffusionImageNrrdReaderService()
+  DiffusionImageNrrdReader::
+  DiffusionImageNrrdReader()
     : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION() )
   {
     Options defaultOptions;
     defaultOptions["Apply image rotation to gradients"] = true;
     this->SetDefaultOptions(defaultOptions);
     m_ServiceReg = this->RegisterService();
   }
 
   std::vector<itk::SmartPointer<mitk::BaseData> >
-  DiffusionImageNrrdReaderService::
+  DiffusionImageNrrdReader::
   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()
+  void DiffusionImageNrrdReader::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";
+        MITK_INFO << "DiffusionImageNrrdReader: 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 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/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReaderService.h b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReader.h
similarity index 78%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReaderService.h
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReader.h
index ce37bc2..dfd14d9 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiReaderService.h
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdReader.h
@@ -1,73 +1,73 @@
 /*===================================================================
 
 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_h
-#define __mitkDiffusionImageNiftiReaderService_h
+#ifndef __mitkDiffusionImageNrrdReader_h
+#define __mitkDiffusionImageNrrdReader_h
 
 #include "mitkCommon.h"
 
 // MITK includes
 #include "mitkImageSource.h"
 #include "mitkFileReader.h"
 
 #include <mitkDiffusionPropertyHelper.h>
 
 // ITK includes
 #include "itkVectorImage.h"
 #include "mitkAbstractFileReader.h"
 
 
 
 namespace mitk
 {
 
   /** \brief
   */
 
-  class DiffusionImageNiftiReaderService : public mitk::AbstractFileReader
+  class DiffusionImageNrrdReader : public mitk::AbstractFileReader
   {
   public:
 
-    DiffusionImageNiftiReaderService(const DiffusionImageNiftiReaderService & other);
-    DiffusionImageNiftiReaderService();
-    ~DiffusionImageNiftiReaderService() override;
+    DiffusionImageNrrdReader(const DiffusionImageNrrdReader & other);
+    DiffusionImageNrrdReader();
+    ~DiffusionImageNrrdReader() override;
 
     using AbstractFileReader::Read;
     std::vector<itk::SmartPointer<BaseData> > Read() override;
 
     typedef short                                                           DiffusionPixelType;
 
     typedef mitk::Image                                                     OutputType;
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
     OutputType::Pointer m_OutputCache;
     itk::TimeStamp m_CacheTime;
 
     void InternalRead();
 
   private:
 
-    DiffusionImageNiftiReaderService* Clone() const override;
+    DiffusionImageNrrdReader* Clone() const override;
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkDiffusionImageNiftiReaderService_h
+#endif // __mitkDiffusionImageNrrdReader_h
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriterService.cpp b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriter.cpp
similarity index 88%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriterService.cpp
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriter.cpp
index 1004af2..9b482de 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriterService.cpp
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriter.cpp
@@ -1,173 +1,173 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef __mitkDiffusionImageNrrdWriterService__cpp
-#define __mitkDiffusionImageNrrdWriterService__cpp
+#ifndef __mitkDiffusionImageNrrdWriter__cpp
+#define __mitkDiffusionImageNrrdWriter__cpp
 
-#include "mitkDiffusionImageNrrdWriterService.h"
+#include "mitkDiffusionImageNrrdWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionIOMimeTypes.h"
 #include "mitkImageCast.h"
 #include <mitkLocaleSwitch.h>
 
 #include <iostream>
 #include <fstream>
 
 
-mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService()
+mitk::DiffusionImageNrrdWriter::DiffusionImageNrrdWriter()
   : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
-mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService(const mitk::DiffusionImageNrrdWriterService& other)
+mitk::DiffusionImageNrrdWriter::DiffusionImageNrrdWriter(const mitk::DiffusionImageNrrdWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
-mitk::DiffusionImageNrrdWriterService::~DiffusionImageNrrdWriterService()
+mitk::DiffusionImageNrrdWriter::~DiffusionImageNrrdWriter()
 {}
 
-void mitk::DiffusionImageNrrdWriterService::Write()
+void mitk::DiffusionImageNrrdWriter::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
-    MITK_ERROR <<"Sorry, input to DiffusionImageNrrdWriterService is nullptr!";
+    MITK_ERROR <<"Sorry, input to DiffusionImageNrrdWriter is nullptr!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   mitk::LocaleSwitch localeSwitch("C");
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
   vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
     itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
   itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
   if (mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->Size())
   {
       MITK_INFO << "Saving original gradient directions";
       sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
       itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
 
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
         sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(0),
           mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(input)->ElementAt(i).get(2));
 
         itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       }
   }
   else if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
       MITK_INFO << "Original gradient directions not found. Saving modified gradient directions";
       sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
       itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
 
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
         sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
           mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
         itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
       }
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = this->GetMimeType()->GetExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .nrrd
   if( ext == "")
   {
     ext = ".nrrd";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
 
   if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
 
     typedef itk::ImageFileWriter<ImageType> WriterType;
     WriterType::Pointer nrrdWriter = WriterType::New();
     nrrdWriter->UseInputMetaDataDictionaryOn();
     nrrdWriter->SetInput( itkImg );
     nrrdWriter->SetImageIO(io);
     nrrdWriter->SetFileName(this->GetOutputLocation());
     nrrdWriter->UseCompressionOn();
     nrrdWriter->SetImageIO(io);
     try
     {
       nrrdWriter->Update();
     }
     catch (const itk::ExceptionObject& e)
     {
       std::cout << e.GetDescription() << std::endl;
       throw;
     }
   }
 }
 
-mitk::DiffusionImageNrrdWriterService* mitk::DiffusionImageNrrdWriterService::Clone() const
+mitk::DiffusionImageNrrdWriter* mitk::DiffusionImageNrrdWriter::Clone() const
 {
-  return new DiffusionImageNrrdWriterService(*this);
+  return new DiffusionImageNrrdWriter(*this);
 }
 
-mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNrrdWriterService::GetConfidenceLevel() const
+mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNrrdWriter::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
-#endif //__mitkDiffusionImageNrrdWriterService__cpp
+#endif //__mitkDiffusionImageNrrdWriter__cpp
diff --git a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriterService.h b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriter.h
similarity index 74%
rename from Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriterService.h
rename to Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriter.h
index 4937d93..719b1db 100644
--- a/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNiftiWriterService.h
+++ b/Modules/DiffusionIO/ReaderWriter/mitkDiffusionImageNrrdWriter.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 _MITK_DiffusionImageNiftiWriterService__H_
-#define _MITK_DiffusionImageNiftiWriterService__H_
+#ifndef _MITK_DiffusionImageNrrdWriter__H_
+#define _MITK_DiffusionImageNrrdWriter__H_
 
 #include <mitkAbstractFileWriter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
-class DiffusionImageNiftiWriterService : public mitk::AbstractFileWriter
+class DiffusionImageNrrdWriter : public mitk::AbstractFileWriter
 {
 public:
 
-    DiffusionImageNiftiWriterService();
-    ~DiffusionImageNiftiWriterService() override;
+    DiffusionImageNrrdWriter();
+    ~DiffusionImageNrrdWriter() override;
 
     using AbstractFileWriter::Write;
     void Write() override;
 
     ConfidenceLevel GetConfidenceLevel() const override;
 
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
 
-    DiffusionImageNiftiWriterService(const DiffusionImageNiftiWriterService& other);
-    mitk::DiffusionImageNiftiWriterService* Clone() const override;
+    DiffusionImageNrrdWriter(const DiffusionImageNrrdWriter& other);
+    mitk::DiffusionImageNrrdWriter* Clone() const override;
 
 
 };
 
 
 } // end of namespace mitk
 
 #endif
diff --git a/Modules/DiffusionIO/files.cmake b/Modules/DiffusionIO/files.cmake
index e8aac0e..d8543ee 100644
--- a/Modules/DiffusionIO/files.cmake
+++ b/Modules/DiffusionIO/files.cmake
@@ -1,60 +1,54 @@
 set(CPP_FILES
 
-  mitkDiffusionModuleActivator.cpp
+  mitkDiffusionServiceActivator.cpp
   mitkDiffusionIOMimeTypes.cpp
 
   ObjectFactories/mitkDiffusionCoreObjectFactory.cpp
   ObjectFactories/mitkConnectomicsObjectFactory.cpp
 
-  Mapper/mitkFiberBundleMapper2D.cpp
-  Mapper/mitkFiberBundleMapper3D.cpp
-  Mapper/mitkPeakImageMapper2D.cpp
-  Mapper/mitkPeakImageMapper3D.cpp
-  Mapper/mitkCompositeMapper.cpp
-
   ReaderWriter/mitkConnectomicsNetworkReader.cpp
   ReaderWriter/mitkConnectomicsNetworkWriter.cpp
   ReaderWriter/mitkConnectomicsNetworkCSVWriter.cpp
   ReaderWriter/mitkConnectomicsNetworkMatrixWriter.cpp
   ReaderWriter/mitkConnectomicsNetworkSerializer.cpp
   ReaderWriter/mitkConnectomicsNetworkDefinitions.cpp
 
   ReaderWriter/mitkFiberBundleDicomReader.cpp
   ReaderWriter/mitkFiberBundleDicomWriter.cpp
   ReaderWriter/mitkFiberBundleTckReader.cpp
   ReaderWriter/mitkFiberBundleTrackVisReader.cpp
   ReaderWriter/mitkFiberBundleTrackVisWriter.cpp
   ReaderWriter/mitkFiberBundleVtkReader.cpp
   ReaderWriter/mitkFiberBundleVtkWriter.cpp
   ReaderWriter/mitkFiberBundleSerializer.cpp
 
   ReaderWriter/mitkTractographyForestReader.cpp
   ReaderWriter/mitkTractographyForestWriter.cpp
   ReaderWriter/mitkTractographyForestSerializer.cpp
 
   ReaderWriter/mitkPlanarFigureCompositeWriter.cpp
   ReaderWriter/mitkPlanarFigureCompositeReader.cpp
   ReaderWriter/mitkPlanarFigureCompositeSerializer.cpp
 
   ReaderWriter/mitkPeakImageReader.cpp
   ReaderWriter/mitkPeakImageSerializer.cpp
 
   ReaderWriter/mitkNrrdTensorImageReader.cpp
   ReaderWriter/mitkNrrdTensorImageWriter.cpp
   ReaderWriter/mitkTensorImageSerializer.cpp
 
   ReaderWriter/mitkNrrdOdfImageReader.cpp
   ReaderWriter/mitkNrrdOdfImageWriter.cpp
   ReaderWriter/mitkOdfImageSerializer.cpp
 
   ReaderWriter/mitkShImageReader.cpp
   ReaderWriter/mitkShImageWriter.cpp
   ReaderWriter/mitkShImageSerializer.cpp
 
-  ReaderWriter/mitkDiffusionImageDicomReaderService.cpp
-  ReaderWriter/mitkDiffusionImageNrrdReaderService.cpp
-  ReaderWriter/mitkDiffusionImageNrrdWriterService.cpp
-  ReaderWriter/mitkDiffusionImageNiftiReaderService.cpp
-  ReaderWriter/mitkDiffusionImageNiftiWriterService.cpp
+  ReaderWriter/mitkDiffusionImageDicomReader.cpp
+  ReaderWriter/mitkDiffusionImageNrrdReader.cpp
+  ReaderWriter/mitkDiffusionImageNrrdWriter.cpp
+  ReaderWriter/mitkDiffusionImageNiftiReader.cpp
+  ReaderWriter/mitkDiffusionImageNiftiWriter.cpp
 )
 
diff --git a/Modules/DiffusionIO/mitkDiffusionModuleActivator.cpp b/Modules/DiffusionIO/mitkDiffusionServiceActivator.cpp
similarity index 88%
rename from Modules/DiffusionIO/mitkDiffusionModuleActivator.cpp
rename to Modules/DiffusionIO/mitkDiffusionServiceActivator.cpp
index 363c92b..30a5824 100644
--- a/Modules/DiffusionIO/mitkDiffusionModuleActivator.cpp
+++ b/Modules/DiffusionIO/mitkDiffusionServiceActivator.cpp
@@ -1,204 +1,204 @@
 /*===================================================================
 
 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 <usModuleActivator.h>
 #include <usModuleContext.h>
 
 #include <mitkFiberBundleVtkReader.h>
 #include <mitkFiberBundleTckReader.h>
 #include <mitkFiberBundleTrackVisReader.h>
 #include <mitkConnectomicsNetworkReader.h>
 #include <mitkPlanarFigureCompositeReader.h>
 #include <mitkTractographyForestReader.h>
 #include <mitkFiberBundleDicomReader.h>
 
 #include <mitkFiberBundleVtkWriter.h>
 #include <mitkFiberBundleTrackVisWriter.h>
 #include <mitkFiberBundleDicomWriter.h>
 #include <mitkConnectomicsNetworkWriter.h>
 #include <mitkConnectomicsNetworkCSVWriter.h>
 #include <mitkConnectomicsNetworkMatrixWriter.h>
 #include <mitkPlanarFigureCompositeWriter.h>
 #include <mitkTractographyForestWriter.h>
 
-#include <mitkDiffusionImageNrrdReaderService.h>
-#include <mitkDiffusionImageNiftiReaderService.h>
-#include <mitkDiffusionImageDicomReaderService.h>
+#include <mitkDiffusionImageNrrdReader.h>
+#include <mitkDiffusionImageNiftiReader.h>
+#include <mitkDiffusionImageDicomReader.h>
 #include <mitkNrrdTensorImageReader.h>
 #include <mitkNrrdOdfImageReader.h>
 #include <mitkShImageReader.h>
 #include <mitkPeakImageReader.h>
 
-#include <mitkDiffusionImageNrrdWriterService.h>
-#include <mitkDiffusionImageNiftiWriterService.h>
+#include <mitkDiffusionImageNrrdWriter.h>
+#include <mitkDiffusionImageNiftiWriter.h>
 #include <mitkNrrdTensorImageWriter.h>
 #include <mitkNrrdOdfImageWriter.h>
 #include <mitkShImageWriter.h>
 
 #include <mitkDiffusionPropertyHelper.h>
 
 #include <mitkCoreServices.h>
 #include <mitkIPropertyDescriptions.h>
 #include <mitkIPropertyPersistence.h>
 
 #include "mitkDiffusionIOMimeTypes.h"
 
 namespace mitk
 {
   /**
   \brief Registers reader and writer services.
   */
-  class DiffusionModuleActivator : public us::ModuleActivator
+  class DiffusionServiceActivator : public us::ModuleActivator
   {
   public:
 
     void Load(us::ModuleContext* context) override
     {
       m_MimeTypes = mitk::DiffusionIOMimeTypes::Get();
       for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = m_MimeTypes.begin(),
         iterEnd = m_MimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
       {
         us::ServiceProperties props;
         mitk::CustomMimeType* mt = *mimeTypeIter;
         if (mt->GetName()==mitk::DiffusionIOMimeTypes::FIBERBUNDLE_VTK_MIMETYPE_NAME())
           props[ us::ServiceConstants::SERVICE_RANKING() ] = -1;
         else if (mt->GetName()==mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TRK_MIMETYPE_NAME())
           props[ us::ServiceConstants::SERVICE_RANKING() ] = -2;
         else if (mt->GetName()==mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TCK_MIMETYPE_NAME())
           props[ us::ServiceConstants::SERVICE_RANKING() ] = -3;
         else if (mt->GetName()==mitk::DiffusionIOMimeTypes::FIBERBUNDLE_DICOM_MIMETYPE_NAME())
           props[ us::ServiceConstants::SERVICE_RANKING() ] = -4;
         else
           props[ us::ServiceConstants::SERVICE_RANKING() ] = 10;
 
         context->RegisterService(*mimeTypeIter, props);
       }
 
       m_FiberBundleVtkReader = new FiberBundleVtkReader();
       m_FiberBundleVtkWriter = new FiberBundleVtkWriter();
       m_FiberBundleTrackVisReader = new FiberBundleTrackVisReader();
       m_FiberBundleTrackVisWriter = new FiberBundleTrackVisWriter();
       m_FiberBundleTckReader = new FiberBundleTckReader();
       m_FiberBundleDicomReader = new FiberBundleDicomReader();
       m_FiberBundleDicomWriter = new FiberBundleDicomWriter();
 
       m_ConnectomicsNetworkReader = new ConnectomicsNetworkReader();
       m_ConnectomicsNetworkWriter = new ConnectomicsNetworkWriter();
       m_ConnectomicsNetworkCSVWriter = new ConnectomicsNetworkCSVWriter();
       m_ConnectomicsNetworkMatrixWriter = new ConnectomicsNetworkMatrixWriter();
 
       m_PlanarFigureCompositeReader = new PlanarFigureCompositeReader();
       m_PlanarFigureCompositeWriter = new PlanarFigureCompositeWriter();
       m_TractographyForestReader = new TractographyForestReader();
       m_TractographyForestWriter = new TractographyForestWriter();
 
-      m_DiffusionImageNrrdReader = new DiffusionImageNrrdReaderService();
-      m_DiffusionImageNrrdWriter = new DiffusionImageNrrdWriterService();
+      m_DiffusionImageNrrdReader = new DiffusionImageNrrdReader();
+      m_DiffusionImageNrrdWriter = new DiffusionImageNrrdWriter();
 
-      m_DiffusionImageNiftiReader = new DiffusionImageNiftiReaderService();
-      m_DiffusionImageNiftiWriter = new DiffusionImageNiftiWriterService();
+      m_DiffusionImageNiftiReader = new DiffusionImageNiftiReader();
+      m_DiffusionImageNiftiWriter = new DiffusionImageNiftiWriter();
 
-      m_DiffusionImageDicomReader = new DiffusionImageDicomReaderService();
+      m_DiffusionImageDicomReader = new DiffusionImageDicomReader();
 
       m_NrrdTensorImageReader = new NrrdTensorImageReader();
       m_NrrdOdfImageReader = new NrrdOdfImageReader();
       m_PeakImageReader = new PeakImageReader();
       m_ShImageReader = new ShImageReader();
 
       m_NrrdTensorImageWriter = new NrrdTensorImageWriter();
       m_NrrdOdfImageWriter = new NrrdOdfImageWriter();
       m_ShImageWriter = new ShImageWriter();
 
       mitk::DiffusionPropertyHelper::SetupProperties();
     }
 
     void Unload(us::ModuleContext*) override
     {
       for (unsigned int loop(0); loop < m_MimeTypes.size(); ++loop)
       {
         delete m_MimeTypes.at(loop);
       }
 
       delete m_FiberBundleVtkReader;
       delete m_FiberBundleTckReader;
       delete m_FiberBundleTrackVisReader;
       delete m_ConnectomicsNetworkReader;
       delete m_PlanarFigureCompositeReader;
       delete m_TractographyForestReader;
       delete m_FiberBundleDicomReader;
 
       delete m_FiberBundleDicomWriter;
       delete m_FiberBundleVtkWriter;
       delete m_FiberBundleTrackVisWriter;
       delete m_ConnectomicsNetworkWriter;
       delete m_ConnectomicsNetworkCSVWriter;
       delete m_ConnectomicsNetworkMatrixWriter;
       delete m_PlanarFigureCompositeWriter;
       delete m_TractographyForestWriter;
 
       delete m_DiffusionImageNrrdReader;
       delete m_DiffusionImageNiftiReader;
       delete m_DiffusionImageDicomReader;
       delete m_NrrdTensorImageReader;
       delete m_NrrdOdfImageReader;
       delete m_PeakImageReader;
       delete m_ShImageReader;
 
       delete m_DiffusionImageNrrdWriter;
       delete m_DiffusionImageNiftiWriter;
       delete m_NrrdTensorImageWriter;
       delete m_NrrdOdfImageWriter;
       delete m_ShImageWriter;
     }
 
   private:
 
     FiberBundleVtkReader * m_FiberBundleVtkReader;
     FiberBundleTckReader * m_FiberBundleTckReader;
     FiberBundleTrackVisReader * m_FiberBundleTrackVisReader;
     FiberBundleDicomReader * m_FiberBundleDicomReader;
     ConnectomicsNetworkReader * m_ConnectomicsNetworkReader;
     PlanarFigureCompositeReader* m_PlanarFigureCompositeReader;
     TractographyForestReader* m_TractographyForestReader;
 
     FiberBundleDicomWriter * m_FiberBundleDicomWriter;
     FiberBundleVtkWriter * m_FiberBundleVtkWriter;
     FiberBundleTrackVisWriter * m_FiberBundleTrackVisWriter;
     ConnectomicsNetworkWriter * m_ConnectomicsNetworkWriter;
     ConnectomicsNetworkCSVWriter * m_ConnectomicsNetworkCSVWriter;
     ConnectomicsNetworkMatrixWriter * m_ConnectomicsNetworkMatrixWriter;
     PlanarFigureCompositeWriter* m_PlanarFigureCompositeWriter;
     TractographyForestWriter* m_TractographyForestWriter;
 
-    DiffusionImageNrrdReaderService * m_DiffusionImageNrrdReader;
-    DiffusionImageNiftiReaderService * m_DiffusionImageNiftiReader;
-    DiffusionImageDicomReaderService * m_DiffusionImageDicomReader;
+    DiffusionImageNrrdReader * m_DiffusionImageNrrdReader;
+    DiffusionImageNiftiReader * m_DiffusionImageNiftiReader;
+    DiffusionImageDicomReader * m_DiffusionImageDicomReader;
     NrrdTensorImageReader * m_NrrdTensorImageReader;
     NrrdOdfImageReader * m_NrrdOdfImageReader;
     PeakImageReader * m_PeakImageReader;
     ShImageReader * m_ShImageReader;
 
-    DiffusionImageNrrdWriterService * m_DiffusionImageNrrdWriter;
-    DiffusionImageNiftiWriterService * m_DiffusionImageNiftiWriter;
+    DiffusionImageNrrdWriter * m_DiffusionImageNrrdWriter;
+    DiffusionImageNiftiWriter * m_DiffusionImageNiftiWriter;
     NrrdTensorImageWriter * m_NrrdTensorImageWriter;
     NrrdOdfImageWriter * m_NrrdOdfImageWriter;
     ShImageWriter * m_ShImageWriter;
 
     std::vector<mitk::CustomMimeType*> m_MimeTypes;
 
   };
 }
 
-US_EXPORT_MODULE_ACTIVATOR(mitk::DiffusionModuleActivator)
+US_EXPORT_MODULE_ACTIVATOR(mitk::DiffusionServiceActivator)