diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index 5686192842..f3a9cf5840 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,39 +1,41 @@
 set(CPP_FILES
   mitkDiffusionModuleActivator.cpp
   mitkNrrdTbssImageWriterFactory.cpp
   #mitkFiberBundleXIOFactory.cpp
   mitkConnectomicsNetworkReader.cpp
   mitkConnectomicsNetworkWriter.cpp
   mitkConnectomicsNetworkSerializer.cpp
   mitkConnectomicsNetworkDefinitions.cpp
   mitkNrrdTbssRoiImageIOFactory.cpp
   #mitkFiberBundleXWriterFactory.cpp
   mitkNrrdTbssRoiImageWriterFactory.cpp
   mitkNrrdTensorImageReader.cpp
   mitkNrrdTensorImageWriter.cpp
   mitkTensorImageSerializer.cpp
   mitkTensorImageSource.cpp
   mitkFiberTrackingObjectFactory.cpp
   mitkConnectomicsObjectFactory.cpp
   mitkQuantificationObjectFactory.cpp
   mitkNrrdTbssImageIOFactory.cpp
   mitkDiffusionCoreObjectFactory.cpp
 
   mitkDiffusionIOMimeTypes.cpp
 
-  mitkNrrdDiffusionImageReader.cpp
-  mitkNrrdDiffusionImageWriter.cpp
+  mitkDiffusionImageNrrdReaderService.cpp
+  mitkDiffusionImageNrrdWriterService.cpp
+  mitkDiffusionImageNiftiReaderService.cpp
+  mitkDiffusionImageNiftiWriterService.cpp
 
   mitkNrrdQBallImageReader.cpp
   mitkNrrdQBallImageWriter.cpp
   mitkQBallImageSerializer.cpp
 
   mitkFiberBundleXReader.cpp
   mitkFiberBundleXWriter.cpp
   mitkFiberBundleXSerializer.cpp
   mitkFiberBundleXMapper2D.cpp
   mitkFiberBundleXMapper3D.cpp
   mitkCompositeMapper.cpp
 
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
index 9282a2e9d3..ac08e0bf2a 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
@@ -1,159 +1,157 @@
 /*===================================================================
 
 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 "mitkDiffusionCoreObjectFactory.h"
 
 #include "mitkProperties.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 
-#include "mitkNrrdDiffusionImageWriter.h"
-
 #include "mitkCompositeMapper.h"
 #include "mitkGPUVolumeMapper3D.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 
 
 typedef short DiffusionPixelType;
 
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionCoreObjectFactory::DiffusionCoreObjectFactory()
   : CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "DiffusionCoreObjectFactory c'tor" << std::endl;
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::DiffusionCoreObjectFactory::~DiffusionCoreObjectFactory()
 {
 
 }
 
 mitk::Mapper::Pointer mitk::DiffusionCoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
 
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
 
   return newMapper;
 }
 
 void mitk::DiffusionCoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   std::string classname = "QBallImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TensorImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
 }
 
 const char* mitk::DiffusionCoreObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionCoreObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::DiffusionCoreObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionCoreObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::DiffusionCoreObjectFactory::CreateFileExtensionsMap()
 {
 
 }
 
 struct RegisterDiffusionCoreObjectFactory{
   RegisterDiffusionCoreObjectFactory()
     : m_Factory( mitk::DiffusionCoreObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterDiffusionCoreObjectFactory()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::DiffusionCoreObjectFactory::Pointer m_Factory;
 };
 
 static RegisterDiffusionCoreObjectFactory registerDiffusionCoreObjectFactory;
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
index b841391c67..fda24fc676 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
@@ -1,259 +1,311 @@
 /*===================================================================
 
 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 "mitkDiffusionIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 #include <itksys/SystemTools.hxx>
 #include <itkNrrdImageIO.h>
 #include <itkMetaDataDictionary.h>
 #include <itkMetaDataObject.h>
 #include <mitkLogMacros.h>
 
 namespace mitk
 {
 
 std::vector<CustomMimeType*> DiffusionIOMimeTypes::Get()
 {
   std::vector<CustomMimeType*> mimeTypes;
 
   // order matters here (descending rank for mime types)
 
-  mimeTypes.push_back(DWI_MIMETYPE().Clone());
+  mimeTypes.push_back(DWI_NRRD_MIMETYPE().Clone());
+  mimeTypes.push_back(DWI_NIFTI_MIMETYPE().Clone());
   mimeTypes.push_back(DTI_MIMETYPE().Clone());
   mimeTypes.push_back(QBI_MIMETYPE().Clone());
 
   mimeTypes.push_back(FIBERBUNDLE_MIMETYPE().Clone());
 
   mimeTypes.push_back(CONNECTOMICS_MIMETYPE().Clone());
 
   return mimeTypes;
 }
 
 // Mime Types
 
 CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE()
 {
   CustomMimeType mimeType(FIBERBUNDLE_MIMETYPE_NAME());
   std::string category = "Fiber Bundle File";
   mimeType.SetComment("Fiber Bundles");
   mimeType.SetCategory(category);
   mimeType.AddExtension("fib");
   mimeType.AddExtension("trk");
   //mimeType.AddExtension("vtk");
   return mimeType;
 }
 
-DiffusionIOMimeTypes::DwiMimeType::DwiMimeType()
-  : CustomMimeType(DWI_MIMETYPE_NAME())
+DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::DiffusionImageNrrdMimeType()
+  : CustomMimeType(DWI_NRRD_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Image";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
 
   this->AddExtension("dwi");
   this->AddExtension("hdwi");
-  this->AddExtension("fsl");
-  this->AddExtension("fslgz");
   this->AddExtension("nrrd");
-  this->AddExtension("nii");
-  this->AddExtension("nii.gz");
 }
 
-bool DiffusionIOMimeTypes::DwiMimeType::AppliesTo(const std::string &path) const
+bool DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead( CustomMimeType::AppliesTo(path) );
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if( ! itksys::SystemTools::FileExists( path.c_str() ) )
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = this->GetExtension( path );
   ext = itksys::SystemTools::LowerCase( ext );
 
   // Simple NRRD files should only be considered for this mime type if they contain
   // corresponding tags
   if( ext == ".nrrd" )
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileName(path);
     try
     {
       io->ReadImageInformation();
 
       itk::MetaDataDictionary imgMetaDictionary = io->GetMetaDataDictionary();
       std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
       std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
       std::string metaString;
 
       for (; itKey != imgMetaKeys.end(); itKey ++)
       {
         itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
         if (itKey->find("modality") != std::string::npos)
         {
           if (metaString.find("DWMRI") != std::string::npos)
           {
             return canRead;
           }
         }
       }
 
     }
     catch( const itk::ExceptionObject &e )
     {
       MITK_ERROR << "ITK Exception: " << e.what();
     }
     canRead = false;
   }
 
+  return canRead;
+}
+
+DiffusionIOMimeTypes::DiffusionImageNrrdMimeType* DiffusionIOMimeTypes::DiffusionImageNrrdMimeType::Clone() const
+{
+  return new DiffusionImageNrrdMimeType(*this);
+}
+
+
+DiffusionIOMimeTypes::DiffusionImageNrrdMimeType DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE()
+{
+  return DiffusionImageNrrdMimeType();
+}
+
+DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::DiffusionImageNiftiMimeType()
+  : CustomMimeType(DWI_NIFTI_MIMETYPE_NAME())
+{
+  std::string category = "Diffusion Weighted Image";
+  this->SetCategory(category);
+  this->SetComment("Diffusion Weighted Images");
+  this->AddExtension("fsl");
+  this->AddExtension("fslgz");
+  this->AddExtension("nii");
+  this->AddExtension("nii.gz");
+}
+
+bool DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::AppliesTo(const std::string &path) const
+{
+  bool canRead(CustomMimeType::AppliesTo(path));
+
+  // fix for bug 18572
+  // Currently this function is called for writing as well as reading, in that case
+  // the image information can of course not be read
+  // This is a bug, this function should only be called for reading.
+  if (!itksys::SystemTools::FileExists(path.c_str()))
+  {
+    return canRead;
+  }
+  //end fix for bug 18572
+
+  std::string ext = this->GetExtension(path);
+  ext = itksys::SystemTools::LowerCase(ext);
+
   // Nifti files should only be considered for this mime type if they are
   // accompanied by bvecs and bvals files defining the diffusion information
-  if( ext == ".nii" || ext == ".nii.gz" )
+  if (ext == ".nii" || ext == ".nii.gz")
   {
-    std::string base = itksys::SystemTools::GetFilenamePath( path ) + "/"
-      + this->GetFilenameWithoutExtension( path );
+    std::string base = itksys::SystemTools::GetFilenamePath(path) + "/"
+      + this->GetFilenameWithoutExtension(path);
 
-    if( itksys::SystemTools::FileExists( std::string( base + ".bvec").c_str() )
-      && itksys::SystemTools::FileExists( std::string( base + ".bval").c_str() )
+    if (itksys::SystemTools::FileExists(std::string(base + ".bvec").c_str())
+      && itksys::SystemTools::FileExists(std::string(base + ".bval").c_str())
       )
     {
       return canRead;
     }
 
-    if( itksys::SystemTools::FileExists( std::string( base + ".bvecs").c_str() )
-      && itksys::SystemTools::FileExists( std::string( base + ".bvals").c_str() )
+    if (itksys::SystemTools::FileExists(std::string(base + ".bvecs").c_str())
+      && itksys::SystemTools::FileExists(std::string(base + ".bvals").c_str())
       )
     {
       return canRead;
     }
 
     canRead = false;
   }
 
   return canRead;
 }
 
-DiffusionIOMimeTypes::DwiMimeType* DiffusionIOMimeTypes::DwiMimeType::Clone() const
+DiffusionIOMimeTypes::DiffusionImageNiftiMimeType* DiffusionIOMimeTypes::DiffusionImageNiftiMimeType::Clone() const
 {
-  return new DwiMimeType(*this);
+  return new DiffusionImageNiftiMimeType(*this);
 }
 
 
-DiffusionIOMimeTypes::DwiMimeType DiffusionIOMimeTypes::DWI_MIMETYPE()
+DiffusionIOMimeTypes::DiffusionImageNiftiMimeType DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE()
 {
-  return DwiMimeType();
+  return DiffusionImageNiftiMimeType();
 }
 
 CustomMimeType DiffusionIOMimeTypes::DTI_MIMETYPE()
 {
   CustomMimeType mimeType(DTI_MIMETYPE_NAME());
   std::string category = "Tensor Images";
   mimeType.SetComment("Diffusion Tensor Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("dti");
   mimeType.AddExtension("hdti");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::QBI_MIMETYPE()
 {
   CustomMimeType mimeType(QBI_MIMETYPE_NAME());
   std::string category = "Q-Ball Images";
   mimeType.SetComment("Diffusion Q-Ball Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("qbi");
   mimeType.AddExtension("hqbi");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE()
 {
   CustomMimeType mimeType(CONNECTOMICS_MIMETYPE_NAME());
   std::string category = "Connectomics Networks";
   mimeType.SetComment("Connectomics Networks");
   mimeType.SetCategory(category);
   mimeType.AddExtension("cnf");
   return mimeType;
 }
 
 // Names
-std::string DiffusionIOMimeTypes::DWI_MIMETYPE_NAME()
+std::string DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
   return name;
 }
 
+std::string DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME()
+{
+  static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fsl";
+  return name;
+}
+
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dti";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".qbi";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fib";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".cnf";
   return name;
 }
 
 // Descriptions
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Fiberbundles";
   return description;
 }
 
-std::string DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION()
+std::string DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION()
+{
+  static std::string description = "Diffusion Weighted Images";
+  return description;
+}
+
+std::string DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Tensor Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Q-Ball Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Connectomics Networks";
   return description;
 }
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
index 5caa50bd8c..a58c35bfb6 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
@@ -1,81 +1,91 @@
 /*===================================================================
 
 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 MITKDIFFUSIONIOMIMETYPES_H
 #define MITKDIFFUSIONIOMIMETYPES_H
 
 #include "mitkCustomMimeType.h"
 #include <MitkDiffusionIOExports.h>
 
 #include <string>
 
 namespace mitk {
 
 class DiffusionIOMimeTypes
 {
 public:
 
-  class MitkDiffusionIO_EXPORT DwiMimeType : public CustomMimeType
+  class MitkDiffusionIO_EXPORT DiffusionImageNrrdMimeType : public CustomMimeType
   {
   public:
-    DwiMimeType();
+    DiffusionImageNrrdMimeType();
     virtual bool AppliesTo(const std::string &path) const;
-    virtual DwiMimeType* Clone() const;
+    virtual DiffusionImageNrrdMimeType* Clone() const;
   };
 
+  class MitkDiffusionIO_EXPORT DiffusionImageNiftiMimeType : public CustomMimeType
+  {
+  public:
+    DiffusionImageNiftiMimeType();
+    virtual bool AppliesTo(const std::string &path) const;
+    virtual DiffusionImageNiftiMimeType* Clone() const;
+  };
   // Get all Diffusion Mime Types
   static std::vector<CustomMimeType*> Get();
 
   // ------------------------------ VTK formats ----------------------------------
 
   static CustomMimeType FIBERBUNDLE_MIMETYPE(); // fib
 
   static std::string FIBERBUNDLE_MIMETYPE_NAME();
 
   static std::string FIBERBUNDLE_MIMETYPE_DESCRIPTION();
 
   // ------------------------- Image formats (ITK based) --------------------------
 
-  static DwiMimeType DWI_MIMETYPE(); // dwi, hdwi
+  static DiffusionImageNrrdMimeType DWI_NRRD_MIMETYPE();
+  static DiffusionImageNiftiMimeType DWI_NIFTI_MIMETYPE();
   static CustomMimeType DTI_MIMETYPE(); // dti, hdti
   static CustomMimeType QBI_MIMETYPE(); // qbi, hqbi
 
-  static std::string DWI_MIMETYPE_NAME();
+  static std::string DWI_NRRD_MIMETYPE_NAME();
+  static std::string DWI_NIFTI_MIMETYPE_NAME();
   static std::string DTI_MIMETYPE_NAME();
   static std::string QBI_MIMETYPE_NAME();
 
-  static std::string DWI_MIMETYPE_DESCRIPTION();
+  static std::string DWI_NRRD_MIMETYPE_DESCRIPTION();
+  static std::string DWI_NIFTI_MIMETYPE_DESCRIPTION();
   static std::string DTI_MIMETYPE_DESCRIPTION();
   static std::string QBI_MIMETYPE_DESCRIPTION();
 
   // ------------------------------ MITK formats ----------------------------------
 
   static CustomMimeType CONNECTOMICS_MIMETYPE(); // cnf
 
   static std::string CONNECTOMICS_MIMETYPE_NAME();
 
   static std::string CONNECTOMICS_MIMETYPE_DESCRIPTION();
 
 private:
 
   // purposely not implemented
   DiffusionIOMimeTypes();
   DiffusionIOMimeTypes(const DiffusionIOMimeTypes&);
 };
 
 }
 
 #endif // MITKDIFFUSIONIOMIMETYPES_H
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiReaderService.cpp
similarity index 77%
rename from Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiReaderService.cpp
index ed1c1db483..35b0ed2f36 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiReaderService.cpp
@@ -1,549 +1,459 @@
 /*===================================================================
 
 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 __mitkNrrdDiffusionImageReader_cpp
-#define __mitkNrrdDiffusionImageReader_cpp
+#ifndef __mitkDiffusionImageNiftiReaderService_cpp
+#define __mitkDiffusionImageNiftiReaderService_cpp
 
-#include "mitkNrrdDiffusionImageReader.h"
+#include "mitkDiffusionImageNiftiReaderService.h"
 
 #include <iostream>
 #include <fstream>
 
 
 // Diffusion properties
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <mitkProperties.h>
 
 // ITK includes
 #include <itkImageRegionIterator.h>
 #include <itkMetaDataObject.h>
 #include "itksys/SystemTools.hxx"
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
-#include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkDiffusionIOMimeTypes.h"
 
 #include <mitkITKImageImport.h>
 #include <mitkItkImageFileReader.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageDataItem.h>
 #include "mitkIOUtil.h"
 
 
 namespace mitk
 {
 
-  NrrdDiffusionImageReader::
-  NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other)
+  DiffusionImageNiftiReaderService::
+  DiffusionImageNiftiReaderService(const DiffusionImageNiftiReaderService & other)
     : AbstractFileReader(other)
   {
   }
 
 
-  NrrdDiffusionImageReader* NrrdDiffusionImageReader::Clone() const
+  DiffusionImageNiftiReaderService* DiffusionImageNiftiReaderService::Clone() const
   {
-    return new NrrdDiffusionImageReader(*this);
+    return new DiffusionImageNiftiReaderService(*this);
   }
 
 
-  NrrdDiffusionImageReader::
-  ~NrrdDiffusionImageReader()
+  DiffusionImageNiftiReaderService::
+  ~DiffusionImageNiftiReaderService()
   {}
 
-  NrrdDiffusionImageReader::
-  NrrdDiffusionImageReader()
-    : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION() )
+  DiffusionImageNiftiReaderService::
+  DiffusionImageNiftiReaderService()
+    : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION() )
   {
     m_ServiceReg = this->RegisterService();
   }
 
   std::vector<itk::SmartPointer<mitk::BaseData> >
-  NrrdDiffusionImageReader::
+  DiffusionImageNiftiReaderService::
   Read()
   {
     std::vector<itk::SmartPointer<mitk::BaseData> > result;
 
     // Since everything is completely read in GenerateOutputInformation() it is stored
     // in a cache variable. A timestamp is associated.
     // If the timestamp of the cache variable is newer than the MTime, we only need to
     // assign the cache variable to the DataObject.
     // Otherwise, the tree must be read again from the file and OuputInformation must
     // be updated!
 
     if(m_OutputCache.IsNull()) InternalRead();
 
     result.push_back(m_OutputCache.GetPointer());
     return result;
   }
 
 
-  void NrrdDiffusionImageReader::InternalRead()
+  void DiffusionImageNiftiReaderService::InternalRead()
   {
     OutputType::Pointer outputForCache = OutputType::New();
     if ( this->GetInputLocation() == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
     }
     else
     {
       try
       {
         const std::string& locale = "C";
         const std::string& currLocale = setlocale( LC_ALL, NULL );
 
         if ( locale.compare(currLocale)!=0 )
         {
           try
           {
             setlocale(LC_ALL, locale.c_str());
           }
           catch(...)
           {
             MITK_INFO << "Could not set locale " << locale;
           }
         }
 
 
-        MITK_INFO << "NrrdDiffusionImageReader: reading image information";
+        MITK_INFO << "DiffusionImageNiftiReaderService: 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();
-        }
-        else if(ext == ".fsl" || ext == ".fslgz")
+        if(ext == ".fsl" || ext == ".fslgz")
         {
           // create temporary file with correct ending for nifti-io
           std::string fname3 = "temp_dwi";
           fname3 += ext == ".fsl" ? ".nii" : ".nii.gz";
           itksys::SystemTools::CopyAFile(this->GetInputLocation().c_str(), fname3.c_str());
 
           // create reader and read file
           typedef itk::Image<DiffusionPixelType,4> ImageType4D;
           itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
           typedef itk::ImageFileReader<ImageType4D> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetFileName(fname3);
           reader->SetImageIO(io2);
           reader->Update();
           ImageType4D::Pointer img4 = reader->GetOutput();
 
           // delete temporary file
           itksys::SystemTools::RemoveFile(fname3.c_str());
 
           // convert 4D file to vector image
           itkVectorImage = VectorImageType::New();
 
           VectorImageType::SpacingType spacing;
           ImageType4D::SpacingType spacing4 = img4->GetSpacing();
           for(int i=0; i<3; i++)
             spacing[i] = spacing4[i];
           itkVectorImage->SetSpacing( spacing );   // Set the image spacing
 
           VectorImageType::PointType origin;
           ImageType4D::PointType origin4 = img4->GetOrigin();
           for(int i=0; i<3; i++)
             origin[i] = origin4[i];
           itkVectorImage->SetOrigin( origin );     // Set the image origin
 
           VectorImageType::DirectionType direction;
           ImageType4D::DirectionType direction4 = img4->GetDirection();
           for(int i=0; i<3; i++)
             for(int j=0; j<3; j++)
               direction[i][j] = direction4[i][j];
           itkVectorImage->SetDirection( direction );  // Set the image direction
 
           VectorImageType::RegionType region;
           ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
 
           VectorImageType::RegionType::SizeType size;
           ImageType4D::RegionType::SizeType size4 = region4.GetSize();
 
           for(int i=0; i<3; i++)
             size[i] = size4[i];
 
           VectorImageType::RegionType::IndexType index;
           ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
           for(int i=0; i<3; i++)
             index[i] = index4[i];
 
           region.SetSize(size);
           region.SetIndex(index);
           itkVectorImage->SetRegions( region );
 
           itkVectorImage->SetVectorLength(size4[3]);
           itkVectorImage->Allocate();
 
           itk::ImageRegionIterator<VectorImageType>   it ( itkVectorImage,  itkVectorImage->GetLargestPossibleRegion() );
           typedef VectorImageType::PixelType VecPixType;
           for (it.GoToBegin(); !it.IsAtEnd(); ++it)
           {
             VecPixType vec = it.Get();
             VectorImageType::IndexType currentIndex = it.GetIndex();
             for(int i=0; i<3; i++)
               index4[i] = currentIndex[i];
             for(unsigned int ind=0; ind<vec.Size(); ind++)
             {
               index4[3] = ind;
               vec[ind] = img4->GetPixel(index4);
             }
             it.Set(vec);
           }
         }
         else if(ext == ".nii" || ext == ".nii.gz")
         {
           // create reader and read file
           typedef itk::Image<DiffusionPixelType,4> ImageType4D;
           itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
           typedef itk::ImageFileReader<ImageType4D> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetFileName( this->GetInputLocation() );
           reader->SetImageIO(io2);
           reader->Update();
           ImageType4D::Pointer img4 = reader->GetOutput();
 
 
           // convert 4D file to vector image
           itkVectorImage = VectorImageType::New();
 
           VectorImageType::SpacingType spacing;
           ImageType4D::SpacingType spacing4 = img4->GetSpacing();
           for(int i=0; i<3; i++)
             spacing[i] = spacing4[i];
           itkVectorImage->SetSpacing( spacing );   // Set the image spacing
 
           VectorImageType::PointType origin;
           ImageType4D::PointType origin4 = img4->GetOrigin();
           for(int i=0; i<3; i++)
             origin[i] = origin4[i];
           itkVectorImage->SetOrigin( origin );     // Set the image origin
 
           VectorImageType::DirectionType direction;
           ImageType4D::DirectionType direction4 = img4->GetDirection();
           for(int i=0; i<3; i++)
             for(int j=0; j<3; j++)
               direction[i][j] = direction4[i][j];
           itkVectorImage->SetDirection( direction );  // Set the image direction
 
           VectorImageType::RegionType region;
           ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
 
           VectorImageType::RegionType::SizeType size;
           ImageType4D::RegionType::SizeType size4 = region4.GetSize();
 
           for(int i=0; i<3; i++)
             size[i] = size4[i];
 
           VectorImageType::RegionType::IndexType index;
           ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
           for(int i=0; i<3; i++)
             index[i] = index4[i];
 
           region.SetSize(size);
           region.SetIndex(index);
           itkVectorImage->SetRegions( region );
 
           itkVectorImage->SetVectorLength(size4[3]);
           itkVectorImage->Allocate();
 
           itk::ImageRegionIterator<VectorImageType>   it ( itkVectorImage,  itkVectorImage->GetLargestPossibleRegion() );
           typedef VectorImageType::PixelType VecPixType;
           for (it.GoToBegin(); !it.IsAtEnd(); ++it)
           {
             VecPixType vec = it.Get();
             VectorImageType::IndexType currentIndex = it.GetIndex();
             for(int i=0; i<3; i++)
               index4[i] = currentIndex[i];
             for(unsigned int ind=0; ind<vec.Size(); ind++)
             {
               index4[3] = ind;
               vec[ind] = img4->GetPixel(index4);
             }
             it.Set(vec);
           }
         }
 
         // Diffusion Image information START
         GradientDirectionContainerType::Pointer DiffusionVectors = GradientDirectionContainerType::New();
         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";
-          }
-
-        }
-        else if(ext == ".fsl" || ext == ".fslgz" || ext == ".nii" || ext == ".nii.gz")
+        if(ext == ".fsl" || ext == ".fslgz" || ext == ".nii" || ext == ".nii.gz")
         {
           // some parsing depending on the extension
           bool useFSLstyle( true );
           std::string bvecsExtension("");
           std::string bvalsExtension("");
 
           std::string base = itksys::SystemTools::GetFilenamePath( this->GetInputLocation() ) + "/"
             + this->GetMimeType()->GetFilenameWithoutExtension( this->GetInputLocation() );
 
           // check for possible file names
           {
             if( useFSLstyle && itksys::SystemTools::FileExists( std::string( base + ".bvec").c_str() )
               && itksys::SystemTools::FileExists( std::string( base + ".bval").c_str() )
               )
             {
               useFSLstyle = false;
               bvecsExtension = ".bvec";
               bvalsExtension = ".bval";
             }
 
             if( useFSLstyle && itksys::SystemTools::FileExists( std::string( base + ".bvecs").c_str() )
               && itksys::SystemTools::FileExists( std::string( base + ".bvals").c_str() )
               )
             {
               useFSLstyle = false;
               bvecsExtension = ".bvecs";
               bvalsExtension = ".bvals";
             }
           }
 
           std::string line;
           std::vector<float> bvec_entries;
           std::string fname = this->GetInputLocation();
           if( useFSLstyle )
           {
             fname += ".bvecs";
           }
           else
           {
             fname = std::string( base + bvecsExtension);
           }
           std::ifstream myfile (fname.c_str());
           if (myfile.is_open())
           {
             while ( myfile.good() )
             {
               getline (myfile,line);
               char* pch = strtok (const_cast<char*>(line.c_str())," ");
               while (pch != NULL)
               {
                 bvec_entries.push_back(atof(pch));
                 pch = strtok (NULL, " ");
               }
             }
             myfile.close();
           }
           else
           {
             MITK_INFO << "Unable to open bvecs file";
           }
 
           std::vector<float> bval_entries;
           std::string fname2 = this->GetInputLocation();
           if( useFSLstyle )
           {
             fname2 += ".bvals";
           }
           else
           {
             fname2 = std::string( base + bvalsExtension);
           }
           std::ifstream myfile2 (fname2.c_str());
           if (myfile2.is_open())
           {
             while ( myfile2.good() )
             {
               getline (myfile2,line);
               char* pch = strtok (const_cast<char*>(line.c_str())," ");
               while (pch != NULL)
               {
                 bval_entries.push_back(atof(pch));
                 pch = strtok (NULL, " ");
               }
             }
             myfile2.close();
           }
           else
           {
             MITK_INFO << "Unable to open bvals file";
           }
 
 
           BValue = -1;
           unsigned int numb = bval_entries.size();
           for(unsigned int i=0; i<numb; i++)
           {
 
             // Take the first entry in bvals as the reference b-value
             if(BValue == -1 && bval_entries.at(i) != 0)
             {
               BValue = bval_entries.at(i);
             }
 
             float b_val = bval_entries.at(i);
 
 
             vnl_vector_fixed< double, 3 > vec;
             vec[0] = bvec_entries.at(i);
             vec[1] = bvec_entries.at(i+numb);
             vec[2] = bvec_entries.at(i+2*numb);
 
             // Adjust the vector length to encode gradient strength
             float factor = b_val/BValue;
             if(vec.magnitude() > 0)
             {
               vec[0] = sqrt(factor)*vec[0];
               vec[1] = sqrt(factor)*vec[1];
               vec[2] = sqrt(factor)*vec[2];
             }
 
             DiffusionVectors->InsertElement(i,vec);
           }
 
           for(int i=0; i<3; i++)
             for(int j=0; j<3; j++)
               MeasurementFrame[i][j] = i==j ? 1 : 0;
         }
 
         outputForCache = mitk::GrabItkImageMemory( itkVectorImage);
 
         // create BValueMap
         mitk::BValueMapProperty::BValueMap BValueMap = mitk::BValueMapProperty::CreateBValueMap(DiffusionVectors,BValue);
         outputForCache->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( DiffusionVectors ) );
         outputForCache->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( OriginalDiffusionVectors ) );
         outputForCache->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( MeasurementFrame ) );
         outputForCache->SetProperty( mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(), mitk::BValueMapProperty::New( BValueMap ) );
         outputForCache->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( BValue ) );
 
 
         // 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)
       {
         MITK_INFO << "Std::Exception while reading file!!";
         MITK_INFO << e.what();
         throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         MITK_INFO << "Exception while reading file!!";
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
       }
     }
   }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiReaderService.h
similarity index 78%
copy from Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiReaderService.h
index ac1fb1d29c..864dc67ee2 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiReaderService.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 __mitkNrrdDiffusionImageReader_h
-#define __mitkNrrdDiffusionImageReader_h
+#ifndef __mitkDiffusionImageNiftiReaderService_h
+#define __mitkDiffusionImageNiftiReaderService_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 NrrdDiffusionImageReader : public mitk::AbstractFileReader
+  class DiffusionImageNiftiReaderService : public mitk::AbstractFileReader
   {
   public:
 
-    NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other);
-    NrrdDiffusionImageReader();
-    virtual ~NrrdDiffusionImageReader();
+    DiffusionImageNiftiReaderService(const DiffusionImageNiftiReaderService & other);
+    DiffusionImageNiftiReaderService();
+    virtual ~DiffusionImageNiftiReaderService();
 
     using AbstractFileReader::Read;
     virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
     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:
 
-    NrrdDiffusionImageReader* Clone() const;
+    DiffusionImageNiftiReaderService* Clone() const;
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkNrrdDiffusionImageReader_h
+#endif // __mitkDiffusionImageNiftiReaderService_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiWriterService.cpp
similarity index 88%
rename from Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
rename to Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiWriterService.cpp
index 09272b6ca1..abda78b674 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiWriterService.cpp
@@ -1,473 +1,443 @@
 /*===================================================================
 
 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 __mitkNrrdDiffusionImageWriter__cpp
-#define __mitkNrrdDiffusionImageWriter__cpp
+#ifndef __mitkDiffusionImageNiftiWriterService__cpp
+#define __mitkDiffusionImageNiftiWriterService__cpp
 
-#include "mitkNrrdDiffusionImageWriter.h"
+#include "mitkDiffusionImageNiftiWriterService.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
-#include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionIOMimeTypes.h"
 #include "mitkImageCast.h"
 
 #include <iostream>
 #include <fstream>
 
 
-mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter()
-  : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
+mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService()
+  : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
-mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter(const mitk::NrrdDiffusionImageWriter& other)
+mitk::DiffusionImageNiftiWriterService::DiffusionImageNiftiWriterService(const mitk::DiffusionImageNiftiWriterService& other)
   : AbstractFileWriter(other)
 {
 }
 
-mitk::NrrdDiffusionImageWriter::~NrrdDiffusionImageWriter()
+mitk::DiffusionImageNiftiWriterService::~DiffusionImageNiftiWriterService()
 {}
 
-void mitk::NrrdDiffusionImageWriter::Write()
+void mitk::DiffusionImageNiftiWriterService::Write()
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
 
   VectorImageType::Pointer itkImg;
   mitk::CastToItkImage(input,itkImg);
 
   if (input.IsNull())
   {
-    MITK_ERROR <<"Sorry, input to NrrdDiffusionImageWriter is NULL!";
+    MITK_ERROR <<"Sorry, input to DiffusionImageNiftiWriterService is NULL!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   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 .dwi
+  // default extension is .nii
   if( ext == "")
   {
-    ext = ".nrrd";
+    ext = ".nii";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
-
-  if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
-  {
-
-    MITK_INFO << "Extension " << ext;
-    itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
-    //io->SetNrrdVectorType( nrrdKindList );
-    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 (itk::ExceptionObject e)
-    {
-      std::cout << e << std::endl;
-      throw;
-    }
-
-  }
-  else if (ext == ".fsl" || ext == ".fslgz")
+  if (ext == ".fsl" || ext == ".fslgz")
   {
     MITK_INFO << "Writing Nifti-Image for FSL";
 
     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]);
       }
     }
 
     // create copy of file with correct ending for mitk
     std::string fname3 = this->GetOutputLocation();
     std::string::iterator itend = fname3.end();
     if (ext == ".fsl")
       fname3.replace( itend-3, itend, "nii");
     else
       fname3.replace( itend-5, itend, "nii.gz");
 
     itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
 
     typedef itk::VectorImage<short,3> ImageType;
     typedef itk::ImageFileWriter<ImageType4D> WriterType4;
     WriterType4::Pointer nrrdWriter4 = WriterType4::New();
     nrrdWriter4->UseInputMetaDataDictionaryOn();
     nrrdWriter4->SetInput( img4 );
     nrrdWriter4->SetFileName(fname3);
     nrrdWriter4->UseCompressionOn();
     nrrdWriter4->SetImageIO(io4);
     try
     {
       nrrdWriter4->Update();
     }
     catch (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
     itksys::SystemTools::CopyAFile(fname3.c_str(), this->GetOutputLocation().c_str());
 
     if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       std::ofstream myfile;
       std::string fname = this->GetOutputLocation();
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = this->GetOutputLocation();
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
 
       std::ofstream myfile3;
       std::string fname4 = this->GetOutputLocation();
       fname4 += ".ttk";
       myfile3.open (fname4.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         for(int j=0; j<3; j++)
         {
           myfile3 << mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(j) << " ";
         }
         myfile3 << std::endl;
       }
     }
   }
   else 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::VectorImage<short,3> ImageType;
     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 (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
 
     if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       std::ofstream myfile;
       std::string fname = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname += ".bvals";
       myfile.open (fname.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
         myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
         for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
           GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
           GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
 
       std::ofstream myfile3;
       std::string fname4 = itksys::SystemTools::GetFilenamePath( this->GetOutputLocation() ) + "/"
         + this->GetMimeType()->GetFilenameWithoutExtension( this->GetOutputLocation() );
       fname4 += ".ttk";
       myfile3.open (fname4.c_str());
       for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         for(int j=0; j<3; j++)
         {
           myfile3 << mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(j) << " ";
         }
         myfile3 << std::endl;
       }
     }
   }
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
-mitk::NrrdDiffusionImageWriter* mitk::NrrdDiffusionImageWriter::Clone() const
+mitk::DiffusionImageNiftiWriterService* mitk::DiffusionImageNiftiWriterService::Clone() const
 {
-  return new NrrdDiffusionImageWriter(*this);
+  return new DiffusionImageNiftiWriterService(*this);
 }
 
-mitk::IFileWriter::ConfidenceLevel mitk::NrrdDiffusionImageWriter::GetConfidenceLevel() const
+mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNiftiWriterService::GetConfidenceLevel() const
 {
   mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
-#endif //__mitkNrrdDiffusionImageWriter__cpp
+#endif //__mitkDiffusionImageNiftiWriterService__cpp
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiWriterService.h
similarity index 75%
copy from Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiWriterService.h
index 1bedf714ce..a57e4f3854 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNiftiWriterService.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_NRRDDIFFVOL_WRITER__H_
-#define _MITK_NRRDDIFFVOL_WRITER__H_
+#ifndef _MITK_DiffusionImageNiftiWriterService__H_
+#define _MITK_DiffusionImageNiftiWriterService__H_
 
 #include <mitkAbstractFileWriter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
-class NrrdDiffusionImageWriter : public mitk::AbstractFileWriter
+class DiffusionImageNiftiWriterService : public mitk::AbstractFileWriter
 {
 public:
 
-    NrrdDiffusionImageWriter();
-    virtual ~NrrdDiffusionImageWriter();
+    DiffusionImageNiftiWriterService();
+    virtual ~DiffusionImageNiftiWriterService();
 
     using AbstractFileWriter::Write;
     virtual void Write();
 
     virtual ConfidenceLevel GetConfidenceLevel() const;
 
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
 
-    NrrdDiffusionImageWriter(const NrrdDiffusionImageWriter& other);
-    virtual mitk::NrrdDiffusionImageWriter* Clone() const;
+    DiffusionImageNiftiWriterService(const DiffusionImageNiftiWriterService& other);
+    virtual mitk::DiffusionImageNiftiWriterService* Clone() const;
 
 
 };
 
 
 } // end of namespace mitk
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdReaderService.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdReaderService.cpp
new file mode 100644
index 0000000000..c7c9931f52
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdReaderService.cpp
@@ -0,0 +1,269 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __mitkDiffusionImageNrrdReaderService_cpp
+#define __mitkDiffusionImageNrrdReaderService_cpp
+
+#include "mitkDiffusionImageNrrdReaderService.h"
+
+#include <iostream>
+#include <fstream>
+
+
+// Diffusion properties
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+#include <mitkProperties.h>
+
+// ITK includes
+#include <itkImageRegionIterator.h>
+#include <itkMetaDataObject.h>
+#include "itksys/SystemTools.hxx"
+#include "itkImageFileReader.h"
+#include "itkMetaDataObject.h"
+#include "itkNrrdImageIO.h"
+
+#include "mitkCustomMimeType.h"
+#include "mitkDiffusionIOMimeTypes.h"
+
+#include <mitkITKImageImport.h>
+#include <mitkItkImageFileReader.h>
+#include <mitkImageWriteAccessor.h>
+#include <mitkImageDataItem.h>
+#include "mitkIOUtil.h"
+
+
+namespace mitk
+{
+
+  DiffusionImageNrrdReaderService::
+  DiffusionImageNrrdReaderService(const DiffusionImageNrrdReaderService & other)
+    : AbstractFileReader(other)
+  {
+  }
+
+
+  DiffusionImageNrrdReaderService* DiffusionImageNrrdReaderService::Clone() const
+  {
+    return new DiffusionImageNrrdReaderService(*this);
+  }
+
+
+  DiffusionImageNrrdReaderService::
+  ~DiffusionImageNrrdReaderService()
+  {}
+
+  DiffusionImageNrrdReaderService::
+  DiffusionImageNrrdReaderService()
+    : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION() )
+  {
+    m_ServiceReg = this->RegisterService();
+  }
+
+  std::vector<itk::SmartPointer<mitk::BaseData> >
+  DiffusionImageNrrdReaderService::
+  Read()
+  {
+    std::vector<itk::SmartPointer<mitk::BaseData> > result;
+
+    // Since everything is completely read in GenerateOutputInformation() it is stored
+    // in a cache variable. A timestamp is associated.
+    // If the timestamp of the cache variable is newer than the MTime, we only need to
+    // assign the cache variable to the DataObject.
+    // Otherwise, the tree must be read again from the file and OuputInformation must
+    // be updated!
+
+    if(m_OutputCache.IsNull()) InternalRead();
+
+    result.push_back(m_OutputCache.GetPointer());
+    return result;
+  }
+
+
+  void DiffusionImageNrrdReaderService::InternalRead()
+  {
+    OutputType::Pointer outputForCache = OutputType::New();
+    if ( this->GetInputLocation() == "")
+    {
+      throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
+    }
+    else
+    {
+      try
+      {
+        const std::string& locale = "C";
+        const std::string& currLocale = setlocale( LC_ALL, NULL );
+
+        if ( locale.compare(currLocale)!=0 )
+        {
+          try
+          {
+            setlocale(LC_ALL, locale.c_str());
+          }
+          catch(...)
+          {
+            MITK_INFO << "Could not set locale " << locale;
+          }
+        }
+
+
+        MITK_INFO << "DiffusionImageNrrdReaderService: reading image information";
+        VectorImageType::Pointer itkVectorImage;
+
+        std::string ext = this->GetMimeType()->GetExtension( this->GetInputLocation() );
+        ext = itksys::SystemTools::LowerCase( ext );
+
+        if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
+        {
+          typedef itk::ImageFileReader<VectorImageType> FileReaderType;
+          FileReaderType::Pointer reader = FileReaderType::New();
+          reader->SetFileName(this->GetInputLocation());
+          itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+          reader->SetImageIO(io);
+          reader->Update();
+          itkVectorImage = reader->GetOutput();
+        }
+
+        // Diffusion Image information START
+        GradientDirectionContainerType::Pointer DiffusionVectors = GradientDirectionContainerType::New();
+        GradientDirectionContainerType::Pointer OriginalDiffusionVectors = GradientDirectionContainerType::New();
+        MeasurementFrameType MeasurementFrame;
+        float BValue = -1;
+        // Diffusion Image information END
+
+        if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
+        {
+
+          itk::MetaDataDictionary imgMetaDictionary =  itkVectorImage->GetMetaDataDictionary();
+          std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+          std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+          std::string metaString;
+
+          GradientDirectionType vect3d;
+
+          int numberOfImages = 0;
+          int numberOfGradientImages = 0;
+          bool readb0 = false;
+          double xx, xy, xz, yx, yy, yz, zx, zy, zz;
+
+          for (; itKey != imgMetaKeys.end(); itKey ++)
+          {
+            double x,y,z;
+
+            itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+            if (itKey->find("DWMRI_gradient") != std::string::npos)
+            {
+              sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
+              vect3d[0] = x; vect3d[1] = y; vect3d[2] = z;
+              DiffusionVectors->InsertElement( numberOfImages, vect3d );
+              ++numberOfImages;
+              // If the direction is 0.0, this is a reference image
+              if (vect3d[0] == 0.0 &&
+                  vect3d[1] == 0.0 &&
+                  vect3d[2] == 0.0)
+              {
+                continue;
+              }
+              ++numberOfGradientImages;;
+            }
+            else if (itKey->find("DWMRI_b-value") != std::string::npos)
+            {
+              readb0 = true;
+              BValue = atof(metaString.c_str());
+            }
+            else if (itKey->find("measurement frame") != std::string::npos)
+            {
+              sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
+
+              if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
+                  yx>10e-10 || yy>10e-10 || yz>10e-10 ||
+                  zx>10e-10 || zy>10e-10 || zz>10e-10 )
+              {
+                MeasurementFrame(0,0) = xx;
+                MeasurementFrame(0,1) = xy;
+                MeasurementFrame(0,2) = xz;
+                MeasurementFrame(1,0) = yx;
+                MeasurementFrame(1,1) = yy;
+                MeasurementFrame(1,2) = yz;
+                MeasurementFrame(2,0) = zx;
+                MeasurementFrame(2,1) = zy;
+                MeasurementFrame(2,2) = zz;
+              }
+              else
+              {
+                MeasurementFrame(0,0) = 1;
+                MeasurementFrame(0,1) = 0;
+                MeasurementFrame(0,2) = 0;
+                MeasurementFrame(1,0) = 0;
+                MeasurementFrame(1,1) = 1;
+                MeasurementFrame(1,2) = 0;
+                MeasurementFrame(2,0) = 0;
+                MeasurementFrame(2,1) = 0;
+                MeasurementFrame(2,2) = 1;
+              }
+            }
+          }
+
+          if(!readb0)
+          {
+            MITK_INFO << "BValue not specified in header file";
+          }
+
+        }
+
+        outputForCache = mitk::GrabItkImageMemory( itkVectorImage);
+
+        // create BValueMap
+        mitk::BValueMapProperty::BValueMap BValueMap = mitk::BValueMapProperty::CreateBValueMap(DiffusionVectors,BValue);
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( DiffusionVectors ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( OriginalDiffusionVectors ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( MeasurementFrame ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(), mitk::BValueMapProperty::New( BValueMap ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( BValue ) );
+
+
+        // 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)
+      {
+        MITK_INFO << "Std::Exception while reading file!!";
+        MITK_INFO << e.what();
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
+      }
+      catch(...)
+      {
+        MITK_INFO << "Exception while reading file!!";
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
+      }
+    }
+  }
+
+} //namespace MITK
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdReaderService.h
similarity index 79%
rename from Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdReaderService.h
index ac1fb1d29c..357b1b038a 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdReaderService.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 __mitkNrrdDiffusionImageReader_h
-#define __mitkNrrdDiffusionImageReader_h
+#ifndef __mitkDiffusionImageNrrdReaderService_h
+#define __mitkDiffusionImageNrrdReaderService_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 NrrdDiffusionImageReader : public mitk::AbstractFileReader
+  class DiffusionImageNrrdReaderService : public mitk::AbstractFileReader
   {
   public:
 
-    NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other);
-    NrrdDiffusionImageReader();
-    virtual ~NrrdDiffusionImageReader();
+    DiffusionImageNrrdReaderService(const DiffusionImageNrrdReaderService & other);
+    DiffusionImageNrrdReaderService();
+    virtual ~DiffusionImageNrrdReaderService();
 
     using AbstractFileReader::Read;
     virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
     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:
 
-    NrrdDiffusionImageReader* Clone() const;
+    DiffusionImageNrrdReaderService* Clone() const;
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-#endif // __mitkNrrdDiffusionImageReader_h
+#endif // __mitkDiffusionImageNrrdReaderService_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdWriterService.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdWriterService.cpp
new file mode 100644
index 0000000000..556ade866b
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdWriterService.cpp
@@ -0,0 +1,185 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef __mitkDiffusionImageNrrdWriterService__cpp
+#define __mitkDiffusionImageNrrdWriterService__cpp
+
+#include "mitkDiffusionImageNrrdWriterService.h"
+#include "itkMetaDataDictionary.h"
+#include "itkMetaDataObject.h"
+#include "itkNrrdImageIO.h"
+#include "itkImageFileWriter.h"
+#include "itksys/SystemTools.hxx"
+#include "mitkDiffusionIOMimeTypes.h"
+#include "mitkImageCast.h"
+
+#include <iostream>
+#include <fstream>
+
+
+mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService()
+  : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE() ), mitk::DiffusionIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION())
+{
+  RegisterService();
+}
+
+mitk::DiffusionImageNrrdWriterService::DiffusionImageNrrdWriterService(const mitk::DiffusionImageNrrdWriterService& other)
+  : AbstractFileWriter(other)
+{
+}
+
+mitk::DiffusionImageNrrdWriterService::~DiffusionImageNrrdWriterService()
+{}
+
+void mitk::DiffusionImageNrrdWriterService::Write()
+{
+  mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
+
+  VectorImageType::Pointer itkImg;
+  mitk::CastToItkImage(input,itkImg);
+
+  if (input.IsNull())
+  {
+    MITK_ERROR <<"Sorry, input to DiffusionImageNrrdWriterService is NULL!";
+    return;
+  }
+  if ( this->GetOutputLocation().empty() )
+  {
+    MITK_ERROR << "Sorry, filename has not been set!";
+    return ;
+  }
+  const std::string& locale = "C";
+  const std::string& currLocale = setlocale( LC_ALL, NULL );
+
+  if ( locale.compare(currLocale)!=0 )
+  {
+    try
+    {
+      setlocale(LC_ALL, locale.c_str());
+    }
+    catch(...)
+    {
+      MITK_INFO << "Could not set locale " << locale;
+    }
+  }
+
+  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 .dwi
+  if( ext == "")
+  {
+    ext = ".nrrd";
+    this->SetOutputLocation(this->GetOutputLocation() + ext);
+  }
+
+  if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
+  {
+
+    MITK_INFO << "Extension " << ext;
+    itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+    //io->SetNrrdVectorType( nrrdKindList );
+    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 (itk::ExceptionObject e)
+    {
+      std::cout << e << std::endl;
+      throw;
+    }
+
+  }
+
+  try
+  {
+    setlocale(LC_ALL, currLocale.c_str());
+  }
+  catch(...)
+  {
+    MITK_INFO << "Could not reset locale " << currLocale;
+  }
+}
+
+mitk::DiffusionImageNrrdWriterService* mitk::DiffusionImageNrrdWriterService::Clone() const
+{
+  return new DiffusionImageNrrdWriterService(*this);
+}
+
+mitk::IFileWriter::ConfidenceLevel mitk::DiffusionImageNrrdWriterService::GetConfidenceLevel() const
+{
+  mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
+  if (input.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( input ) )
+  {
+    return Unsupported;
+  }
+  else
+  {
+    return Supported;
+  }
+}
+
+#endif //__mitkDiffusionImageNrrdWriterService__cpp
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdWriterService.h
similarity index 75%
rename from Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
rename to Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdWriterService.h
index 1bedf714ce..9b436c66b5 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageNrrdWriterService.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_NRRDDIFFVOL_WRITER__H_
-#define _MITK_NRRDDIFFVOL_WRITER__H_
+#ifndef _MITK_DiffusionImageNrrdWriterService__H_
+#define _MITK_DiffusionImageNrrdWriterService__H_
 
 #include <mitkAbstractFileWriter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
-class NrrdDiffusionImageWriter : public mitk::AbstractFileWriter
+class DiffusionImageNrrdWriterService : public mitk::AbstractFileWriter
 {
 public:
 
-    NrrdDiffusionImageWriter();
-    virtual ~NrrdDiffusionImageWriter();
+    DiffusionImageNrrdWriterService();
+    virtual ~DiffusionImageNrrdWriterService();
 
     using AbstractFileWriter::Write;
     virtual void Write();
 
     virtual ConfidenceLevel GetConfidenceLevel() const;
 
     typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
 
-    NrrdDiffusionImageWriter(const NrrdDiffusionImageWriter& other);
-    virtual mitk::NrrdDiffusionImageWriter* Clone() const;
+    DiffusionImageNrrdWriterService(const DiffusionImageNrrdWriterService& other);
+    virtual mitk::DiffusionImageNrrdWriterService* Clone() const;
 
 
 };
 
 
 } // end of namespace mitk
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
index c4bd31236b..c1d8cbf0e5 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
@@ -1,99 +1,107 @@
 /*===================================================================
 
 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 <mitkNrrdDiffusionImageReader.h>
+#include <mitkDiffusionImageNrrdReaderService.h>
+#include <mitkDiffusionImageNiftiReaderService.h>
 #include <mitkNrrdTensorImageReader.h>
 #include <mitkNrrdQBallImageReader.h>
 #include <mitkFiberBundleXReader.h>
 #include <mitkConnectomicsNetworkReader.h>
 
-#include <mitkNrrdDiffusionImageWriter.h>
+#include <mitkDiffusionImageNrrdWriterService.h>
+#include <mitkDiffusionImageNiftiWriterService.h>
 #include <mitkNrrdTensorImageWriter.h>
 #include <mitkNrrdQBallImageWriter.h>
 #include <mitkFiberBundleXWriter.h>
 #include <mitkConnectomicsNetworkWriter.h>
 
 #include "mitkDiffusionIOMimeTypes.h"
 
 namespace mitk
 {
   /**
   \brief Registers services for segmentation module.
   */
   class DiffusionModuleActivator : public us::ModuleActivator
   {
   public:
 
     void Load(us::ModuleContext* context)
     {
       us::ServiceProperties props;
       props[ us::ServiceConstants::SERVICE_RANKING() ] = 10;
 
       std::vector<mitk::CustomMimeType*> mimeTypes = mitk::DiffusionIOMimeTypes::Get();
       for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = mimeTypes.begin(),
         iterEnd = mimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
       {
         context->RegisterService(*mimeTypeIter, props);
       }
 
-      m_NrrdDiffusionImageReader = new NrrdDiffusionImageReader();
+      m_DiffusionImageNrrdReaderService = new DiffusionImageNrrdReaderService();
+      m_DiffusionImageNiftiReaderService = new DiffusionImageNiftiReaderService();
       m_NrrdTensorImageReader = new NrrdTensorImageReader();
       m_NrrdQBallImageReader = new NrrdQBallImageReader();
       m_FiberBundleXReader = new FiberBundleXReader();
       m_ConnectomicsNetworkReader = new ConnectomicsNetworkReader();
 
-      m_NrrdDiffusionImageWriter = new NrrdDiffusionImageWriter();
+      m_DiffusionImageNrrdWriterService = new DiffusionImageNrrdWriterService();
+      m_DiffusionImageNiftiWriterService = new DiffusionImageNiftiWriterService();
       m_NrrdTensorImageWriter = new NrrdTensorImageWriter();
       m_NrrdQBallImageWriter = new NrrdQBallImageWriter();
       m_FiberBundleXWriter = new FiberBundleXWriter();
       m_ConnectomicsNetworkWriter = new ConnectomicsNetworkWriter();
     }
 
     void Unload(us::ModuleContext*)
     {
-      delete m_NrrdDiffusionImageReader;
+      delete m_DiffusionImageNrrdReaderService;
+      delete m_DiffusionImageNiftiReaderService;
       delete m_NrrdTensorImageReader;
       delete m_NrrdQBallImageReader;
       delete m_FiberBundleXReader;
       delete m_ConnectomicsNetworkReader;
 
-      delete m_NrrdDiffusionImageWriter;
+      delete m_DiffusionImageNrrdWriterService;
+      delete m_DiffusionImageNiftiWriterService;
       delete m_NrrdTensorImageWriter;
       delete m_NrrdQBallImageWriter;
       delete m_FiberBundleXWriter;
       delete m_ConnectomicsNetworkWriter;
     }
 
   private:
 
-    NrrdDiffusionImageReader * m_NrrdDiffusionImageReader;
+    DiffusionImageNrrdReaderService * m_DiffusionImageNrrdReaderService;
+    DiffusionImageNiftiReaderService * m_DiffusionImageNiftiReaderService;
     NrrdTensorImageReader * m_NrrdTensorImageReader;
     NrrdQBallImageReader * m_NrrdQBallImageReader;
     FiberBundleXReader * m_FiberBundleXReader;
     ConnectomicsNetworkReader * m_ConnectomicsNetworkReader;
 
-    NrrdDiffusionImageWriter * m_NrrdDiffusionImageWriter;
+    DiffusionImageNrrdWriterService * m_DiffusionImageNrrdWriterService;
+    DiffusionImageNiftiWriterService * m_DiffusionImageNiftiWriterService;
     NrrdTensorImageWriter * m_NrrdTensorImageWriter;
     NrrdQBallImageWriter * m_NrrdQBallImageWriter;
     FiberBundleXWriter * m_FiberBundleXWriter;
     ConnectomicsNetworkWriter * m_ConnectomicsNetworkWriter;
 
   };
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::DiffusionModuleActivator)