diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index 5b0f5b3057..2984862eb7 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,41 +1,39 @@
 set(CPP_FILES
   mitkDiffusionModuleActivator.cpp
   mitkNrrdTbssImageWriterFactory.cpp
   #mitkFiberBundleXIOFactory.cpp
   mitkConnectomicsNetworkIOFactory.cpp
   mitkConnectomicsNetworkReader.cpp
   mitkConnectomicsNetworkWriter.cpp
   mitkConnectomicsNetworkSerializer.cpp
   mitkConnectomicsNetworkDefinitions.cpp
   mitkNrrdTbssRoiImageIOFactory.cpp
   #mitkFiberBundleXWriterFactory.cpp
   mitkConnectomicsNetworkWriterFactory.cpp
   mitkNrrdTbssRoiImageWriterFactory.cpp
   mitkNrrdTensorImageReader.cpp
   mitkNrrdTensorImageWriter.cpp
-  mitkNrrdTensorImageIOFactory.cpp
-  mitkNrrdTensorImageWriterFactory.cpp
   mitkTensorImageSerializer.cpp
   mitkTensorImageSource.cpp
   mitkFiberTrackingObjectFactory.cpp
   mitkConnectomicsObjectFactory.cpp
   mitkQuantificationObjectFactory.cpp
   mitkNrrdTbssImageIOFactory.cpp
   mitkDiffusionCoreObjectFactory.cpp
 
   mitkNrrdDiffusionImageReader.cpp
 #  mitkNrrdDiffusionImageIOFactory.cpp
   mitkNrrdDiffusionImageWriterFactory.cpp
   mitkDiffusionImageSerializer.cpp
 
   mitkNrrdQBallImageReader.cpp
   mitkNrrdQBallImageWriter.cpp
   mitkNrrdQBallImageIOFactory.cpp
   mitkNrrdQBallImageWriterFactory.cpp
   mitkQBallImageSerializer.cpp
 
   mitkFiberBundleXMapper2D.cpp
   mitkFiberBundleXMapper3D.cpp
   mitkCompositeMapper.cpp
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
index bcf9f59642..9b7237e94a 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
@@ -1,231 +1,216 @@
 /*===================================================================
 
 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 "mitkNrrdDiffusionImageWriterFactory.h"
 #include "mitkNrrdDiffusionImageWriter.h"
 #include "mitkDiffusionImage.h"
 
 #include "mitkNrrdQBallImageIOFactory.h"
 #include "mitkNrrdQBallImageWriterFactory.h"
 #include "mitkNrrdQBallImageWriter.h"
 
-#include "mitkNrrdTensorImageIOFactory.h"
-#include "mitkNrrdTensorImageWriterFactory.h"
-#include "mitkNrrdTensorImageWriter.h"
-
 #include "mitkCompositeMapper.h"
 #include "mitkDiffusionImageMapper.h"
 #include "mitkGPUVolumeMapper3D.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 
 
 typedef short DiffusionPixelType;
 
 typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionCoreObjectFactory::DiffusionCoreObjectFactory()
   : CoreObjectFactoryBase()
   , m_NrrdQBallImageIOFactory(mitk::NrrdQBallImageIOFactory::New().GetPointer())
-  , m_NrrdTensorImageIOFactory(mitk::NrrdTensorImageIOFactory::New().GetPointer())
   , m_NrrdDiffusionImageWriterFactory(mitk::NrrdDiffusionImageWriterFactory::New().GetPointer())
   , m_NrrdQBallImageWriterFactory(mitk::NrrdQBallImageWriterFactory::New().GetPointer())
-  , m_NrrdTensorImageWriterFactory(mitk::NrrdTensorImageWriterFactory::New().GetPointer())
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "DiffusionCoreObjectFactory c'tor" << std::endl;
 
     itk::ObjectFactoryBase::RegisterFactory(m_NrrdQBallImageIOFactory);
-    itk::ObjectFactoryBase::RegisterFactory(m_NrrdTensorImageIOFactory);
 
     itk::ObjectFactoryBase::RegisterFactory(m_NrrdDiffusionImageWriterFactory);
     itk::ObjectFactoryBase::RegisterFactory(m_NrrdQBallImageWriterFactory);
-    itk::ObjectFactoryBase::RegisterFactory(m_NrrdTensorImageWriterFactory);
 
     m_FileWriters.push_back( NrrdDiffusionImageWriter<DiffusionPixelType>::New().GetPointer() );
     m_FileWriters.push_back( NrrdQBallImageWriter::New().GetPointer() );
-    m_FileWriters.push_back( NrrdTensorImageWriter::New().GetPointer() );
 
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::DiffusionCoreObjectFactory::~DiffusionCoreObjectFactory()
 {
   itk::ObjectFactoryBase::UnRegisterFactory(m_NrrdQBallImageIOFactory);
-  itk::ObjectFactoryBase::UnRegisterFactory(m_NrrdTensorImageIOFactory);
 
   itk::ObjectFactoryBase::UnRegisterFactory(m_NrrdDiffusionImageWriterFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_NrrdQBallImageWriterFactory);
-  itk::ObjectFactoryBase::UnRegisterFactory(m_NrrdTensorImageWriterFactory);
 
 }
 
 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());
     }
 
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::DiffusionImageMapper<short>::New();
       newMapper->SetDataNode(node);
     }
 
   }
   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);
     }
     classname = "DiffusionImage";
     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);
   }
 
   classname = "DiffusionImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::DiffusionImageMapper<short>::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()
 {
 
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
-  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
-  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   //  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure File"));
 
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
-  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
-  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   // m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure File"));
 
 }
 
 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/mitkDiffusionCoreObjectFactory.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.h
index da416c1a34..4b75db9b9f 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.h
@@ -1,69 +1,66 @@
 /*===================================================================
 
 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 DiffusionCoreObjectFactory_H_INCLUDED
 #define DiffusionCoreObjectFactory_H_INCLUDED
 
 #include "mitkCoreObjectFactory.h"
 
 namespace mitk {
 
 class DiffusionCoreObjectFactory : public CoreObjectFactoryBase
 {
   public:
     mitkClassMacro(DiffusionCoreObjectFactory,CoreObjectFactoryBase)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     ~DiffusionCoreObjectFactory();
 
     virtual Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId);
 
     virtual void SetDefaultProperties(mitk::DataNode* node);
 
     virtual const char* GetFileExtensions();
 
     virtual mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap();
 
     virtual const char* GetSaveFileExtensions();
 
     virtual mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap();
 
 protected:
     DiffusionCoreObjectFactory();
     void CreateFileExtensionsMap();
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
 private:
 
     std::string m_ExternalFileExtensions;
     std::string m_InternalFileExtensions;
     std::string m_SaveFileExtensions;
 
     itk::ObjectFactoryBase::Pointer m_NrrdDiffusionImageIOFactory;
     itk::ObjectFactoryBase::Pointer m_NrrdQBallImageIOFactory;
-    itk::ObjectFactoryBase::Pointer m_NrrdTensorImageIOFactory;
 
     itk::ObjectFactoryBase::Pointer m_NrrdDiffusionImageWriterFactory;
     itk::ObjectFactoryBase::Pointer m_NrrdQBallImageWriterFactory;
-    itk::ObjectFactoryBase::Pointer m_NrrdTensorImageWriterFactory;
-
 };
 
 }
 
 #endif
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
index fb47f9742a..2d56b1e3cd 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionModuleActivator.cpp
@@ -1,45 +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.
 
 ===================================================================*/
 #include <usModuleActivator.h>
+
 #include <mitkNrrdDiffusionImageReader.h>
+#include <mitkNrrdTensorImageReader.h>
+
+#include <mitkNrrdTensorImageWriter.h>
 
 namespace mitk
 {
   /**
   \brief Registers services for segmentation module.
   */
   class DiffusionModuleActivator : public us::ModuleActivator
   {
   public:
 
     void Load(us::ModuleContext* /*context*/)
     {
         m_NrrdDiffusionImageReader = new NrrdDiffusionImageReader();
+        m_NrrdTensorImageReader = new NrrdTensorImageReader();
+
+        m_NrrdTensorImageWriter = new NrrdTensorImageWriter();
     }
 
     void Unload(us::ModuleContext*)
     {
       delete m_NrrdDiffusionImageReader;
+      delete m_NrrdTensorImageReader;
+
+      delete m_NrrdTensorImageWriter;
     }
 
   private:
 
     NrrdDiffusionImageReader * m_NrrdDiffusionImageReader;
+    NrrdTensorImageReader * m_NrrdTensorImageReader;
+
+    NrrdTensorImageWriter * m_NrrdTensorImageWriter;
 
   };
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::DiffusionModuleActivator)
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
index 160e33d600..cf8846e1fa 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.cpp
@@ -1,111 +1,127 @@
+/*===================================================================
+
+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 "mitkFiberTrackingObjectFactory.h"
 
 
 mitk::FiberTrackingObjectFactory::FiberTrackingObjectFactory()
   : CoreObjectFactoryBase()
 {
 }
 
 mitk::FiberTrackingObjectFactory::~FiberTrackingObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::FiberTrackingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
     std::string classname("FiberBundleX");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
     std::string classname("FiberBundleX");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
 //    classname = "FiberBundleXThreadMonitor";
 //    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
 //    {
 //      newMapper = mitk::FiberBundleXThreadMonitorMapper3D::New();
 //      newMapper->SetDataNode(node);
 //    }
   }
 
   return newMapper;
 }
 
 void mitk::FiberTrackingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   std::string classname("FiberBundleX");
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
     mitk::FiberBundleXMapper2D::SetDefaultProperties(node);
   }
 
 //  classname = "FiberBundleXThreadMonitor";
 //  if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
 //  {
 //    mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(node);
 //  }
 }
 
 const char* mitk::FiberTrackingObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::FiberTrackingObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::FiberTrackingObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::FiberTrackingObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::FiberTrackingObjectFactory::CreateFileExtensionsMap()
 {
 
 }
 
 void mitk::FiberTrackingObjectFactory::RegisterIOFactories()
 {
 }
 
 struct RegisterFiberTrackingObjectFactory{
   RegisterFiberTrackingObjectFactory()
     : m_Factory( mitk::FiberTrackingObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterFiberTrackingObjectFactory()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::FiberTrackingObjectFactory::Pointer m_Factory;
 };
 
 static RegisterFiberTrackingObjectFactory registerFiberTrackingObjectFactory;
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
index f78bc04bc9..b26f470e1b 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberTrackingObjectFactory.h
@@ -1,54 +1,70 @@
+/*===================================================================
+
+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 MITKFIBERTRACKINGOBJECTFACTORY_H
 #define MITKFIBERTRACKINGOBJECTFACTORY_H
 
 #include "mitkCoreObjectFactory.h"
 
 //modernized fiberbundle datastrucutre
 #include "mitkFiberBundleX.h"
 #include "mitkFiberBundleXMapper3D.h"
 #include "mitkFiberBundleXMapper2D.h"
 
 //#include "mitkFiberBundleXThreadMonitorMapper3D.h"
 //#include "mitkFiberBundleXThreadMonitor.h"
 
 namespace mitk {
 
 class FiberTrackingObjectFactory : public CoreObjectFactoryBase
 {
   public:
     mitkClassMacro(FiberTrackingObjectFactory,CoreObjectFactoryBase)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     ~FiberTrackingObjectFactory();
 
     virtual Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId);
 
     virtual void SetDefaultProperties(mitk::DataNode* node);
 
     virtual const char* GetFileExtensions();
 
     virtual mitk::CoreObjectFactoryBase::MultimapType GetFileExtensionsMap();
 
     virtual const char* GetSaveFileExtensions();
 
     virtual mitk::CoreObjectFactoryBase::MultimapType GetSaveFileExtensionsMap();
 
     void RegisterIOFactories();
 
 protected:
     FiberTrackingObjectFactory();
   private:
     void CreateFileExtensionsMap();
     std::string m_ExternalFileExtensions;
     std::string m_InternalFileExtensions;
     std::string m_SaveFileExtensions;
     MultimapType m_FileExtensionsMap;
     MultimapType m_SaveFileExtensionsMap;
 
 };
 
 }
 
 
 #endif // MITKFIBERTRACKINGOBJECTFACTORY_H
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageIOFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageIOFactory.cpp
deleted file mode 100644
index de84648cf6..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageIOFactory.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*===================================================================
-
-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 "mitkNrrdTensorImageIOFactory.h"
-#include "mitkIOAdapter.h"
-#include "mitkNrrdTensorImageReader.h"
-
-#include "itkVersion.h"
-
-
-namespace mitk
-{
-
-NrrdTensorImageIOFactory::NrrdTensorImageIOFactory()
-{
-  typedef NrrdTensorImageReader NrrdDTIReaderType;
-  this->RegisterOverride("mitkIOAdapter",
-                         "mitkNrrdTensorImageReader",
-                         "TensorImages IO",
-                         1,
-                         itk::CreateObjectFunction<IOAdapter<NrrdDTIReaderType> >::New());
-}
-
-NrrdTensorImageIOFactory::~NrrdTensorImageIOFactory()
-{
-}
-
-const char* NrrdTensorImageIOFactory::GetITKSourceVersion() const
-{
-  return ITK_SOURCE_VERSION;
-}
-
-const char* NrrdTensorImageIOFactory::GetDescription() const
-{
-  return "NrrdTensorImage IO Factory, allows the loading of NRRD tensor data";
-}
-
-} // end namespace mitk
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageIOFactory.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageIOFactory.h
deleted file mode 100644
index fe2c928896..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageIOFactory.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*===================================================================
-
-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_NRRD_DTI_IO_FACTORY_H_HEADER__
-#define __MITK_NRRD_DTI_IO_FACTORY_H_HEADER__
-
-#ifdef _MSC_VER
-#pragma warning ( disable : 4786 )
-#endif
-
-#include "itkObjectFactoryBase.h"
-#include "mitkBaseData.h"
-
-namespace mitk
-{
-//##Documentation
-//## @brief Create instances of NrrdTensorImageReader objects using an object factory.
-//##
-class NrrdTensorImageIOFactory : public itk::ObjectFactoryBase
-{
-public:
-  /** Standard class typedefs. */
-  typedef NrrdTensorImageIOFactory   Self;
-  typedef itk::ObjectFactoryBase  Superclass;
-  typedef itk::SmartPointer<Self>  Pointer;
-  typedef itk::SmartPointer<const Self>  ConstPointer;
-
-  /** Class methods used to interface with the registered factories. */
-  virtual const char* GetITKSourceVersion(void) const;
-  virtual const char* GetDescription(void) const;
-
-  /** Method for class instantiation. */
-  itkFactorylessNewMacro(Self);
-  static NrrdTensorImageIOFactory* FactoryNew() { return new NrrdTensorImageIOFactory;}
-  /** Run-time type information (and related methods). */
-  itkTypeMacro(NrrdTensorImageIOFactory, ObjectFactoryBase);
-
-  /** Register one factory of this type  */
-  static void RegisterOneFactory(void)
-  {
-    static bool IsRegistered = false;
-    if ( !IsRegistered )
-    {
-      NrrdTensorImageIOFactory::Pointer ugVtkWriterFactory = NrrdTensorImageIOFactory::New();
-      ObjectFactoryBase::RegisterFactory( ugVtkWriterFactory );
-      IsRegistered = true;
-    }
-  }
-
-protected:
-  NrrdTensorImageIOFactory();
-  ~NrrdTensorImageIOFactory();
-
-private:
-  NrrdTensorImageIOFactory(const Self&); //purposely not implemented
-  void operator=(const Self&); //purposely not implemented
-
-};
-
-
-} // end namespace mitk
-
-#endif  // __MITK_NRRD_DTI_IO_FACTORY_H_HEADER__
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.cpp
index 5dd4300541..4442f59652 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.cpp
@@ -1,480 +1,448 @@
 /*===================================================================
 
 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 "mitkNrrdTensorImageReader.h"
+#include <mitkCustomMimeType.h>
 
 #include "itkImageFileReader.h"
 #include "itkImageRegionIterator.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include <itkNiftiImageIO.h>
 
 #include "mitkITKImageImport.h"
 #include "mitkImageDataItem.h"
 
 namespace mitk
 {
 
-void NrrdTensorImageReader
-::GenerateData()
-{
-    if ( m_FileName == "")
+  NrrdTensorImageReader::NrrdTensorImageReader(const NrrdTensorImageReader& other)
+    : mitk::AbstractFileReader(other)
+  {
+  }
+
+  NrrdTensorImageReader::NrrdTensorImageReader()
+  {
+    std::string category = "Tensor Images";
+    mitk::CustomMimeType customMimeType;
+    customMimeType.SetCategory(category);
+    customMimeType.AddExtension("dti");
+    customMimeType.AddExtension("hdti");
+
+    this->SetDescription(category);
+    this->SetMimeType(customMimeType);
+
+    m_ServiceReg = this->RegisterService();
+  }
+
+  NrrdTensorImageReader::~NrrdTensorImageReader()
+  {
+  }
+
+  std::vector<itk::SmartPointer<BaseData> > NrrdTensorImageReader::Read()
+  {
+    std::vector<itk::SmartPointer<mitk::BaseData> > result;
+    std::string location = GetInputLocation();
+
+    if ( location == "")
     {
-        throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
+      throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
     }
     else
     {
-        try
+      try
+      {
+        const std::string& locale = "C";
+        const std::string& currLocale = setlocale( LC_ALL, NULL );
+
+        if ( locale.compare(currLocale)!=0 )
         {
-            const std::string& locale = "C";
-            const std::string& currLocale = setlocale( LC_ALL, NULL );
+          try
+          {
+            setlocale(LC_ALL, locale.c_str());
+          }
+          catch(...)
+          {
+            MITK_INFO << "Could not set locale " << locale;
+          }
+        }
 
-            if ( locale.compare(currLocale)!=0 )
+        try
+        {
+          std::string fname3 = "temp_dti.nii";
+          itksys::SystemTools::CopyAFile(location.c_str(), fname3.c_str());
+
+          typedef itk::VectorImage<float,3> ImageType;
+          itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
+          typedef itk::ImageFileReader<ImageType> FileReaderType;
+          FileReaderType::Pointer reader = FileReaderType::New();
+          reader->SetImageIO(io);
+          reader->SetFileName(fname3);
+          reader->Update();
+          ImageType::Pointer img = reader->GetOutput();
+
+          typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
+          VecImgType::Pointer vecImg = VecImgType::New();
+          vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
+          vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
+          vecImg->SetDirection( img->GetDirection() );  // Set the image direction
+          vecImg->SetRegions( img->GetLargestPossibleRegion());
+          vecImg->Allocate();
+
+          itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
+          ot.GoToBegin();
+
+          itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
+          it.GoToBegin();
+
+          typedef ImageType::PixelType  VarPixType;
+          typedef VecImgType::PixelType FixPixType;
+          int numComponents = img->GetNumberOfComponentsPerPixel();
+
+          if (numComponents==6)
+          {
+            MITK_INFO << "Trying to load dti as 6-comp nifti ...";
+            while (!it.IsAtEnd())
             {
-                try
-                {
-                    setlocale(LC_ALL, locale.c_str());
-                }
-                catch(...)
-                {
-                    MITK_INFO << "Could not set locale " << locale;
-                }
+              VarPixType vec = it.Get();
+              FixPixType fixVec(vec.GetDataPointer());
+
+              itk::DiffusionTensor3D<float> tensor;
+              tensor.SetElement(0, vec.GetElement(0));
+              tensor.SetElement(1, vec.GetElement(1));
+              tensor.SetElement(2, vec.GetElement(2));
+              tensor.SetElement(3, vec.GetElement(3));
+              tensor.SetElement(4, vec.GetElement(4));
+              tensor.SetElement(5, vec.GetElement(5));
+
+              fixVec = tensor;
+
+              ot.Set(fixVec);
+              ++ot;
+              ++it;
             }
-
-            try
+          }
+          else if(numComponents==9)
+          {
+            MITK_INFO << "Trying to load dti as 9-comp nifti ...";
+            while (!it.IsAtEnd())
             {
-                std::string fname3 = "temp_dti.nii";
-                itksys::SystemTools::CopyAFile(m_FileName.c_str(), fname3.c_str());
-
-                typedef itk::VectorImage<float,3> ImageType;
-                itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
-                typedef itk::ImageFileReader<ImageType> FileReaderType;
-                FileReaderType::Pointer reader = FileReaderType::New();
-                reader->SetImageIO(io);
-                reader->SetFileName(fname3);
-                reader->Update();
-                ImageType::Pointer img = reader->GetOutput();
-
-                typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
-                VecImgType::Pointer vecImg = VecImgType::New();
-                vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
-                vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
-                vecImg->SetDirection( img->GetDirection() );  // Set the image direction
-                vecImg->SetRegions( img->GetLargestPossibleRegion());
-                vecImg->Allocate();
-
-                itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
-                ot.GoToBegin();
-
-                itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
-                it.GoToBegin();
-
-                typedef ImageType::PixelType  VarPixType;
-                typedef VecImgType::PixelType FixPixType;
-                int numComponents = img->GetNumberOfComponentsPerPixel();
-
-                if (numComponents==6)
-                {
-                    MITK_INFO << "Trying to load dti as 6-comp nifti ...";
-                    while (!it.IsAtEnd())
-                    {
-                        VarPixType vec = it.Get();
-                        FixPixType fixVec(vec.GetDataPointer());
-
-                        itk::DiffusionTensor3D<float> tensor;
-                        tensor.SetElement(0, vec.GetElement(0));
-                        tensor.SetElement(1, vec.GetElement(1));
-                        tensor.SetElement(2, vec.GetElement(2));
-                        tensor.SetElement(3, vec.GetElement(3));
-                        tensor.SetElement(4, vec.GetElement(4));
-                        tensor.SetElement(5, vec.GetElement(5));
-
-                        fixVec = tensor;
-
-                        ot.Set(fixVec);
-                        ++ot;
-                        ++it;
-                    }
-                }
-                else if(numComponents==9)
-                {
-                    MITK_INFO << "Trying to load dti as 9-comp nifti ...";
-                    while (!it.IsAtEnd())
-                    {
-                        VarPixType vec = it.Get();
-                        itk::DiffusionTensor3D<float> tensor;
-                        tensor.SetElement(0, vec.GetElement(0));
-                        tensor.SetElement(1, vec.GetElement(1));
-                        tensor.SetElement(2, vec.GetElement(2));
-                        tensor.SetElement(3, vec.GetElement(4));
-                        tensor.SetElement(4, vec.GetElement(5));
-                        tensor.SetElement(5, vec.GetElement(8));
-
-                        FixPixType fixVec(tensor);
-                        ot.Set(fixVec);
-                        ++ot;
-                        ++it;
-                    }
-                }
-                else if (numComponents==1)
-                {
-                    MITK_INFO << "Trying to load dti as 4D nifti ...";
-                    typedef itk::Image<float,4> ImageType;
-                    typedef itk::ImageFileReader<ImageType> FileReaderType;
-                    FileReaderType::Pointer reader = FileReaderType::New();
-                    reader->SetImageIO(io);
-                    reader->SetFileName(fname3);
-                    reader->Update();
-                    ImageType::Pointer img = reader->GetOutput();
-
-                    itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
-
-                    while (!ot.IsAtEnd())
-                    {
-                        itk::DiffusionTensor3D<float> tensor;
-                        ImageType::IndexType idx;
-                        idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
-
-                        if (size[3]==6)
-                        {
-                            for (unsigned int te=0; te<size[3]; te++)
-                            {
-                                idx[3] = te;
-                                tensor.SetElement(te, img->GetPixel(idx));
-                            }
-                        }
-                        else if (size[3]==9)
-                        {
-                            idx[3] = 0;
-                            tensor.SetElement(0, img->GetPixel(idx));
-                            idx[3] = 1;
-                            tensor.SetElement(1, img->GetPixel(idx));
-                            idx[3] = 2;
-                            tensor.SetElement(2, img->GetPixel(idx));
-                            idx[3] = 4;
-                            tensor.SetElement(3, img->GetPixel(idx));
-                            idx[3] = 5;
-                            tensor.SetElement(4, img->GetPixel(idx));
-                            idx[3] = 8;
-                            tensor.SetElement(5, img->GetPixel(idx));
-                        }
-                        else
-                            throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!");
-
-                        FixPixType fixVec(tensor);
-                        ot.Set(fixVec);
-                        ++ot;
-                    }
-                }
-                this->GetOutput()->InitializeByItk(vecImg.GetPointer());
-                this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
+              VarPixType vec = it.Get();
+              itk::DiffusionTensor3D<float> tensor;
+              tensor.SetElement(0, vec.GetElement(0));
+              tensor.SetElement(1, vec.GetElement(1));
+              tensor.SetElement(2, vec.GetElement(2));
+              tensor.SetElement(3, vec.GetElement(4));
+              tensor.SetElement(4, vec.GetElement(5));
+              tensor.SetElement(5, vec.GetElement(8));
+
+              FixPixType fixVec(tensor);
+              ot.Set(fixVec);
+              ++ot;
+              ++it;
             }
-            catch(...)
+          }
+          else if (numComponents==1)
+          {
+            MITK_INFO << "Trying to load dti as 4D nifti ...";
+            typedef itk::Image<float,4> ImageType;
+            typedef itk::ImageFileReader<ImageType> FileReaderType;
+            FileReaderType::Pointer reader = FileReaderType::New();
+            reader->SetImageIO(io);
+            reader->SetFileName(fname3);
+            reader->Update();
+            ImageType::Pointer img = reader->GetOutput();
+
+            itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
+
+            while (!ot.IsAtEnd())
             {
-                MITK_INFO << "Trying to load dti as nrrd ...";
-
-                typedef itk::VectorImage<float,3> ImageType;
-                itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
-                typedef itk::ImageFileReader<ImageType> FileReaderType;
-                FileReaderType::Pointer reader = FileReaderType::New();
-                reader->SetImageIO(io);
-                reader->SetFileName(this->m_FileName);
-                reader->Update();
-                ImageType::Pointer img = reader->GetOutput();
-
-                typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
-                VecImgType::Pointer vecImg = VecImgType::New();
-                vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
-                vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
-                vecImg->SetDirection( img->GetDirection() );  // Set the image direction
-                vecImg->SetRegions( img->GetLargestPossibleRegion());
-                vecImg->Allocate();
-
-                itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
-                ot.GoToBegin();
-
-                itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
-                it.GoToBegin();
-
-                typedef ImageType::PixelType  VarPixType;
-                typedef VecImgType::PixelType FixPixType;
-                int numComponents = img->GetNumberOfComponentsPerPixel();
-
-                itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
-                std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
-                std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
-                std::string metaString;
-
-                bool readFrame = false;
-                double xx, xy, xz, yx, yy, yz, zx, zy, zz;
-                MeasurementFrameType measFrame;
-                measFrame.SetIdentity();
-                MeasurementFrameType measFrameTransp;
-                measFrameTransp.SetIdentity();
-
-                for (; itKey != imgMetaKeys.end(); itKey ++)
-                {
-                    itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
-                    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 )
-                        {
-                            readFrame = true;
-
-                            measFrame(0,0) = xx;
-                            measFrame(0,1) = xy;
-                            measFrame(0,2) = xz;
-                            measFrame(1,0) = yx;
-                            measFrame(1,1) = yy;
-                            measFrame(1,2) = yz;
-                            measFrame(2,0) = zx;
-                            measFrame(2,1) = zy;
-                            measFrame(2,2) = zz;
-
-                            measFrameTransp = measFrame.GetTranspose();
-                        }
-                    }
-                }
+              itk::DiffusionTensor3D<float> tensor;
+              ImageType::IndexType idx;
+              idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
 
-                if (numComponents==6)
+              if (size[3]==6)
+              {
+                for (unsigned int te=0; te<size[3]; te++)
                 {
-                    while (!it.IsAtEnd())
-                    {
-                        // T'=RTR'
-                        VarPixType vec = it.Get();
-                        FixPixType fixVec(vec.GetDataPointer());
-
-                        if(readFrame)
-                        {
-                            itk::DiffusionTensor3D<float> tensor;
-                            tensor.SetElement(0, vec.GetElement(0));
-                            tensor.SetElement(1, vec.GetElement(1));
-                            tensor.SetElement(2, vec.GetElement(2));
-                            tensor.SetElement(3, vec.GetElement(3));
-                            tensor.SetElement(4, vec.GetElement(4));
-                            tensor.SetElement(5, vec.GetElement(5));
-
-                            tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
-                            tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
-                            fixVec = tensor;
-                        }
-
-                        ot.Set(fixVec);
-                        ++ot;
-                        ++it;
-                    }
+                  idx[3] = te;
+                  tensor.SetElement(te, img->GetPixel(idx));
                 }
-                else if(numComponents==9)
-                {
-                    while (!it.IsAtEnd())
-                    {
-                        VarPixType vec = it.Get();
-                        itk::DiffusionTensor3D<float> tensor;
-                        tensor.SetElement(0, vec.GetElement(0));
-                        tensor.SetElement(1, vec.GetElement(1));
-                        tensor.SetElement(2, vec.GetElement(2));
-                        tensor.SetElement(3, vec.GetElement(4));
-                        tensor.SetElement(4, vec.GetElement(5));
-                        tensor.SetElement(5, vec.GetElement(8));
-
-                        if(readFrame)
-                        {
-                            tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
-                            tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
-                        }
-
-                        FixPixType fixVec(tensor);
-                        ot.Set(fixVec);
-                        ++ot;
-                        ++it;
-                    }
-                }
-                else if (numComponents==1)
-                {
-                    typedef itk::Image<float,4> ImageType;
-                    itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
-                    typedef itk::ImageFileReader<ImageType> FileReaderType;
-                    FileReaderType::Pointer reader = FileReaderType::New();
-                    reader->SetImageIO(io);
-                    reader->SetFileName(this->m_FileName);
-                    reader->Update();
-                    ImageType::Pointer img = reader->GetOutput();
-
-                    itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
-
-                    while (!ot.IsAtEnd())
-                    {
-                        itk::DiffusionTensor3D<float> tensor;
-                        ImageType::IndexType idx;
-                        idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
-
-                        if (size[3]==6)
-                        {
-                            for (unsigned int te=0; te<size[3]; te++)
-                            {
-                                idx[3] = te;
-                                tensor.SetElement(te, img->GetPixel(idx));
-                            }
-                        }
-                        else if (size[3]==9)
-                        {
-                            idx[3] = 0;
-                            tensor.SetElement(0, img->GetPixel(idx));
-                            idx[3] = 1;
-                            tensor.SetElement(1, img->GetPixel(idx));
-                            idx[3] = 2;
-                            tensor.SetElement(2, img->GetPixel(idx));
-                            idx[3] = 4;
-                            tensor.SetElement(3, img->GetPixel(idx));
-                            idx[3] = 5;
-                            tensor.SetElement(4, img->GetPixel(idx));
-                            idx[3] = 8;
-                            tensor.SetElement(5, img->GetPixel(idx));
-                        }
-                        else
-                            throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!");
-
-                        if(readFrame)
-                        {
-                            tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
-                            tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
-                        }
-                        FixPixType fixVec(tensor);
-                        ot.Set(fixVec);
-                        ++ot;
-                    }
-                }
-                else
-                {
-                    throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
-                }
-
-                this->GetOutput()->InitializeByItk(vecImg.GetPointer());
-                this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
-
+              }
+              else if (size[3]==9)
+              {
+                idx[3] = 0;
+                tensor.SetElement(0, img->GetPixel(idx));
+                idx[3] = 1;
+                tensor.SetElement(1, img->GetPixel(idx));
+                idx[3] = 2;
+                tensor.SetElement(2, img->GetPixel(idx));
+                idx[3] = 4;
+                tensor.SetElement(3, img->GetPixel(idx));
+                idx[3] = 5;
+                tensor.SetElement(4, img->GetPixel(idx));
+                idx[3] = 8;
+                tensor.SetElement(5, img->GetPixel(idx));
+              }
+              else
+                throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of components for DTI file. Should be 6 or 9!");
+
+              FixPixType fixVec(tensor);
+              ot.Set(fixVec);
+              ++ot;
             }
+          }
+          OutputType::Pointer resultImage = OutputType::New();
+          resultImage->InitializeByItk( vecImg.GetPointer() );
+          resultImage->SetVolume( vecImg->GetBufferPointer() );
+          result.push_back( resultImage.GetPointer() );
+        }
+        catch(...)
+        {
+          MITK_INFO << "Trying to load dti as nrrd ...";
+
+          typedef itk::VectorImage<float,3> ImageType;
+          itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+          typedef itk::ImageFileReader<ImageType> FileReaderType;
+          FileReaderType::Pointer reader = FileReaderType::New();
+          reader->SetImageIO(io);
+          reader->SetFileName(location);
+          reader->Update();
+          ImageType::Pointer img = reader->GetOutput();
+
+          typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
+          VecImgType::Pointer vecImg = VecImgType::New();
+          vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
+          vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
+          vecImg->SetDirection( img->GetDirection() );  // Set the image direction
+          vecImg->SetRegions( img->GetLargestPossibleRegion());
+          vecImg->Allocate();
+
+          itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
+          ot.GoToBegin();
+
+          itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
+          it.GoToBegin();
+
+          typedef ImageType::PixelType  VarPixType;
+          typedef VecImgType::PixelType FixPixType;
+          int numComponents = img->GetNumberOfComponentsPerPixel();
+
+          itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
+          std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+          std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+          std::string metaString;
+
+          bool readFrame = false;
+          double xx, xy, xz, yx, yy, yz, zx, zy, zz;
+          MeasurementFrameType measFrame;
+          measFrame.SetIdentity();
+          MeasurementFrameType measFrameTransp;
+          measFrameTransp.SetIdentity();
+
+          for (; itKey != imgMetaKeys.end(); itKey ++)
+          {
+            itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+            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 )
+              {
+                readFrame = true;
+
+                measFrame(0,0) = xx;
+                measFrame(0,1) = xy;
+                measFrame(0,2) = xz;
+                measFrame(1,0) = yx;
+                measFrame(1,1) = yy;
+                measFrame(1,2) = yz;
+                measFrame(2,0) = zx;
+                measFrame(2,1) = zy;
+                measFrame(2,2) = zz;
+
+                measFrameTransp = measFrame.GetTranspose();
+              }
+            }
+          }
 
-            try
+          if (numComponents==6)
+          {
+            while (!it.IsAtEnd())
             {
-                setlocale(LC_ALL, currLocale.c_str());
+              // T'=RTR'
+              VarPixType vec = it.Get();
+              FixPixType fixVec(vec.GetDataPointer());
+
+              if(readFrame)
+              {
+                itk::DiffusionTensor3D<float> tensor;
+                tensor.SetElement(0, vec.GetElement(0));
+                tensor.SetElement(1, vec.GetElement(1));
+                tensor.SetElement(2, vec.GetElement(2));
+                tensor.SetElement(3, vec.GetElement(3));
+                tensor.SetElement(4, vec.GetElement(4));
+                tensor.SetElement(5, vec.GetElement(5));
+
+                tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+                tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+                fixVec = tensor;
+              }
+
+              ot.Set(fixVec);
+              ++ot;
+              ++it;
             }
-            catch(...)
+          }
+          else if(numComponents==9)
+          {
+            while (!it.IsAtEnd())
             {
-                MITK_INFO << "Could not reset locale " << currLocale;
+              VarPixType vec = it.Get();
+              itk::DiffusionTensor3D<float> tensor;
+              tensor.SetElement(0, vec.GetElement(0));
+              tensor.SetElement(1, vec.GetElement(1));
+              tensor.SetElement(2, vec.GetElement(2));
+              tensor.SetElement(3, vec.GetElement(4));
+              tensor.SetElement(4, vec.GetElement(5));
+              tensor.SetElement(5, vec.GetElement(8));
+
+              if(readFrame)
+              {
+                tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+                tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+              }
+
+              FixPixType fixVec(tensor);
+              ot.Set(fixVec);
+              ++ot;
+              ++it;
             }
+          }
+          else if (numComponents==1)
+          {
+            typedef itk::Image<float,4> ImageType;
+            itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+            typedef itk::ImageFileReader<ImageType> FileReaderType;
+            FileReaderType::Pointer reader = FileReaderType::New();
+            reader->SetImageIO(io);
+            reader->SetFileName(location);
+            reader->Update();
+            ImageType::Pointer img = reader->GetOutput();
+
+            itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
+
+            while (!ot.IsAtEnd())
+            {
+              itk::DiffusionTensor3D<float> tensor;
+              ImageType::IndexType idx;
+              idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
 
+              if (size[3]==6)
+              {
+                for (unsigned int te=0; te<size[3]; te++)
+                {
+                  idx[3] = te;
+                  tensor.SetElement(te, img->GetPixel(idx));
+                }
+              }
+              else if (size[3]==9)
+              {
+                idx[3] = 0;
+                tensor.SetElement(0, img->GetPixel(idx));
+                idx[3] = 1;
+                tensor.SetElement(1, img->GetPixel(idx));
+                idx[3] = 2;
+                tensor.SetElement(2, img->GetPixel(idx));
+                idx[3] = 4;
+                tensor.SetElement(3, img->GetPixel(idx));
+                idx[3] = 5;
+                tensor.SetElement(4, img->GetPixel(idx));
+                idx[3] = 8;
+                tensor.SetElement(5, img->GetPixel(idx));
+              }
+              else
+                throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!");
+
+              if(readFrame)
+              {
+                tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+                tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+              }
+              FixPixType fixVec(tensor);
+              ot.Set(fixVec);
+              ++ot;
+            }
+          }
+          else
+          {
+            throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
+          }
+
+          OutputType::Pointer resultImage = OutputType::New();
+          resultImage->InitializeByItk( vecImg.GetPointer() );
+          resultImage->SetVolume( vecImg->GetBufferPointer() );
+          result.push_back( resultImage.GetPointer() );
         }
-        catch(std::exception& e)
+
+        try
         {
-            throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
+          setlocale(LC_ALL, currLocale.c_str());
         }
         catch(...)
         {
-            throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
+          MITK_INFO << "Could not reset locale " << currLocale;
         }
-    }
-}
-
-void NrrdTensorImageReader::GenerateOutputInformation()
-{
-
-}
-
-
-
-const char* NrrdTensorImageReader
-::GetFileName() const
-{
-    return m_FileName.c_str();
-}
-
-
-void NrrdTensorImageReader
-::SetFileName(const char* aFileName)
-{
-    m_FileName = aFileName;
-}
-
-
-const char* NrrdTensorImageReader
-::GetFilePrefix() const
-{
-    return m_FilePrefix.c_str();
-}
-
 
-void NrrdTensorImageReader
-::SetFilePrefix(const char* aFilePrefix)
-{
-    m_FilePrefix = aFilePrefix;
-}
-
-
-const char* NrrdTensorImageReader
-::GetFilePattern() const
-{
-    return m_FilePattern.c_str();
-}
-
-
-void NrrdTensorImageReader
-::SetFilePattern(const char* aFilePattern)
-{
-    m_FilePattern = aFilePattern;
-}
-
-
-bool NrrdTensorImageReader
-::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
-{
-    // First check the extension
-    if(  filename == "" )
-    {
-        return false;
-    }
-    std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
-    ext = itksys::SystemTools::LowerCase(ext);
-
-    if (ext == ".hdti" || ext == ".dti")
-    {
-        return true;
+      }
+      catch(std::exception& e)
+      {
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
+      }
+      catch(...)
+      {
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
+      }
     }
 
-    return false;
-}
+    return result;
+  }
 
 itk::DiffusionTensor3D<float> NrrdTensorImageReader
 ::ConvertMatrixTypeToFixedArrayType(const itk::DiffusionTensor3D<float>::Superclass::MatrixType & matrix)
 {
     /*       | 0  1  2  |
       *       | X  3  4  |
       *       | X  X  5  |
       */
     itk::DiffusionTensor3D<float> arr;
     arr.SetElement(0,matrix(0,0));
     arr.SetElement(1,matrix(0,1));
     arr.SetElement(2,matrix(0,2));
     arr.SetElement(3,matrix(1,3));
     arr.SetElement(4,matrix(1,4));
     arr.SetElement(5,matrix(2,5));
     return arr;
 }
 
 } //namespace MITK
+
+mitk::NrrdTensorImageReader* mitk::NrrdTensorImageReader::Clone() const
+{
+  return new NrrdTensorImageReader(*this);
+}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.h
index 8c51504540..22b57938ef 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageReader.h
@@ -1,73 +1,63 @@
 /*===================================================================
 
 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 __mitkNrrdTensorImageReader_h
 #define __mitkNrrdTensorImageReader_h
 
 #include "mitkCommon.h"
 #include "itkVectorContainer.h"
-#include "mitkFileReader.h"
 #include "vnl/vnl_vector_fixed.h"
 #include "mitkTensorImage.h"
-#include "mitkTensorImageSource.h"
 #include "itkVectorImage.h"
 #include "itkDiffusionTensor3D.h"
+#include <mitkAbstractFileReader.h>
+#include <mitkBaseData.h>
+#include <mitkMimeType.h>
 
 namespace mitk
 {
 
   /** \brief
   */
 
-  class NrrdTensorImageReader : public mitk::TensorImageSource, public FileReader
+  class NrrdTensorImageReader : public mitk::AbstractFileReader
   {
   public:
 
     typedef mitk::TensorImage OutputType;
-    typedef mitk::TensorImageSource DTImgSourceType;
     typedef itk::Matrix< float, 3, 3 > MeasurementFrameType;
 
-    mitkClassMacro( NrrdTensorImageReader, DTImgSourceType );
-    itkFactorylessNewMacro(Self)
-    itkCloneMacro(Self)
+    NrrdTensorImageReader(const NrrdTensorImageReader& other);
+    NrrdTensorImageReader();
+    virtual ~NrrdTensorImageReader();
 
-    const char* GetFileName() const;
-    void SetFileName(const char* aFileName);
-    const char* GetFilePrefix() const;
-    void SetFilePrefix(const char* aFilePrefix);
-    const char* GetFilePattern() const;
-    void SetFilePattern(const char* aFilePattern);
-
-    static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
+    using AbstractFileReader::Read;
+    virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
   protected:
 
-    /** Does the real work. */
-    virtual void GenerateData();
-    virtual void GenerateOutputInformation();
-
-    std::string m_FileName;
-    std::string m_FilePrefix;
-    std::string m_FilePattern;
 
   private:
-    void operator=(const Self&); //purposely not implemented
+    NrrdTensorImageReader* Clone() const;
+
+    us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
+
     itk::DiffusionTensor3D<float> ConvertMatrixTypeToFixedArrayType(const itk::DiffusionTensor3D<float>::Superclass::MatrixType & matrix);
   };
 
 } //namespace MITK
 
 #endif // __mitkNrrdTensorImageReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.cpp
index 816af51a52..da60fc48bc 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.cpp
@@ -1,132 +1,131 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkNrrdTensorImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itkDiffusionTensor3D.h"
 #include "mitkImageCast.h"
+#include "mitkIOMimeTypes.h"
 
 
 mitk::NrrdTensorImageWriter::NrrdTensorImageWriter()
-    : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
+  : AbstractFileWriter(mitk::TensorImage::GetStaticNameOfClass())
 {
-    this->SetNumberOfRequiredInputs( 1 );
-}
+  std::string category = "Tensor Images";
+  mitk::CustomMimeType customMimeType;
+  customMimeType.SetCategory(category);
+  customMimeType.AddExtension("dti");
+  customMimeType.AddExtension("hdti");
 
+  this->SetDescription(category);
+  this->SetMimeType(customMimeType);
 
-mitk::NrrdTensorImageWriter::~NrrdTensorImageWriter()
-{}
-
+  RegisterService();
+}
 
-void mitk::NrrdTensorImageWriter::GenerateData()
+mitk::NrrdTensorImageWriter::NrrdTensorImageWriter(const mitk::NrrdTensorImageWriter& other)
+  : AbstractFileWriter(other)
 {
-    m_Success = false;
-    InputType* input = this->GetInput();
-    if (input == NULL)
-    {
-        itkWarningMacro(<<"Sorry, input to NrrdTensorImageWriter is NULL!");
-        return;
-    }
-    if ( m_FileName == "" )
-    {
-        itkWarningMacro( << "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;
-      }
-    }
-
-    itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
-    io->SetFileType( itk::ImageIOBase::Binary );
-    io->UseCompressionOn();
-
-    typedef itk::Image<itk::DiffusionTensor3D<float>,3> ImageType;
-    typedef itk::ImageFileWriter<ImageType> WriterType;
-    WriterType::Pointer nrrdWriter = WriterType::New();
+}
 
-    ImageType::Pointer outimage = ImageType::New();
-    CastToItkImage(input, outimage);
 
-    nrrdWriter->SetInput( outimage );
-    nrrdWriter->SetImageIO(io);
-    nrrdWriter->SetFileName(m_FileName);
-    nrrdWriter->UseCompressionOn();
+mitk::NrrdTensorImageWriter::~NrrdTensorImageWriter()
+{}
 
-    try
-    {
-      nrrdWriter->Update();
-    }
-    catch (itk::ExceptionObject e)
-    {
-      std::cout << e << std::endl;
-    }
 
+void mitk::NrrdTensorImageWriter::Write()
+{
+  InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
+  if (input.IsNull() )
+  {
+    MITK_ERROR <<"Sorry, input to NrrdTensorImageWriter is NULL!";
+    return;
+  }
+  if ( this->GetOutputLocation().c_str() == "" )
+  {
+    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, currLocale.c_str());
+      setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
-      MITK_INFO << "Could not reset locale " << currLocale;
+      MITK_INFO << "Could not set locale " << locale;
     }
-    m_Success = true;
-}
-
+  }
+
+  itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+  io->SetFileType( itk::ImageIOBase::Binary );
+  io->UseCompressionOn();
+
+  typedef itk::Image<itk::DiffusionTensor3D<float>,3> ImageType;
+  typedef itk::ImageFileWriter<ImageType> WriterType;
+  WriterType::Pointer nrrdWriter = WriterType::New();
+
+  ImageType::Pointer outimage = ImageType::New();
+  CastToItkImage(input, outimage);
+
+  nrrdWriter->SetInput( outimage );
+  nrrdWriter->SetImageIO(io);
+  nrrdWriter->SetFileName(this->GetOutputLocation().c_str());
+  nrrdWriter->UseCompressionOn();
+
+  try
+  {
+    nrrdWriter->Update();
+  }
+  catch (itk::ExceptionObject e)
+  {
+    std::cout << e << std::endl;
+  }
+
+  try
+  {
+    setlocale(LC_ALL, currLocale.c_str());
+  }
+  catch(...)
+  {
+    MITK_INFO << "Could not reset locale " << currLocale;
+  }
 
-void mitk::NrrdTensorImageWriter::SetInput( InputType* diffVolumes )
-{
-    this->ProcessObject::SetNthInput( 0, diffVolumes );
 }
 
-
-mitk::TensorImage* mitk::NrrdTensorImageWriter::GetInput()
-{
-    if ( this->GetNumberOfInputs() < 1 )
-    {
-        return NULL;
-    }
-    else
-    {
-        return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
-    }
-}
-
-
-std::vector<std::string> mitk::NrrdTensorImageWriter::GetPossibleFileExtensions()
+mitk::NrrdTensorImageWriter* mitk::NrrdTensorImageWriter::Clone() const
 {
-  std::vector<std::string> possibleFileExtensions;
-  possibleFileExtensions.push_back(".dti");
-  possibleFileExtensions.push_back(".hdti");
-  return possibleFileExtensions;
+  return new NrrdTensorImageWriter(*this);
 }
 
-std::string mitk::NrrdTensorImageWriter::GetSupportedBaseData() const
+mitk::IFileWriter::ConfidenceLevel mitk::NrrdTensorImageWriter::GetConfidenceLevel() const
 {
-  return InputType::GetStaticNameOfClass();
+  InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
+  if (input.IsNull() )
+  {
+    return Unsupported;
+  }
+  else
+  {
+    return Supported;
+  }
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.h
index 15af42a65f..7d8dff5d89 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriter.h
@@ -1,133 +1,55 @@
 /*===================================================================
 
 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_NRRDDTI_WRITER__H_
 #define _MITK_NRRDDTI_WRITER__H_
 
 #include <itkProcessObject.h>
-#include <mitkFileWriterWithInformation.h>
+#include <mitkAbstractFileWriter.h>
 #include <mitkTensorImage.h>
 
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
-class NrrdTensorImageWriter : public mitk::FileWriterWithInformation
+class NrrdTensorImageWriter : public mitk::AbstractFileWriter
 {
 public:
 
-    mitkClassMacro( NrrdTensorImageWriter, mitk::FileWriterWithInformation );
-
-    mitkWriterMacro;
-
-    itkFactorylessNewMacro(Self)
-    itkCloneMacro(Self)
-
     typedef mitk::TensorImage InputType;
 
-    /**
-     * Sets the filename of the file to write.
-     * @param FileName the name of the file to write.
-     */
-    itkSetStringMacro( FileName );
-
-    /**
-     * @returns the name of the file to be written to disk.
-     */
-    itkGetStringMacro( FileName );
-
-    /**
-     * @warning multiple write not (yet) supported
-     */
-    itkSetStringMacro( FilePrefix );
-
-    /**
-     * @warning multiple write not (yet) supported
-     */
-    itkGetStringMacro( FilePrefix );
-
-    /**
-     * @warning multiple write not (yet) supported
-     */
-    itkSetStringMacro( FilePattern );
-
-    /**
-     * @warning multiple write not (yet) supported
-     */
-    itkGetStringMacro( FilePattern );
-
-    /**
-     * Sets the input object for the filter.
-     * @param input the diffusion volumes to write to file.
-     */
-    using itk::ProcessObject::SetInput;
-    void SetInput( InputType* input );
-
-    /**
-     * @returns the 0'th input object of the filter.
-     */
-    InputType* GetInput();
-
-    /**
-     * Returns false if an error happened during writing
-     */
-    itkGetMacro( Success, bool );
-
-    /**
-    * @return possible file extensions for the data type associated with the writer
-    */
-    virtual std::vector<std::string> GetPossibleFileExtensions();
-
-    std::string GetSupportedBaseData() const;
-
-    // FileWriterWithInformation methods
-    virtual const char * GetDefaultFilename() { return "Tensors.dti"; }
-    virtual const char * GetFileDialogPattern() { return "Tensor Images (*.dti *.hdti)"; }
-    virtual const char * GetDefaultExtension() { return ".dti"; }
-    virtual bool CanWriteBaseDataType(BaseData::Pointer data) { return (dynamic_cast<mitk::TensorImage*>(data.GetPointer()) != NULL); };
-    virtual void DoWrite(BaseData::Pointer data) {
-      if (CanWriteBaseDataType(data)) {
-        this->SetInput(dynamic_cast<mitk::TensorImage*>(data.GetPointer()));
-        this->Update();
-      }
-    };
-
-protected:
-
     NrrdTensorImageWriter();
-
     virtual ~NrrdTensorImageWriter();
 
-    virtual void GenerateData();
-
-    std::string m_FileName;
+    using AbstractFileWriter::Write;
+    virtual void Write();
 
-    std::string m_FilePrefix;
+    virtual ConfidenceLevel GetConfidenceLevel() const;
 
-    std::string m_FilePattern;
-
-    bool m_Success;
+protected:
 
+  NrrdTensorImageWriter(const NrrdTensorImageWriter& other);
+  virtual mitk::NrrdTensorImageWriter* Clone() const;
 };
 
 
 } // end of namespace mitk
 
 #endif //_MITK_NRRDDTI_WRITER__H_
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriterFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriterFactory.cpp
deleted file mode 100644
index 7dc6ce5bca..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriterFactory.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*===================================================================
-
-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 "mitkNrrdTensorImageWriterFactory.h"
-
-#include "itkCreateObjectFunction.h"
-#include "itkVersion.h"
-
-#include <mitkNrrdTensorImageWriter.h>
-
-namespace mitk
-{
-
-//template <class T>
-//class CreateNrrdTensorImageWriter : public itk::CreateObjectFunctionBase
-//{
-//public:
-
-//  /** Standard class typedefs. */
-//  typedef CreateNrrdTensorImageWriter  Self;
-//  typedef itk::SmartPointer<Self>    Pointer;
-
-//  /** Methods from itk:LightObject. */
-//  itkFactorylessNewMacro(Self);
-//  LightObject::Pointer CreateObject() { typename T::Pointer p = T::New();
-//    p->Register();
-//    return p.GetPointer();
-//  }
-
-//protected:
-//  CreateNrrdTensorImageWriter() {}
-//  ~CreateNrrdTensorImageWriter() {}
-
-//private:
-//  CreateNrrdTensorImageWriter(const Self&); //purposely not implemented
-//  void operator=(const Self&); //purposely not implemented
-//};
-
-NrrdTensorImageWriterFactory::NrrdTensorImageWriterFactory()
-{
-  typedef short DiffusionPixelType;
-  this->RegisterOverride("IOWriter",
-                         "NrrdTensorImageWriter",
-                         "NrrdTensorImage Writer",
-                         1,
-                         itk::CreateObjectFunction< mitk::NrrdTensorImageWriter >::New());
-}
-
-NrrdTensorImageWriterFactory::~NrrdTensorImageWriterFactory()
-{
-}
-
-const char* NrrdTensorImageWriterFactory::GetITKSourceVersion() const
-{
-  return ITK_SOURCE_VERSION;
-}
-
-const char* NrrdTensorImageWriterFactory::GetDescription() const
-{
-  return "NrrdTensorImageWriterFactory";
-}
-
-} // end namespace mitk
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriterFactory.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriterFactory.h
deleted file mode 100644
index 7917b57c9d..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdTensorImageWriterFactory.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*===================================================================
-
-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 NRRDDTI_WRITERFACTORY_H_HEADER_INCLUDED
-#define NRRDDTI_WRITERFACTORY_H_HEADER_INCLUDED
-
-#include "itkObjectFactoryBase.h"
-#include "mitkBaseData.h"
-
-namespace mitk
-{
-
-class NrrdTensorImageWriterFactory : public itk::ObjectFactoryBase
-{
-public:
-
-  mitkClassMacro( mitk::NrrdTensorImageWriterFactory, itk::ObjectFactoryBase )
-
-  /** Class methods used to interface with the registered factories. */
-  virtual const char* GetITKSourceVersion(void) const;
-  virtual const char* GetDescription(void) const;
-
-  /** Method for class instantiation. */
-  itkFactorylessNewMacro(Self);
-
-  /** Register one factory of this type  */
-  static void RegisterOneFactory(void)
-  {
-    static bool IsRegistered = false;
-    if ( !IsRegistered )
-    {
-      NrrdTensorImageWriterFactory::Pointer ugVtkWriterFactory = NrrdTensorImageWriterFactory::New();
-      ObjectFactoryBase::RegisterFactory( ugVtkWriterFactory );
-      IsRegistered = true;
-    }
-  }
-
-protected:
-  NrrdTensorImageWriterFactory();
-  ~NrrdTensorImageWriterFactory();
-
-private:
-  NrrdTensorImageWriterFactory(const Self&); //purposely not implemented
-  void operator=(const Self&); //purposely not implemented
-
-};
-
-} // end namespace mitk
-
-#endif // NRRDDTI_WRITERFACTORY_H_HEADER_INCLUDED
-
-
-
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkTensorImageSerializer.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkTensorImageSerializer.cpp
index a74fc216b2..9df84889b9 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkTensorImageSerializer.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkTensorImageSerializer.cpp
@@ -1,74 +1,74 @@
 /*===================================================================
 
 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 "mitkTensorImageSerializer.h"
 #include "mitkTensorImage.h"
 #include "mitkNrrdTensorImageWriter.h"
 
 #include <itksys/SystemTools.hxx>
 
 
 MITK_REGISTER_SERIALIZER(TensorImageSerializer)
 
 
 mitk::TensorImageSerializer::TensorImageSerializer()
 {
 }
 
 
 mitk::TensorImageSerializer::~TensorImageSerializer()
 {
 }
 
 
 std::string mitk::TensorImageSerializer::Serialize()
 {
   const TensorImage* image = dynamic_cast<const TensorImage*>( m_Data.GetPointer() );
   if (image == NULL)
   {
     MITK_ERROR << " Object at " << (const void*) this->m_Data
               << " is not an mitk::NrrdTensorImage. Cannot serialize as NrrdTensorImage.";
     return "";
   }
 
   std::string filename( this->GetUniqueFilenameInWorkingDirectory() );
   filename += "_";
   filename += m_FilenameHint;
   filename += ".dti";
 
   std::string fullname(m_WorkingDirectory);
   fullname += "/";
   fullname += itksys::SystemTools::ConvertToOutputPath(filename.c_str());
 
   try
   {
-    NrrdTensorImageWriter::Pointer writer = NrrdTensorImageWriter::New();
-    writer->SetFileName(fullname);
-    writer->SetInput(const_cast<TensorImage*>(image));
-    writer->Write();
+    NrrdTensorImageWriter writer;
+    writer.SetOutputLocation(fullname);
+    writer.SetInput(const_cast<TensorImage*>(image));
+    writer.Write();
   }
   catch (std::exception& e)
   {
     MITK_ERROR << " Error serializing object at " << (const void*) this->m_Data
               << " to "
               << fullname
               << ": "
               << e.what();
     return "";
   }
   return filename;
 }