diff --git a/Modules/DiffusionImaging/CMakeLists.txt b/Modules/DiffusionImaging/CMakeLists.txt
index 948174af97..a9eabf6a88 100644
--- a/Modules/DiffusionImaging/CMakeLists.txt
+++ b/Modules/DiffusionImaging/CMakeLists.txt
@@ -1,12 +1,12 @@
 set( diffusion_module_dirs
       DiffusionCore
       FiberTracking
       Connectomics
       Quantification
 )
 
 foreach(diffusion_module_dir ${diffusion_module_dirs})
   add_subdirectory(${diffusion_module_dir})
 endforeach()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/mitkDiffusionImagingConfigure.h.in ${CMAKE_CURRENT_BINARY_DIR}/mitkDiffusionImagingConfigure.h)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/mitkDiffusionImagingConfigure.h.in ${CMAKE_CURRENT_BINARY_DIR}/DiffusionCore/mitkDiffusionImagingConfigure.h)
diff --git a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsObjectFactory.cpp b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsObjectFactory.cpp
index 0f9ea00226..f74c38c264 100644
--- a/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsObjectFactory.cpp
+++ b/Modules/DiffusionImaging/Connectomics/IODataStructures/mitkConnectomicsObjectFactory.cpp
@@ -1,121 +1,121 @@
 /*===================================================================
 
 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 "mitkConnectomicsObjectFactory.h"
 
 #include "mitkConnectomicsNetwork.h"
 #include "mitkConnectomicsNetworkIOFactory.h"
 #include "mitkConnectomicsNetworkWriter.h"
 #include "mitkConnectomicsNetworkWriterFactory.h"
 #include "mitkConnectomicsNetworkMapper3D.h"
 
 mitk::ConnectomicsObjectFactory::ConnectomicsObjectFactory(bool /*registerSelf*/)
   : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "ConnectomicsObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
     mitk::ConnectomicsNetworkIOFactory::RegisterOneFactory();
 
     mitk::ConnectomicsNetworkWriterFactory::RegisterOneFactory();
 
     m_FileWriters.push_back( mitk::ConnectomicsNetworkWriter::New().GetPointer() );
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::Mapper::Pointer mitk::ConnectomicsObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard3D )
   {
-    classname = "ConnectomicsNetwork";
+    std::string classname("ConnectomicsNetwork");
     if (node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::ConnectomicsNetworkMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
   }
 
   return newMapper;
 }
 
 void mitk::ConnectomicsObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
-  classname = "ConnectomicsNetwork";
+  std::string classname("ConnectomicsNetwork");
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::ConnectomicsNetworkMapper3D::SetDefaultProperties(node);
   }
 }
 
 const char* mitk::ConnectomicsObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::ConnectomicsObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::ConnectomicsObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::ConnectomicsObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::ConnectomicsObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.cnf", "Connectomics Network File"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.cnf", "Connectomics Network File"));
 }
 
 void mitk::ConnectomicsObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterConnectomicsObjectFactory()
 {
   static bool oneConnectomicsObjectFactoryRegistered = false;
   if ( ! oneConnectomicsObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering ConnectomicsObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::ConnectomicsObjectFactory::New());
 
     oneConnectomicsObjectFactoryRegistered = true;
   }
 }
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/mitkDiffusionCoreObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/mitkDiffusionCoreObjectFactory.cpp
index 625eeaff52..4a8a868b18 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/mitkDiffusionCoreObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/mitkDiffusionCoreObjectFactory.cpp
@@ -1,275 +1,277 @@
 /*===================================================================
 
 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 "mitkNrrdDiffusionImageIOFactory.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"
 
+#include "mitkPlanarFigureMapper3D.h"
+
 
 typedef short DiffusionPixelType;
 
 typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionCoreObjectFactory::DiffusionCoreObjectFactory(bool /*registerSelf*/)
   :CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "DiffusionCoreObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
     mitk::NrrdDiffusionImageIOFactory::RegisterOneFactory();
     mitk::NrrdQBallImageIOFactory::RegisterOneFactory();
     mitk::NrrdTensorImageIOFactory::RegisterOneFactory();
 
     mitk::NrrdDiffusionImageWriterFactory::RegisterOneFactory();
     mitk::NrrdQBallImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTensorImageWriterFactory::RegisterOneFactory();
 
     m_FileWriters.push_back( NrrdDiffusionImageWriter<DiffusionPixelType>::New().GetPointer() );
     m_FileWriters.push_back( NrrdQBallImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTensorImageWriter::New().GetPointer() );
 
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 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);
     }
 
     classname =  "PlanarRectangle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarFigureMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname =  "PlanarCircle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarFigureMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname =  "PlanarEllipse";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarFigureMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "PlanarPolygon";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarFigureMapper3D::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);
   }
 
 
   classname = "PlanarRectangle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarFigureMapper3D::SetDefaultProperties(node);
   }
 
   classname = "PlanarEllipse";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarFigureMapper3D::SetDefaultProperties(node);
   }
 
   classname = "PlanarCircle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarFigureMapper3D::SetDefaultProperties(node);
   }
 
   classname = "PlanarPolygon";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarFigureMapper3D::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>("*.dwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   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"));
 
 }
 
 void mitk::DiffusionCoreObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterDiffusionCoreObjectFactory()
 {
   static bool oneDiffusionCoreObjectFactoryRegistered = false;
   if ( ! oneDiffusionCoreObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering DiffusionCoreObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionCoreObjectFactory::New());
 
     oneDiffusionCoreObjectFactoryRegistered = true;
   }
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkPlanarFigureMapper3D.cpp b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkPlanarFigureMapper3D.cpp
similarity index 100%
rename from Modules/DiffusionImaging/FiberTracking/Rendering/mitkPlanarFigureMapper3D.cpp
rename to Modules/DiffusionImaging/DiffusionCore/Rendering/mitkPlanarFigureMapper3D.cpp
diff --git a/Modules/DiffusionImaging/FiberTracking/Rendering/mitkPlanarFigureMapper3D.h b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkPlanarFigureMapper3D.h
similarity index 100%
rename from Modules/DiffusionImaging/FiberTracking/Rendering/mitkPlanarFigureMapper3D.h
rename to Modules/DiffusionImaging/DiffusionCore/Rendering/mitkPlanarFigureMapper3D.h
diff --git a/Modules/DiffusionImaging/DiffusionCore/files.cmake b/Modules/DiffusionImaging/DiffusionCore/files.cmake
index 350df17a44..75d68664b5 100644
--- a/Modules/DiffusionImaging/DiffusionCore/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/files.cmake
@@ -1,114 +1,116 @@
 set(CPP_FILES
 
   # DicomImport
   DicomImport/mitkDicomDiffusionImageReader.cpp
   DicomImport/mitkGroupDiffusionHeadersFilter.cpp
   DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
 
   # DataStructures
   IODataStructures/mitkDiffusionCoreObjectFactory.cpp
 
   # DataStructures -> DWI
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageReader.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriter.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageIOFactory.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriterFactory.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSerializer.cpp
 
   # DataStructures -> QBall
   IODataStructures/QBallImages/mitkQBallImageSource.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageWriter.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageIOFactory.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageWriterFactory.cpp
   IODataStructures/QBallImages/mitkQBallImage.cpp
   IODataStructures/QBallImages/mitkQBallImageSerializer.cpp
 
   # DataStructures -> Tensor
   IODataStructures/TensorImages/mitkTensorImageSource.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageWriter.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageIOFactory.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageWriterFactory.cpp
   IODataStructures/TensorImages/mitkTensorImage.cpp
   IODataStructures/TensorImages/mitkTensorImageSerializer.cpp
 
   # Rendering
   Rendering/vtkMaskedProgrammableGlyphFilter.cpp
   Rendering/mitkCompositeMapper.cpp
   Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
   Rendering/vtkOdfSource.cxx
   Rendering/vtkThickPlane.cxx
   Rendering/mitkOdfNormalizationMethodProperty.cpp
   Rendering/mitkOdfScaleByProperty.cpp
+  Rendering/mitkPlanarFigureMapper3D.cpp
 
   # Algorithms
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
 
   # Function Collection
   mitkDiffusionFunctionCollection.cpp
 )
 
 set(H_FILES
   # function Collection
   mitkDiffusionFunctionCollection.h
 
   # Rendering
   Rendering/mitkDiffusionImageMapper.h
   Rendering/mitkOdfVtkMapper2D.h
+  Rendering/mitkPlanarFigureMapper3D.h
 
   # Reconstruction
   Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
   Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
   Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
   Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
   Algorithms/Reconstruction/itkPointShell.h
   Algorithms/Reconstruction/itkOrientationDistributionFunction.h
   Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
 
   # IO Datastructures
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
 
   # Algorithms
   Algorithms/itkDiffusionQballGeneralizedFaImageFilter.h
   Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.h
   Algorithms/itkTensorDerivedMeasurementsFilter.h
   Algorithms/itkBrainMaskExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionToSeparateImageFilter.h
   Algorithms/itkTensorImageToDiffusionImageFilter.h
   Algorithms/itkTensorToL2NormImageFilter.h
   Algorithms/itkGaussianInterpolateImageFunction.h
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
   Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
   Algorithms/itkCartesianToPolarVectorImageFilter.h
   Algorithms/itkPolarToCartesianVectorImageFilter.h
   Algorithms/itkDistanceMapFilter.h
   Algorithms/itkProjectionFilter.h
   Algorithms/itkResidualImageFilter.h
   Algorithms/itkExtractChannelFromRgbaImageFilter.h
   Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
   Algorithms/itkMergeDiffusionImagesFilter.h
   Algorithms/itkDwiPhantomGenerationFilter.h
   Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
   Algorithms/itkMrtrixPeakImageConverter.h
   Algorithms/itkFslPeakImageConverter.h
   Algorithms/itkFslShCoefficientImageConverter.h
   Algorithms/itkOdfMaximaExtractionFilter.h
   Algorithms/itkResampleDwiImageFilter.h
 
 
 
 )
 
 set( TOOL_FILES
 )
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h
index 412f4f263b..ccedb1ce6b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/mitkTractAnalyzer.h
@@ -1,149 +1,155 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __mitkTractAnalyzer_h_
 #define __mitkTractAnalyzer_h_
 
 #include "FiberTrackingExports.h"
 #include <itkImage.h>
-#include <mitkTbssImage.h>
+#include <itkVectorImage.h>
+#include "mitkImage.h"
+#include "mitkImageCast.h"
+
+//#include <mitkTbssImage.h>
 
 
 namespace mitk{
 /** \class TractAnalyzer
  */
 
 
 class FiberTracking_EXPORT TractAnalyzer
 {
 
 public:
 
 
   TractAnalyzer();
   ~TractAnalyzer() {};
 
   typedef itk::Image<char,3> CharImageType;
   typedef itk::Image<float,3> FloatImageType;
   typedef itk::Image<float,4> ProjectionsImageType;
   typedef itk::VectorImage<float, 3> VectorImageType;
 
 
 
   /*
   void SetSkeleton(CharImageType::Pointer skeleton)
   {
     m_Skeleton = skeleton;
   }
 
   void SetMeanSkeleton(FloatImageType::Pointer i)
   {
     m_MeanSkeleton = i;
   }*/
 
 
+  /* Unused method - would introduce circular dependency to the new module structure
+   * of the diffusion imaging
   void SetTbssImage(mitk::TbssImage::Pointer tbssImg)
   {
     m_TbssImage = tbssImg;
-  }
+  }*/
 
   void SetProjections(ProjectionsImageType::Pointer projections)
   {
     m_Projections = projections;
   }
 
   void BuildGraph(itk::Index<3> startPoint, itk::Index<3> endPoint);
 
   std::vector< itk::Index<3> > GetPath()
   {
     return m_Path;
   }
 
   void SetFileName(std::string fname)
   {
     m_FileName = fname;
   }
 
   void SetFileNameLong(std::string fname)
   {
     m_FileNameLong = fname;
   }
 
   void SetRoi(std::vector< itk::Index<3> > roi)
   {
     m_Roi = roi;
   }
 
   CharImageType::Pointer GetRoiImage()
   {
     return m_RoiImg;
   }
 
   void SetGroups(std::vector< std::pair<std::string, int> > groups)
   {
     m_Groups = groups;
   }
 
   void MeasureRoi();
 
   void SetInputImage(mitk::Image::Pointer inputImage)
   {
     m_InputImage = inputImage;
   }
 
 
   void SetThreshold(double threshold)
   {
     m_Threshold = threshold;
   }
 
 
 protected:
 
 
   //CharImageType::Pointer m_Skeleton;
   CharImageType::Pointer m_RoiImg;
   ProjectionsImageType::Pointer m_Projections;
   //FloatImageType::Pointer m_MeanSkeleton;
-  mitk::TbssImage::Pointer m_TbssImage;
+  //mitk::TbssImage::Pointer m_TbssImage;
 
   mitk::Image::Pointer m_InputImage;
 
   double m_Threshold;
 
   std::vector< itk::Index<3> > m_Path;
 
   std::string m_FileName;
 
   std::string m_FileNameLong; // For the regression analysis 'friendly' file
 
   std::vector< std::pair<std::string, int> > m_Groups;
 
   std::vector< itk::Index<3> > m_Roi;
 
 private:
 
 };
 
 }
 
 #endif //__itkTractAnalyzer_h_
 
diff --git a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
index 49f3cfe574..277ee84596 100644
--- a/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/CMakeLists.txt
@@ -1,13 +1,13 @@
 MITK_CREATE_MODULE( FiberTracking
   INCLUDE_DIRS Algorithms Algorithms/GibbsTracking Algorithms/StochasticTracking IODataStructures/FiberBundleX IODataStructures/PlanarFigureComposite Interactions SignalModels Rendering ${CMAKE_CURRENT_BINARY_DIR}
-  DEPENDS DiffusionCore
+  DEPENDS DiffusionCore MitkGraphAlgorithms
 )
 
 if(FiberTracking_IS_ENABLED)
   file(DOWNLOAD http://mitk.org/download/data/FibertrackingLUT.tar.gz ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FibertrackingLUT.tar.gz TIMEOUT 10)
   execute_process(COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} tar xzf FibertrackingLUT.tar.gz)
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Rendering/mitkShaderFiberClipping.xml ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/mitkShaderFiberClipping.xml)
   MITK_INSTALL(FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/mitkShaderFiberClipping.xml ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FiberTrackingLUTBaryCoords.bin ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/FiberTrackingLUTIndices.bin)
 endif()
 
 add_subdirectory(Testing)
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberTrackingObjectFactory.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberTrackingObjectFactory.cpp
index b394f41f99..7ff0166236 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberTrackingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberTrackingObjectFactory.cpp
@@ -1,124 +1,124 @@
 #include "mitkFiberTrackingObjectFactory.h"
 
 
 mitk::FiberTrackingObjectFactory::FiberTrackingObjectFactory(bool /*registerSelf*/)
   :CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "FiberTrackingObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
     mitk::FiberBundleXIOFactory::RegisterOneFactory(); //modernized
 
     mitk::FiberBundleXWriterFactory::RegisterOneFactory();//modernized
 
     m_FileWriters.push_back( mitk::FiberBundleXWriter::New().GetPointer() );//modernized
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::Mapper::Pointer mitk::FiberTrackingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
-    classname = "FiberBundleX";
+    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 )
   {
-    classname = "FiberBundleX";
+    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)
 {
-  classname = "FiberBundleX";
+  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()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle"));
 }
 
 void mitk::FiberTrackingObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterFiberTrackingObjectFactory()
 {
   static bool oneFiberTrackingObjectFactoryRegistered = false;
   if ( ! oneFiberTrackingObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering FiberTrackingObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::FiberTrackingObjectFactory::New());
 
     oneFiberTrackingObjectFactoryRegistered = true;
   }
 }
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake
index 99db322608..c8ca444ac1 100644
--- a/Modules/DiffusionImaging/FiberTracking/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/files.cmake
@@ -1,86 +1,86 @@
 set(CPP_FILES
 
 # DataStructures -> FiberBundleX
   IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXWriter.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
 
   # DataStructures -> PlanarFigureComposite
   IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
 
   # DataStructures
   IODataStructures/mitkFiberTrackingObjectFactory.cpp
 
   # Rendering
   Rendering/mitkFiberBundleXMapper2D.cpp
   Rendering/mitkFiberBundleXMapper3D.cpp
   Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
-  Rendering/mitkPlanarFigureMapper3D.cpp
+  #Rendering/mitkPlanarFigureMapper3D.cpp
 
   # Interactions
   Interactions/mitkFiberBundleInteractor.cpp
 
   # Algorithms
   Algorithms/mitkTractAnalyzer.cpp
 
   # Tractography
   Algorithms/GibbsTracking/mitkParticleGrid.cpp
   Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp
   Algorithms/GibbsTracking/mitkEnergyComputer.cpp
   Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp
   Algorithms/GibbsTracking/mitkFiberBuilder.cpp
 )
 
 set(H_FILES
   # Rendering
   Rendering/mitkFiberBundleXMapper3D.h
   Rendering/mitkFiberBundleXMapper2D.h
   Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
-  Rendering/mitkPlanarFigureMapper3D.h
+  #Rendering/mitkPlanarFigureMapper3D.h
 
   # DataStructures -> FiberBundleX
   IODataStructures/FiberBundleX/mitkFiberBundleX.h
   IODataStructures/FiberBundleX/mitkFiberBundleXWriter.h
   IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
   IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.h
   IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.h
   IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.h
   IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
 
   # Algorithms
   Algorithms/itkTractDensityImageFilter.h
   Algorithms/itkTractsToFiberEndingsImageFilter.h
   Algorithms/itkTractsToRgbaImageFilter.h
   Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
   Algorithms/itkFibersFromPlanarFiguresFilter.h
   Algorithms/itkTractsToDWIImageFilter.h
   Algorithms/itkTractsToVectorImageFilter.h
 
   # (old) Tractography
   Algorithms/itkGibbsTrackingFilter.h
   Algorithms/itkStochasticTractographyFilter.h
   Algorithms/itkStreamlineTrackingFilter.h
   Algorithms/GibbsTracking/mitkParticle.h
   Algorithms/GibbsTracking/mitkParticleGrid.h
   Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h
   Algorithms/GibbsTracking/mitkSimpSamp.h
   Algorithms/GibbsTracking/mitkEnergyComputer.h
   Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h
   Algorithms/GibbsTracking/mitkSphereInterpolator.h
   Algorithms/GibbsTracking/mitkFiberBuilder.h
 
   # Signal Models
   SignalModels/mitkDiffusionSignalModel.h
   SignalModels/mitkTensorModel.h
   SignalModels/mitkBallModel.h
   SignalModels/mitkStickModel.h
   SignalModels/mitkDiffusionNoiseModel.h
   SignalModels/mitkRicianNoiseModel.h
   SignalModels/mitkKspaceArtifact.h
   SignalModels/mitkGibbsRingingArtifact.h
   SignalModels/mitkT2SmearingArtifact.h
 )
\ No newline at end of file
diff --git a/Modules/DiffusionImaging/Quantification/IODataStructures/mitkQuantificationObjectFactory.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/mitkQuantificationObjectFactory.cpp
index 536c061788..12045d0c3e 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/mitkQuantificationObjectFactory.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/mitkQuantificationObjectFactory.cpp
@@ -1,165 +1,168 @@
 /*===================================================================
 
 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 "mitkQuantificationObjectFactory.h"
 
 #include "mitkTbssImageMapper.h"
 
 #include "mitkNrrdTbssImageIOFactory.h"
 #include "mitkNrrdTbssImageWriterFactory.h"
 #include "mitkNrrdTbssImageWriter.h"
 
 #include "mitkNrrdTbssRoiImageIOFactory.h"
 #include "mitkNrrdTbssRoiImageWriterFactory.h"
 #include "mitkNrrdTbssRoiImageWriter.h"
 
+#include "mitkVolumeDataVtkMapper3D.h"
+#include "mitkGPUVolumeMapper3D.h"
+
 typedef char TbssRoiPixelType;
 typedef float TbssPixelType;
 typedef int TbssGradientPixelType;
 
 mitk::QuantificationObjectFactory::QuantificationObjectFactory(bool /*registerSelf*/)
 :CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "QuantificationObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
     mitk::NrrdTbssImageIOFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageIOFactory::RegisterOneFactory();
 
     mitk::NrrdTbssImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageWriterFactory::RegisterOneFactory();
 
     m_FileWriters.push_back( NrrdTbssImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTbssRoiImageWriter::New().GetPointer() );
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::Mapper::Pointer mitk::QuantificationObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
-    classname = "TbssRoiImage";
+    std::string classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::ImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
-    classname = "TbssRoiImage";
+    std::string classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::VolumeDataVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
   }
 
   return newMapper;
 }
 
 void mitk::QuantificationObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
-  classname = "TbssRoiImage";
+  std::string classname = "TbssRoiImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TbssImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::TbssImageMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 }
 
 const char* mitk::QuantificationObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::QuantificationObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::QuantificationObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::QuantificationObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::QuantificationObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
 }
 
 void mitk::QuantificationObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterQuantificationObjectFactory()
 {
   static bool oneQuantificationObjectFactoryRegistered = false;
   if ( ! oneQuantificationObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering QuantificationObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::QuantificationObjectFactory::New());
 
     oneQuantificationObjectFactoryRegistered = true;
   }
 }
diff --git a/Plugins/org.mitk.diffusionimaging/CMakeLists.txt b/Plugins/org.mitk.diffusionimaging/CMakeLists.txt
index 10174a592c..e3f87fa0f0 100644
--- a/Plugins/org.mitk.diffusionimaging/CMakeLists.txt
+++ b/Plugins/org.mitk.diffusionimaging/CMakeLists.txt
@@ -1,7 +1,7 @@
 project(org_mitk_diffusionimaging)
 
 MACRO_CREATE_MITK_CTK_PLUGIN(
   EXPORT_DIRECTIVE ORG_MITK_DIFFUSIONIMAGING_EXPORT
   EXPORTED_INCLUDE_SUFFIXES src
-  MODULE_DEPENDENCIES MitkDiffusionImaging QmitkExt
+  MODULE_DEPENDENCIES DiffusionCore QmitkExt
 )
diff --git a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
index 9afbffda13..548fbed611 100644
--- a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
+++ b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
@@ -1,62 +1,62 @@
 /*===================================================================
 
 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 "mitkDiffusionImagingActivator.h"
-#include "mitkDiffusionImagingObjectFactory.h"
+#include "mitkDiffusionCoreObjectFactory.h"
 
 #include "QmitkNodeDescriptorManager.h"
 #include "mitkNodePredicateDataType.h"
 
 #include <QtPlugin>
 
 void
 mitk::DiffusionImagingActivator::start(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 
-  RegisterDiffusionImagingObjectFactory();
+  RegisterDiffusionCoreObjectFactory();
 
   QmitkNodeDescriptorManager* manager =
     QmitkNodeDescriptorManager::GetInstance();
 
   mitk::NodePredicateDataType::Pointer isDiffusionImage = mitk::NodePredicateDataType::New("DiffusionImage");
   QmitkNodeDescriptor* desc = new QmitkNodeDescriptor(QObject::tr("DiffusionImage"), QString(":/QmitkDiffusionImaging/QBallData24.png"), isDiffusionImage, manager);
   manager->AddDescriptor(desc);
 
   mitk::NodePredicateDataType::Pointer isTensorImage = mitk::NodePredicateDataType::New("TensorImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("TensorImage"), QString(":/QmitkDiffusionImaging/recontensor.png"), isTensorImage, manager));
 
   mitk::NodePredicateDataType::Pointer isQBallImage = mitk::NodePredicateDataType::New("QBallImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("QBallImage"), QString(":/QmitkDiffusionImaging/reconodf.png"), isQBallImage, manager));
-
+/*
   mitk::NodePredicateDataType::Pointer isFiberBundle = mitk::NodePredicateDataType::New("FiberBundle");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundle"), QString(":/QmitkDiffusionImaging/FiberBundle.png"), isFiberBundle, manager));
 
   mitk::NodePredicateDataType::Pointer isFiberBundleX = mitk::NodePredicateDataType::New("FiberBundleX");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundleX"), QString(":/QmitkDiffusionImaging/FiberBundleX.png"), isFiberBundleX, manager));
 
   mitk::NodePredicateDataType::Pointer isConnectomicsNetwork = mitk::NodePredicateDataType::New("ConnectomicsNetwork");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("ConnectomicsNetwork"), QString(":/QmitkDiffusionImaging/ConnectomicsNetwork.png"), isConnectomicsNetwork, manager));
-
+*/
 }
 
 void
 mitk::DiffusionImagingActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 Q_EXPORT_PLUGIN2(org_mitk_diffusionimaging, mitk::DiffusionImagingActivator)
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt b/Plugins/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt
index 0b6fabcce4..0d9ded573b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/CMakeLists.txt
@@ -1,7 +1,7 @@
 project(org_mitk_gui_qt_diffusionimaging)
 
 MACRO_CREATE_MITK_CTK_PLUGIN(
   EXPORT_DIRECTIVE DIFFUSIONIMAGING_EXPORT
   EXPORTED_INCLUDE_SUFFIXES src
-  MODULE_DEPENDENCIES QmitkExt MitkDiffusionImaging
+  MODULE_DEPENDENCIES QmitkExt Connectomics FiberTracking DiffusionCore Quantification
 )