diff --git a/CMake/mitkInstallRules.cmake b/CMake/mitkInstallRules.cmake
index 1a0692cc42..01d2b71efc 100644
--- a/CMake/mitkInstallRules.cmake
+++ b/CMake/mitkInstallRules.cmake
@@ -1,193 +1,193 @@
 MITK_INSTALL(FILES "${MITK_SOURCE_DIR}/mitk.ico")
 MITK_INSTALL(FILES "${MITK_SOURCE_DIR}/mitk.bmp")
 
 # Install CTK Qt (designer) plugins
 if(MITK_USE_CTK)
   if(EXISTS ${CTK_QTDESIGNERPLUGINS_DIR})
     set(_qtplugin_install_destinations)
     if(MACOSX_BUNDLE_NAMES)
       foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
         list(APPEND _qtplugin_install_destinations
              ${bundle_name}.app/Contents/MacOS/${_install_DESTINATION}/plugins/designer)
       endforeach()
     else()
       list(APPEND _qtplugin_install_destinations bin/plugins/designer)
     endif()
 
     set(_ctk_qt_plugin_folder_release)
     set(_ctk_qt_plugin_folder_debug)
     if(NOT CMAKE_CFG_INTDIR STREQUAL ".")
       set(_ctk_qt_plugin_folder_release "Release/")
       set(_ctk_qt_plugin_folder_debug "Debug/")
     endif()
 
     foreach(_qtplugin_install_dir ${_qtplugin_install_destinations})
       install(DIRECTORY "${CTK_QTDESIGNERPLUGINS_DIR}/designer/${_ctk_qt_plugin_folder_release}"
               DESTINATION ${_qtplugin_install_dir}
               CONFIGURATIONS Release
               )
       install(DIRECTORY "${CTK_QTDESIGNERPLUGINS_DIR}/designer/${_ctk_qt_plugin_folder_debug}"
               DESTINATION ${_qtplugin_install_dir}
               CONFIGURATIONS Debug
               )
     endforeach()
   endif()
 endif()
 
 # related to MITK:T19679
 if(MACOSX_BUNDLE_NAMES)
   foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
     get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
                  PROPERTY IMPORT_LOCATION)
     get_filename_component(_qmake_path "${_qmake_location}" DIRECTORY)
     install(FILES "${_qmake_path}/../plugins/platforms/libqcocoa.dylib"
             DESTINATION "${bundle_name}.app/Contents/MacOS/platforms"
             CONFIGURATIONS Release)
     install(FILES "${_qmake_path}/../plugins/sqldrivers/libqsqlite.dylib"
             DESTINATION "${bundle_name}.app/Contents/MacOS/sqldrivers"
             CONFIGURATIONS Release)
     install(FILES "${_qmake_path}/../plugins/iconengines/libqsvgicon.dylib"
             DESTINATION "${bundle_name}.app/Contents/MacOS/iconengines"
             CONFIGURATIONS Release)
     # related to MITK:T19679-InstallQtWebEnginProcess
     if(MITK_USE_Qt5_WebEngine)
         get_filename_component(ABS_DIR_HELPERS "${_qmake_path}/../lib/QtWebEngineCore.framework/Helpers" REALPATH)
         install(DIRECTORY ${ABS_DIR_HELPERS}
                 DESTINATION "${bundle_name}.app/Contents/Frameworks/QtWebEngineCore.framework/"
                 CONFIGURATIONS Release)
     endif()
   endforeach()
 endif()
 
 if(WIN32)
   if(MITK_USE_Qt5)
     get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
                  PROPERTY IMPORT_LOCATION)
     get_filename_component(_qmake_path "${_qmake_location}" DIRECTORY)
     install(FILES "${_qmake_path}/../plugins/platforms/qwindows.dll"
             DESTINATION "bin/plugins/platforms"
             CONFIGURATIONS Release)
     install(FILES "${_qmake_path}/../plugins/sqldrivers/qsqlite.dll"
             DESTINATION "bin/plugins/sqldrivers"
             CONFIGURATIONS Release)
     install(FILES "${_qmake_path}/../plugins/imageformats/qsvg.dll"
             DESTINATION "bin/plugins/imageformats"
             CONFIGURATIONS Release)
     install(FILES "${_qmake_path}/../plugins/iconengines/qsvgicon.dll"
             DESTINATION "bin/plugins/iconengines"
             CONFIGURATIONS Release)
     if(MITK_USE_Qt5_WebEngine)
       MITK_INSTALL( FILES "${_qmake_path}/QtWebEngineProcess.exe")
     endif()
     install(DIRECTORY "${_qmake_path}/../resources/"
             DESTINATION "bin/resources/"
             CONFIGURATIONS Release)
     install(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales/"
             DESTINATION "bin/translations/qtwebengine_locales/"
             CONFIGURATIONS Release)
     install(FILES "${_qmake_path}/../plugins/platforms/qwindowsd.dll"
             DESTINATION "bin/plugins/platforms"
             CONFIGURATIONS Debug)
     install(FILES "${_qmake_path}/../plugins/sqldrivers/qsqlited.dll"
             DESTINATION "bin/plugins/sqldrivers"
             CONFIGURATIONS Debug)
     install(FILES "${_qmake_path}/../plugins/imageformats/qsvgd.dll"
             DESTINATION "bin/plugins/imageformats"
             CONFIGURATIONS Debug)
     install(FILES "${_qmake_path}/../plugins/iconengines/qsvgicond.dll"
             DESTINATION "bin/plugins/iconengines"
             CONFIGURATIONS Debug)
     install(DIRECTORY "${_qmake_path}/../resources/"
             DESTINATION "bin/resources/"
             CONFIGURATIONS Debug)
     install(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales/"
             DESTINATION "bin/translations/qtwebengine_locales/"
             CONFIGURATIONS Debug)
   endif()
 
   #DCMTK Dlls install target (shared libs on gcc only)
   if(MINGW AND DCMTK_ofstd_LIBRARY)
     set(_dcmtk_libs
         ${DCMTK_dcmdata_LIBRARY}
         ${DCMTK_dcmimgle_LIBRARY}
         ${DCMTK_dcmnet_LIBRARY}
         ${DCMTK_ofstd_LIBRARY}
        )
 
     foreach(_dcmtk_lib ${_dcmtk_libs})
       MITK_INSTALL(FILES ${_dcmtk_lib} )
     endforeach()
   endif()
 
   #MinGW dll
   if(MINGW)
     find_library(MINGW_RUNTIME_DLL "mingwm10.dll" HINTS ${CMAKE_FIND_ROOT_PATH}/sys-root/mingw/bin)
     if(MINGW_RUNTIME_DLL)
       MITK_INSTALL(FILES ${MINGW_RUNTIME_DLL} )
     else()
       message(SEND_ERROR "Could not find mingwm10.dll which is needed for a proper install")
     endif()
 
     find_library(MINGW_GCC_RUNTIME_DLL "libgcc_s_dw2-1.dll" HINTS ${CMAKE_FIND_ROOT_PATH}/sys-root/mingw/bin)
     if(MINGW_GCC_RUNTIME_DLL)
       MITK_INSTALL(FILES ${MINGW_GCC_RUNTIME_DLL} )
     else()
       message(SEND_ERROR "Could not find libgcc_s_dw2-1.dll which is needed for a proper install")
     endif()
   endif()
 
 else()
 
   #DCMTK Dlls install target (shared libs on gcc only)
   if(DCMTK_ofstd_LIBRARY)
     set(_dcmtk_libs
         ${DCMTK_dcmdata_LIBRARY}
         ${DCMTK_dcmimgle_LIBRARY}
         ${DCMTK_dcmnet_LIBRARY}
         ${DCMTK_ofstd_LIBRARY}
     )
     foreach(_dcmtk_lib ${_dcmtk_libs})
       #MITK_INSTALL(FILES ${_dcmtk_lib} DESTINATION lib)
     endforeach()
   endif()
 
 # We need to install Webengineprocess and related files on unix as well
   if(UNIX)
     if(MITK_USE_Qt5)
       get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE}
                  PROPERTY IMPORT_LOCATION)
       get_filename_component(_qmake_path "${_qmake_location}" DIRECTORY)
 
       install(FILES "${_qmake_path}/../plugins/platforms/libqxcb.so"
               DESTINATION "bin/plugins/platforms")
       install(FILES "${_qmake_path}/../plugins/sqldrivers/libqsqlite.so"
               DESTINATION "bin/plugins/sqldrivers")
       install(FILES "${_qmake_path}/../plugins/imageformats/libqsvg.so"
               DESTINATION "bin/plugins/imageformats")
       install(FILES "${_qmake_path}/../plugins/iconengines/libqsvgicon.so"
               DESTINATION "bin/plugins/iconengines")
       install(FILES "${_qmake_path}/../plugins/xcbglintegrations/libqxcb-glx-integration.so"
-              DESTINATION "bin/plugins/iconengines")
+              DESTINATION "bin/plugins/xcbglintegrations")
 
       if(MITK_USE_Qt5_WebEngine)
         MITK_INSTALL_HELPER_APP( EXECUTABLES "${_qmake_path}/../libexec/QtWebEngineProcess")
       endif()
 
       install(DIRECTORY "${_qmake_path}/../resources/"
               DESTINATION "bin/resources/")
       install(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales/"
               DESTINATION "bin/translations/qtwebengine_locales/")
     endif()
   endif()
 
 endif()
 
 #install Matchpoint libs that are currently not auto detected
 if(MITK_USE_MatchPoint)
   install(DIRECTORY "${MITK_EXTERNAL_PROJECT_PREFIX}/bin/"
             DESTINATION "bin"
             FILES_MATCHING PATTERN "MAPUtilities*")
   install(DIRECTORY "${MITK_EXTERNAL_PROJECT_PREFIX}/bin/"
             DESTINATION "bin"
             FILES_MATCHING PATTERN "MAPAlgorithms*")
 endif()
diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index 20174ef77d..209e2cf4ff 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,36 +1,38 @@
 set(CPP_FILES
   mitkDiffusionModuleActivator.cpp
   mitkNrrdTbssImageWriterFactory.cpp
   #mitkFiberBundleIOFactory.cpp
   mitkConnectomicsNetworkReader.cpp
   mitkConnectomicsNetworkWriter.cpp
   mitkConnectomicsNetworkCSVWriter.cpp
   mitkConnectomicsNetworkMatrixWriter.cpp
   mitkConnectomicsNetworkSerializer.cpp
   mitkConnectomicsNetworkDefinitions.cpp
   mitkNrrdTbssRoiImageIOFactory.cpp
   #mitkFiberBundleWriterFactory.cpp
   mitkNrrdTbssRoiImageWriterFactory.cpp
   mitkFiberTrackingObjectFactory.cpp
   mitkConnectomicsObjectFactory.cpp
   mitkQuantificationObjectFactory.cpp
   mitkNrrdTbssImageIOFactory.cpp
 
   mitkDiffusionIOMimeTypes.cpp
 
   mitkFiberBundleTckReader.cpp
   mitkFiberBundleTrackVisReader.cpp
   mitkFiberBundleTrackVisWriter.cpp
   mitkFiberBundleVtkReader.cpp
   mitkFiberBundleVtkWriter.cpp
   mitkFiberBundleSerializer.cpp
   mitkFiberBundleMapper2D.cpp
   mitkFiberBundleMapper3D.cpp
+  
   mitkTractographyForestReader.cpp
   mitkTractographyForestWriter.cpp
+  mitkTractographyForestSerializer.cpp
 
   mitkPlanarFigureCompositeWriter.cpp
   mitkPlanarFigureCompositeReader.cpp
   mitkPlanarFigureCompositeSerializer.cpp
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h b/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h
index 24184e2a5f..28e9b29a5e 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h
@@ -1,39 +1,39 @@
 /*===================================================================
 
 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 mitkPlanarFigureCompositeSerializer_h_included
 #define mitkPlanarFigureCompositeSerializer_h_included
 
 #include "mitkBaseDataSerializer.h"
 
 namespace mitk
 {
 /**
-  \brief Serializes mitk::Surface for mitk::SceneIO
+  \brief Serializes mitk::PlanarFigureComposite for mitk::SceneIO
 */
 class PlanarFigureCompositeSerializer : public BaseDataSerializer
 {
   public:
     mitkClassMacro( PlanarFigureCompositeSerializer, BaseDataSerializer );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     virtual std::string Serialize() override;
   protected:
     PlanarFigureCompositeSerializer();
     virtual ~PlanarFigureCompositeSerializer();
 };
 } // namespace
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkTractographyForestSerializer.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkTractographyForestSerializer.cpp
new file mode 100644
index 0000000000..b26c6ce347
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkTractographyForestSerializer.cpp
@@ -0,0 +1,73 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTractographyForestSerializer.h"
+#include "mitkTractographyForest.h"
+#include "mitkTractographyForestWriter.h"
+#include <mitkTractographyForest.h>
+
+#include <itksys/SystemTools.hxx>
+#include <mitkIOUtil.h>
+
+
+MITK_REGISTER_SERIALIZER(TractographyForestSerializer)
+
+
+mitk::TractographyForestSerializer::TractographyForestSerializer()
+{
+}
+
+
+mitk::TractographyForestSerializer::~TractographyForestSerializer()
+{
+}
+
+
+std::string mitk::TractographyForestSerializer::Serialize()
+{
+  const TractographyForest* fb = dynamic_cast<const TractographyForest*>( m_Data.GetPointer() );
+  if (fb == nullptr)
+  {
+    MITK_ERROR << " Object at " << (const void*) this->m_Data
+              << " is not an mitk::TractographyForest. Cannot serialize as TractographyForest.";
+    return "";
+  }
+
+  std::string filename( this->GetUniqueFilenameInWorkingDirectory() );
+  filename += "_";
+  filename += m_FilenameHint;
+  filename += ".rf";
+
+  std::string fullname(m_WorkingDirectory);
+  fullname += "/";
+  fullname += itksys::SystemTools::ConvertToOutputPath(filename.c_str());
+
+  try
+  {
+    mitk::IOUtil::Save(fb,fullname);
+  }
+  catch (std::exception& e)
+  {
+    MITK_ERROR << " Error serializing object at " << (const void*) this->m_Data
+              << " to "
+              << fullname
+              << ": "
+              << e.what();
+    return "";
+  }
+  return filename;
+}
+
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h b/Modules/DiffusionImaging/DiffusionIO/mitkTractographyForestSerializer.h
similarity index 64%
copy from Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h
copy to Modules/DiffusionImaging/DiffusionIO/mitkTractographyForestSerializer.h
index 24184e2a5f..ac336e6b17 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeSerializer.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkTractographyForestSerializer.h
@@ -1,39 +1,39 @@
 /*===================================================================
 
 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 mitkPlanarFigureCompositeSerializer_h_included
-#define mitkPlanarFigureCompositeSerializer_h_included
+#ifndef mitkTractographyForestSerializer_h_included
+#define mitkTractographyForestSerializer_h_included
 
 #include "mitkBaseDataSerializer.h"
 
 namespace mitk
 {
 /**
-  \brief Serializes mitk::Surface for mitk::SceneIO
+  \brief Serializes mitk::TractographyForest for mitk::SceneIO
 */
-class PlanarFigureCompositeSerializer : public BaseDataSerializer
+class TractographyForestSerializer : public BaseDataSerializer
 {
   public:
-    mitkClassMacro( PlanarFigureCompositeSerializer, BaseDataSerializer );
+    mitkClassMacro( TractographyForestSerializer, BaseDataSerializer );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     virtual std::string Serialize() override;
   protected:
-    PlanarFigureCompositeSerializer();
-    virtual ~PlanarFigureCompositeSerializer();
+    TractographyForestSerializer();
+    virtual ~TractographyForestSerializer();
 };
 } // namespace
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
index c8361cceab..5e81179c97 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
@@ -1,274 +1,273 @@
 /*===================================================================
 
 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 "mitkTrackingHandlerOdf.h"
 #include <itkDiffusionQballGeneralizedFaImageFilter.h>
 #include <itkImageRegionIterator.h>
 #include <itkPointShell.h>
 #include <omp.h>
 #include <math.h>
 
 namespace mitk
 {
 
 TrackingHandlerOdf::TrackingHandlerOdf()
   : m_GfaThreshold(0.2)
   , m_OdfThreshold(0.1)
   , m_SharpenOdfs(false)
   , m_NumProbSamples(1)
 {
 
 }
 
 TrackingHandlerOdf::~TrackingHandlerOdf()
 {
 }
 
 void TrackingHandlerOdf::InitForTracking()
 {
   MITK_INFO << "Initializing ODF tracker.";
 
   if (m_NeedsDataInit)
   {
     m_OdfHemisphereIndices.clear();
     itk::OrientationDistributionFunction< float, QBALL_ODFSIZE > odf;
     vnl_vector_fixed<double,3> ref; ref.fill(0); ref[0]=1;
 
     for (int i=0; i<QBALL_ODFSIZE; i++)
       if (dot_product(ref, odf.GetDirection(i))>0)
         m_OdfHemisphereIndices.push_back(i);
     m_OdfFloatDirs.set_size(m_OdfHemisphereIndices.size(), 3);
 
     for (unsigned int i=0; i<m_OdfHemisphereIndices.size(); i++)
     {
       m_OdfFloatDirs[i][0] = odf.GetDirection(m_OdfHemisphereIndices[i])[0];
       m_OdfFloatDirs[i][1] = odf.GetDirection(m_OdfHemisphereIndices[i])[1];
       m_OdfFloatDirs[i][2] = odf.GetDirection(m_OdfHemisphereIndices[i])[2];
     }
 
     if (m_GfaImage.IsNull())
     {
       MITK_INFO << "Calculating GFA image.";
       typedef itk::DiffusionQballGeneralizedFaImageFilter<float,float,QBALL_ODFSIZE> GfaFilterType;
       GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
       gfaFilter->SetInput(m_OdfImage);
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
       gfaFilter->Update();
       m_GfaImage = gfaFilter->GetOutput();
     }
 
     m_NeedsDataInit = false;
   }
 
   std::cout << "TrackingHandlerOdf - GFA threshold: " << m_GfaThreshold << std::endl;
   std::cout << "TrackingHandlerOdf - ODF threshold: " << m_OdfThreshold << std::endl;
   if (m_SharpenOdfs)
     std::cout << "TrackingHandlerOdf - Sharpening ODfs" << std::endl;
 }
 
 int TrackingHandlerOdf::SampleOdf(vnl_vector< float >& probs, vnl_vector< float >& angles)
 {
   boost::random::discrete_distribution<int, float> dist(probs.begin(), probs.end());
   int sampled_idx = 0;
   int max_sample_idx = -1;
   float max_prob = 0;
   int trials = 0;
 
   for (int i=0; i<m_NumProbSamples; i++)  // we sample m_NumProbSamples times and retain the sample with maximum probabilty
   {
     trials++;
 #pragma omp critical
     {
       boost::random::variate_generator<boost::random::mt19937&, boost::random::discrete_distribution<int,float>> sampler(m_Rng, dist);
       sampled_idx = sampler();
     }
     if (probs[sampled_idx]>max_prob && probs[sampled_idx]>m_OdfThreshold && fabs(angles[sampled_idx])>=m_AngularThreshold)
     {
       max_prob = probs[sampled_idx];
       max_sample_idx = sampled_idx;
     }
     else if ( (probs[sampled_idx]<=m_OdfThreshold || fabs(angles[sampled_idx])<m_AngularThreshold) && trials<50) // we allow 50 trials to exceed the ODF threshold
       i--;
   }
 
   return max_sample_idx;
 }
 
 vnl_vector_fixed<float,3> TrackingHandlerOdf::ProposeDirection(const itk::Point<float, 3>& pos, std::deque<vnl_vector_fixed<float, 3> >& olddirs, itk::Index<3>& oldIndex)
 {
 
   vnl_vector_fixed<float,3> output_direction; output_direction.fill(0);
 
   itk::Index<3> idx;
   m_OdfImage->TransformPhysicalPointToIndex(pos, idx);
 
   if ( !m_OdfImage->GetLargestPossibleRegion().IsInside(idx) )
     return output_direction;
 
   // check GFA threshold for termination
   float gfa = GetImageValue<float>(pos, m_GfaImage, m_Interpolate);
   if (gfa<m_GfaThreshold)
     return output_direction;
 
   vnl_vector_fixed<float,3> last_dir;
   if (!olddirs.empty())
     last_dir = olddirs.back();
 
   if (!m_Interpolate && oldIndex==idx)
     return last_dir;
 
   ItkOdfImageType::PixelType odf_values = GetImageValue<float, QBALL_ODFSIZE>(pos, m_OdfImage, m_Interpolate);
   vnl_vector< float > probs; probs.set_size(m_OdfHemisphereIndices.size());
   vnl_vector< float > angles; angles.set_size(m_OdfHemisphereIndices.size()); angles.fill(1.0);
 
   // Find ODF maximum and remove <0 values
   float max_odf_val = 0;
   float min_odf_val = 999;
   int max_idx_d = -1;
   int c = 0;
   for (int i : m_OdfHemisphereIndices)
   {
     if (odf_values[i]<0)
       odf_values[i] = 0;
 
     if (odf_values[i]>max_odf_val)
     {
       max_odf_val = odf_values[i];
       max_idx_d = c;
     }
     if (odf_values[i]<min_odf_val)
       min_odf_val = odf_values[i];
 
     probs[c] = odf_values[i];
     c++;
   }
 
   if (m_SharpenOdfs)
   {
     // sharpen ODF
     probs -= min_odf_val;
     probs /= (max_odf_val-min_odf_val);
     for (unsigned int i=0; i<probs.size(); i++)
       probs[i] = pow(probs[i], 4);
     float odf_sum = probs.sum();
     if (odf_sum>0)
     {
       probs /= odf_sum;
       max_odf_val /= odf_sum;
     }
   }
 
   // no previous direction
   if (max_odf_val>m_OdfThreshold && (olddirs.empty() || last_dir.magnitude()<=0.5))
   {
     if (m_Mode==MODE::DETERMINISTIC)  // return maximum peak
     {
       output_direction = m_OdfFloatDirs.get_row(max_idx_d);
       return output_direction * max_odf_val;
     }
     else if (m_Mode==MODE::PROBABILISTIC) // sample from complete ODF
     {
       int max_sample_idx = SampleOdf(probs, angles);
       if (max_sample_idx>=0)
         output_direction = m_OdfFloatDirs.get_row(max_sample_idx) * probs[max_sample_idx];
       return output_direction;
     }
   }
   else if (max_odf_val<=m_OdfThreshold) // return (0,0,0)
   {
     return output_direction;
   }
 
   // correct previous direction
   if (m_FlipX)
     last_dir[0] *= -1;
   if (m_FlipY)
     last_dir[1] *= -1;
   if (m_FlipZ)
     last_dir[2] *= -1;
 
   // calculate angles between previous direction and ODF directions
   angles = m_OdfFloatDirs*last_dir;
 
   float probs_sum = 0;
   float max_prob = 0;
   for (unsigned int i=0; i<m_OdfHemisphereIndices.size(); i++)
   {
     float odf_val = probs[i];
     float angle = angles[i];
     float abs_angle = fabs(angle);
 
     odf_val *= abs_angle; // weight probabilities according to deviation from last direction
     if (m_Mode==MODE::DETERMINISTIC && odf_val>max_prob && odf_val>m_OdfThreshold)
     {
       // use maximum peak of the ODF weighted with the directional prior
       max_prob = odf_val;
       vnl_vector_fixed<float,3> d = m_OdfFloatDirs.get_row(i);
       if (angle<0)
         d *= -1;
       output_direction = odf_val*d;
     }
     else if (m_Mode==MODE::PROBABILISTIC)
     {
       // update ODF probabilties with the ODF values pow(abs_angle, m_DirPriorPower)
       probs[i] = odf_val;
       probs_sum += probs[i];
     }
   }
 
   // do probabilistic sampling
   if (m_Mode==MODE::PROBABILISTIC && probs_sum>0.0001)
   {
-//    probs /= probs_sum;
     int max_sample_idx = SampleOdf(probs, angles);
     if (max_sample_idx>=0)
     {
       output_direction = m_OdfFloatDirs.get_row(max_sample_idx);
       if (angles[max_sample_idx]<0)
         output_direction *= -1;
       output_direction *= probs[max_sample_idx];
     }
   }
 
   // check hard angular threshold
   float mag = output_direction.magnitude();
   if (mag>=0.0001)
   {
     output_direction.normalize();
     float a = dot_product(output_direction, last_dir);
     if (a<m_AngularThreshold)
       output_direction.fill(0);
   }
   else
     output_direction.fill(0);
 
   if (m_FlipX)
     output_direction[0] *= -1;
   if (m_FlipY)
     output_direction[1] *= -1;
   if (m_FlipZ)
     output_direction[2] *= -1;
 
   return output_direction;
 }
 
 void TrackingHandlerOdf::SetNumProbSamples(int NumProbSamples)
 {
   m_NumProbSamples = NumProbSamples;
 }
 
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp
index 482bd32d07..ad9edb8b68 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp
@@ -1,928 +1,932 @@
 /*===================================================================
 
 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 _TrackingForestHandler_cpp
 #define _TrackingForestHandler_cpp
 
 #include "mitkTrackingHandlerRandomForest.h"
 #include <itkTractDensityImageFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 namespace mitk
 {
 template< int ShOrder, int NumberOfSignalFeatures >
 TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::TrackingHandlerRandomForest()
   : m_WmSampleDistance(-1)
   , m_NumTrees(30)
   , m_MaxTreeDepth(25)
   , m_SampleFraction(1.0)
   , m_NumberOfSamples(0)
   , m_GmSamplesPerVoxel(-1)
   , m_NumPreviousDirections(1)
   , m_BidirectionalFiberSampling(false)
   , m_ZeroDirWmFeatures(true)
   , m_MaxNumWmSamples(-1)
 {
   vnl_vector_fixed<float,3> ref; ref.fill(0); ref[0]=1;
 
   itk::OrientationDistributionFunction< float, 200 > odf;
   m_DirectionContainer.clear();
   for (unsigned int i = 0; i<odf.GetNumberOfComponents(); i++)
   {
     vnl_vector_fixed<float,3> odf_dir;
     odf_dir[0] = odf.GetDirection(i)[0];
     odf_dir[1] = odf.GetDirection(i)[1];
     odf_dir[2] = odf.GetDirection(i)[2];
     if (dot_product(ref, odf_dir)>0)            // only used directions on one hemisphere
       m_DirectionContainer.push_back(odf_dir);  // store indices for later mapping the classifier output to the actual direction
   }
 
 
   m_OdfFloatDirs.set_size(m_DirectionContainer.size(), 3);
 
   for (unsigned int i=0; i<m_DirectionContainer.size(); i++)
   {
       m_OdfFloatDirs[i][0] = m_DirectionContainer.at(i)[0];
       m_OdfFloatDirs[i][1] = m_DirectionContainer.at(i)[1];
       m_OdfFloatDirs[i][2] = m_DirectionContainer.at(i)[2];
   }
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::~TrackingHandlerRandomForest()
 {
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 typename TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::DwiFeatureImageType::PixelType TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::GetDwiFeaturesAtPosition(itk::Point<float, 3> itkP, typename DwiFeatureImageType::Pointer image, bool interpolate)
 {
   // transform physical point to index coordinates
   itk::Index<3> idx;
   itk::ContinuousIndex< float, 3> cIdx;
   image->TransformPhysicalPointToIndex(itkP, idx);
   image->TransformPhysicalPointToContinuousIndex(itkP, cIdx);
 
   typename DwiFeatureImageType::PixelType pix; pix.Fill(0.0);
   if ( image->GetLargestPossibleRegion().IsInside(idx) )
   {
     pix = image->GetPixel(idx);
     if (!interpolate)
       return pix;
   }
   else
     return pix;
 
   float frac_x = cIdx[0] - idx[0];
   float frac_y = cIdx[1] - idx[1];
   float frac_z = cIdx[2] - idx[2];
   if (frac_x<0)
   {
     idx[0] -= 1;
     frac_x += 1;
   }
   if (frac_y<0)
   {
     idx[1] -= 1;
     frac_y += 1;
   }
   if (frac_z<0)
   {
     idx[2] -= 1;
     frac_z += 1;
   }
   frac_x = 1-frac_x;
   frac_y = 1-frac_y;
   frac_z = 1-frac_z;
 
   // int coordinates inside image?
   if (idx[0] >= 0 && idx[0] < static_cast<itk::IndexValueType>(image->GetLargestPossibleRegion().GetSize(0) - 1) &&
       idx[1] >= 0 && idx[1] < static_cast<itk::IndexValueType>(image->GetLargestPossibleRegion().GetSize(1) - 1) &&
       idx[2] >= 0 && idx[2] < static_cast<itk::IndexValueType>(image->GetLargestPossibleRegion().GetSize(2) - 1))
   {
     // trilinear interpolation
     vnl_vector_fixed<float, 8> interpWeights;
     interpWeights[0] = (  frac_x)*(  frac_y)*(  frac_z);
     interpWeights[1] = (1-frac_x)*(  frac_y)*(  frac_z);
     interpWeights[2] = (  frac_x)*(1-frac_y)*(  frac_z);
     interpWeights[3] = (  frac_x)*(  frac_y)*(1-frac_z);
     interpWeights[4] = (1-frac_x)*(1-frac_y)*(  frac_z);
     interpWeights[5] = (  frac_x)*(1-frac_y)*(1-frac_z);
     interpWeights[6] = (1-frac_x)*(  frac_y)*(1-frac_z);
     interpWeights[7] = (1-frac_x)*(1-frac_y)*(1-frac_z);
 
     pix = image->GetPixel(idx) * interpWeights[0];
     typename DwiFeatureImageType::IndexType tmpIdx = idx; tmpIdx[0]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[1];
     tmpIdx = idx; tmpIdx[1]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[2];
     tmpIdx = idx; tmpIdx[2]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[3];
     tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[4];
     tmpIdx = idx; tmpIdx[1]++; tmpIdx[2]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[5];
     tmpIdx = idx; tmpIdx[2]++; tmpIdx[0]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[6];
     tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
     pix +=  image->GetPixel(tmpIdx) * interpWeights[7];
   }
 
   return pix;
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 void TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::InputDataValidForTracking()
 {
   if (m_InputDwis.empty())
     mitkThrow() << "No diffusion-weighted images set!";
   if (!IsForestValid())
     mitkThrow() << "No or invalid random forest detected!";
 }
 
 template< int ShOrder, int NumberOfSignalFeatures>
 template<typename T>
 typename std::enable_if< NumberOfSignalFeatures <=99, T >::type TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::InitDwiImageFeatures(mitk::Image::Pointer mitk_dwi)
 {
   MITK_INFO << "Calculating spherical harmonics features";
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,ShOrder, 2*NumberOfSignalFeatures> InterpolationFilterType;
 
   typename InterpolationFilterType::Pointer filter = InterpolationFilterType::New();
   filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(mitk_dwi));
   filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(mitk_dwi), mitk::DiffusionPropertyHelper::GetItkVectorImage(mitk_dwi) );
   filter->SetLambda(0.006);
   filter->SetNormalizationMethod(InterpolationFilterType::QBAR_RAW_SIGNAL);
   filter->Update();
 
   m_DwiFeatureImages.push_back(filter->GetCoefficientImage());
   return true;
 }
 
 template< int ShOrder, int NumberOfSignalFeatures>
 template<typename T>
 typename std::enable_if< NumberOfSignalFeatures >=100, T >::type TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::InitDwiImageFeatures(mitk::Image::Pointer mitk_dwi)
 {
   MITK_INFO << "Interpolating raw dwi signal features";
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,ShOrder, 2*NumberOfSignalFeatures> InterpolationFilterType;
 
   typename InterpolationFilterType::Pointer filter = InterpolationFilterType::New();
   filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(mitk_dwi));
   filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(mitk_dwi), mitk::DiffusionPropertyHelper::GetItkVectorImage(mitk_dwi) );
   filter->SetLambda(0.006);
   filter->SetNormalizationMethod(InterpolationFilterType::QBAR_RAW_SIGNAL);
   filter->Update();
 
   typename DwiFeatureImageType::Pointer dwiFeatureImage = DwiFeatureImageType::New();
   dwiFeatureImage->SetSpacing(filter->GetOutput()->GetSpacing());
   dwiFeatureImage->SetOrigin(filter->GetOutput()->GetOrigin());
   dwiFeatureImage->SetDirection(filter->GetOutput()->GetDirection());
   dwiFeatureImage->SetLargestPossibleRegion(filter->GetOutput()->GetLargestPossibleRegion());
   dwiFeatureImage->SetBufferedRegion(filter->GetOutput()->GetLargestPossibleRegion());
   dwiFeatureImage->SetRequestedRegion(filter->GetOutput()->GetLargestPossibleRegion());
   dwiFeatureImage->Allocate();
 
   // get signal values and store them in the feature image
   vnl_vector_fixed<double,3> ref; ref.fill(0); ref[0]=1;
   itk::OrientationDistributionFunction< float, 2*NumberOfSignalFeatures > odf;
   itk::ImageRegionIterator< typename InterpolationFilterType::OutputImageType > it(filter->GetOutput(), filter->GetOutput()->GetLargestPossibleRegion());
   while(!it.IsAtEnd())
   {
     typename DwiFeatureImageType::PixelType pix;
     int f = 0;
     for (unsigned int i = 0; i<odf.GetNumberOfComponents(); i++)
     {
       if (dot_product(ref, odf.GetDirection(i))>0)            // only used directions on one hemisphere
       {
         pix[f] = it.Get()[i];
         f++;
       }
     }
     dwiFeatureImage->SetPixel(it.GetIndex(), pix);
     ++it;
   }
   m_DwiFeatureImages.push_back(dwiFeatureImage);
   return true;
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 void TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::InitForTracking()
 {
   MITK_INFO << "Initializing random forest tracker.";
   if (m_NeedsDataInit)
   {
     InputDataValidForTracking();
     m_DwiFeatureImages.clear();
     InitDwiImageFeatures<>(m_InputDwis.at(0));
     m_NeedsDataInit = false;
   }
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 vnl_vector_fixed<float,3> TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::ProposeDirection(const itk::Point<float, 3>& pos, std::deque<vnl_vector_fixed<float, 3> >& olddirs, itk::Index<3>& oldIndex)
 {
 
   vnl_vector_fixed<float,3> output_direction; output_direction.fill(0);
 
   itk::Index<3> idx;
   m_DwiFeatureImages.at(0)->TransformPhysicalPointToIndex(pos, idx);
 
   bool check_last_dir = false;
   vnl_vector_fixed<float,3> last_dir;
   if (!olddirs.empty())
   {
     last_dir = olddirs.back();
     if (last_dir.magnitude()>0.5)
       check_last_dir = true;
   }
 
   if (!m_Interpolate && oldIndex==idx)
     return last_dir;
 
   // store feature pixel values in a vigra data type
   vigra::MultiArray<2, float> featureData = vigra::MultiArray<2, float>( vigra::Shape2(1,m_Forest->GetNumFeatures()) );
   typename DwiFeatureImageType::PixelType dwiFeaturePixel = GetDwiFeaturesAtPosition(pos, m_DwiFeatureImages.at(0), m_Interpolate);
   for (unsigned int f=0; f<NumberOfSignalFeatures; f++)
     featureData(0,f) = dwiFeaturePixel[f];
 
   vnl_matrix_fixed<double,3,3> direction_matrix = m_DwiFeatureImages.at(0)->GetDirection().GetVnlMatrix();
   vnl_matrix_fixed<double,3,3> inverse_direction_matrix = m_DwiFeatureImages.at(0)->GetInverseDirection().GetVnlMatrix();
 
   // append normalized previous direction(s) to feature vector
   int i = 0;
   vnl_vector_fixed<double,3> ref; ref.fill(0); ref[0]=1;
 
   for (auto d : olddirs)
   {
     vnl_vector_fixed<double,3> tempD;
     tempD[0] = d[0]; tempD[1] = d[1]; tempD[2] = d[2];
 
     if (m_FlipX)
         tempD[0] *= -1;
     if (m_FlipY)
         tempD[1] *= -1;
     if (m_FlipZ)
         tempD[2] *= -1;
 
     tempD = inverse_direction_matrix * tempD;
     last_dir[0] = tempD[0];
     last_dir[1] = tempD[1];
     last_dir[2] = tempD[2];
 
     int c = 0;
     for (int f=NumberOfSignalFeatures+3*i; f<NumberOfSignalFeatures+3*(i+1); f++)
     {
       if (dot_product(ref, tempD)<0)
         featureData(0,f) = -tempD[c];
       else
         featureData(0,f) = tempD[c];
       c++;
     }
     i++;
   }
 
   // additional feature images
   if (m_AdditionalFeatureImages.size()>0)
   {
     int c = 0;
     for (auto img : m_AdditionalFeatureImages.at(0))
     {
       float v = GetImageValue<float>(pos, img, false);
       featureData(0,NumberOfSignalFeatures+m_NumPreviousDirections*3+c) = v;
       c++;
     }
   }
 
   // perform classification
   vigra::MultiArray<2, float> probs(vigra::Shape2(1, m_Forest->GetNumClasses()));
   m_Forest->PredictProbabilities(featureData, probs);
 
   vnl_vector< float > angles = m_OdfFloatDirs*last_dir;
   vnl_vector< float > probs2; probs2.set_size(m_DirectionContainer.size()); probs2.fill(0.0); // used for probabilistic direction sampling
   float probs_sum = 0;
 
   float pNonFib = 0;     // probability that we left the white matter
   float w = 0;           // weight of the predicted direction
 
   for (int i=0; i<m_Forest->GetNumClasses(); i++)   // for each class (number of possible directions + out-of-wm class)
   {
     if (probs(0,i)>0)   // if probability of respective class is 0, do nothing
     {
       // get label of class (does not correspond to the loop variable i)
       unsigned int classLabel = m_Forest->IndexToClassLabel(i);
 
       if (classLabel<m_DirectionContainer.size())   // does class label correspond to a direction or to the out-of-wm class?
       {
+        float angle = angles[classLabel];
+        float abs_angle = fabs(angle);
+
         if (m_Mode==MODE::PROBABILISTIC)
         {
-          if (!check_last_dir || fabs(angles[classLabel])>=m_AngularThreshold)
-            probs2[classLabel] = probs(0,i);
+          probs2[classLabel] = probs(0,i);
+          if (check_last_dir)
+            probs2[classLabel] *= abs_angle;
           probs_sum += probs2[classLabel];
         }
         else if (m_Mode==MODE::DETERMINISTIC)
         {
           vnl_vector_fixed<float,3> d = m_DirectionContainer.at(classLabel);  // get direction vector assiciated with the respective direction index
           if (check_last_dir)   // do we have a previous streamline direction or did we just start?
           {
-            // TODO: check if hard curvature threshold is necessary.
-            // alternatively try square of dot product as weight.
-            // TODO: check if additional weighting with dot product as directional prior is necessary. are there alternatives on the classification level?
-
-            float dot = angles[classLabel];    // claculate angle between the candidate direction vector and the previous streamline direction
-            if (fabs(dot)>=m_AngularThreshold)         // is angle between the directions smaller than our hard threshold?
+            if (abs_angle>=m_AngularThreshold)         // is angle between the directions smaller than our hard threshold?
             {
-              if (dot<0)                          // make sure we don't walk backwards
+              if (angle<0)                          // make sure we don't walk backwards
                 d *= -1;
-              float w_i = probs(0,i)*fabs(dot);
+              float w_i = probs(0,i)*abs_angle;
               output_direction += w_i*d; // weight contribution to output direction with its probability and the angular deviation from the previous direction
               w += w_i;           // increase output weight of the final direction
             }
           }
           else
           {
             output_direction += probs(0,i)*d;
             w += probs(0,i);
           }
         }
       }
       else
         pNonFib += probs(0,i);  // probability that we are not in the white matter anymore
     }
   }
 
 
   if (m_Mode==MODE::PROBABILISTIC && pNonFib<0.5)
   {
-    probs2 /= probs_sum;
     boost::random::discrete_distribution<int, float> dist(probs2.begin(), probs2.end());
-
     int sampled_idx = 0;
-#pragma omp critical
+
+    for (int i=0; i<50; i++)  // we allow 50 trials to exceed m_AngularThreshold
     {
+  #pragma omp critical
+      {
         boost::random::variate_generator<boost::random::mt19937&, boost::random::discrete_distribution<int,float>> sampler(m_Rng, dist);
         sampled_idx = sampler();
+      }
+
+      if ( probs2[sampled_idx]>0.1 && (!check_last_dir || (check_last_dir && fabs(angles[sampled_idx])>=m_AngularThreshold)) )
+        break;
     }
 
     output_direction = m_DirectionContainer.at(sampled_idx);
     w = probs2[sampled_idx];
     if (check_last_dir && angles[sampled_idx]<0)                          // make sure we don't walk backwards
         output_direction *= -1;
   }
 
   // if we did not find a suitable direction, make sure that we return (0,0,0)
   if (pNonFib>w && w>0)
     output_direction.fill(0.0);
   else
   {
     vnl_vector_fixed<double,3> tempD;
     tempD[0] = output_direction[0]; tempD[1] = output_direction[1]; tempD[2] = output_direction[2];
     tempD = direction_matrix * tempD;
     output_direction[0] = tempD[0];
     output_direction[1] = tempD[1];
     output_direction[2] = tempD[2];
 
     if (m_FlipX)
       output_direction[0] *= -1;
     if (m_FlipY)
       output_direction[1] *= -1;
     if (m_FlipZ)
       output_direction[2] *= -1;
   }
 
   return output_direction * w;
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 void TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::StartTraining()
 {
   m_StartTime = std::chrono::system_clock::now();
   InputDataValidForTraining();
   InitForTraining();
   CalculateTrainingSamples();
 
   MITK_INFO << "Maximum tree depths: " << m_MaxTreeDepth;
   MITK_INFO << "Sample fraction per tree: " << m_SampleFraction;
   MITK_INFO << "Number of trees: " << m_NumTrees;
 
   DefaultSplitType splitter;
   splitter.UsePointBasedWeights(true);
   splitter.SetWeights(m_Weights);
   splitter.UseRandomSplit(false);
   splitter.SetPrecision(mitk::eps);
   splitter.SetMaximumTreeDepth(m_MaxTreeDepth);
 
   std::vector< std::shared_ptr< vigra::RandomForest<int> > > trees;
   int count = 0;
 #pragma omp parallel for
   for (int i = 0; i < m_NumTrees; ++i)
   {
     std::shared_ptr< vigra::RandomForest<int> > lrf = std::make_shared< vigra::RandomForest<int> >();
     lrf->set_options().use_stratification(vigra::RF_NONE); // How the data should be made equal
     lrf->set_options().sample_with_replacement(true); // if sampled with replacement or not
     lrf->set_options().samples_per_tree(m_SampleFraction); // Fraction of samples that are used to train a tree
     lrf->set_options().tree_count(1); // Number of trees that are calculated;
     lrf->set_options().min_split_node_size(5); // Minimum number of datapoints that must be in a node
     lrf->ext_param_.max_tree_depth = m_MaxTreeDepth;
 
     lrf->learn(m_FeatureData, m_LabelData,vigra::rf::visitors::VisitorBase(),splitter);
 #pragma omp critical
     {
       count++;
       MITK_INFO << "Tree " << count << " finished training.";
       trees.push_back(lrf);
     }
   }
 
   for (int i = 1; i < m_NumTrees; ++i)
     trees.at(0)->trees_.push_back(trees.at(i)->trees_[0]);
 
   std::shared_ptr< vigra::RandomForest<int> > forest = trees.at(0);
   forest->options_.tree_count_ = m_NumTrees;
   m_Forest = mitk::TractographyForest::New(forest);
   MITK_INFO << "Training finsihed";
 
   m_EndTime = std::chrono::system_clock::now();
   std::chrono::hours   hh = std::chrono::duration_cast<std::chrono::hours>(m_EndTime - m_StartTime);
   std::chrono::minutes mm = std::chrono::duration_cast<std::chrono::minutes>(m_EndTime - m_StartTime);
   mm %= 60;
   MITK_INFO << "Training took " << hh.count() << "h and " << mm.count() << "m";
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 void TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::InputDataValidForTraining()
 {
   if (m_InputDwis.empty())
     mitkThrow() << "No diffusion-weighted images set!";
   if (m_Tractograms.empty())
     mitkThrow() << "No tractograms set!";
   if (m_InputDwis.size()!=m_Tractograms.size())
     mitkThrow() << "Unequal number of diffusion-weighted images and tractograms detected!";
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 bool TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::IsForestValid()
 {
   int additional_features = 0;
   if (m_AdditionalFeatureImages.size()>0)
     additional_features = m_AdditionalFeatureImages.at(0).size();
 
   if (!m_Forest)
     MITK_INFO << "No forest available!";
   else
   {
     if (m_Forest->GetNumTrees() <= 0)
       MITK_ERROR << "Forest contains no trees!";
     if ( m_Forest->GetNumFeatures() != static_cast<int>(NumberOfSignalFeatures+3*m_NumPreviousDirections+additional_features) )
       MITK_ERROR << "Wrong number of features in forest: got " << m_Forest->GetNumFeatures() << ", expected " << (NumberOfSignalFeatures+3*m_NumPreviousDirections+additional_features);
   }
 
   if(m_Forest && m_Forest->GetNumTrees()>0 && m_Forest->GetNumFeatures() == static_cast<int>(NumberOfSignalFeatures+3*m_NumPreviousDirections+additional_features))
     return true;
 
   return false;
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 void TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::InitForTraining()
 {
   MITK_INFO << "Spherical signal interpolation and sampling ...";
   for (unsigned int i=0; i<m_InputDwis.size(); i++)
   {
     InitDwiImageFeatures<>(m_InputDwis.at(i));
 
     if (i>=m_AdditionalFeatureImages.size())
     {
       m_AdditionalFeatureImages.push_back(std::vector< ItkFloatImgType::Pointer >());
     }
 
     if (i>=m_FiberVolumeModImages.size())
     {
       ItkFloatImgType::Pointer img = ItkFloatImgType::New();
       img->SetSpacing( m_DwiFeatureImages.at(i)->GetSpacing() );
       img->SetOrigin( m_DwiFeatureImages.at(i)->GetOrigin() );
       img->SetDirection( m_DwiFeatureImages.at(i)->GetDirection() );
       img->SetLargestPossibleRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       img->SetBufferedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       img->SetRequestedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       img->Allocate();
       img->FillBuffer(1);
       m_FiberVolumeModImages.push_back(img);
     }
 
     if (m_FiberVolumeModImages.at(i)==nullptr)
     {
       m_FiberVolumeModImages.at(i) = ItkFloatImgType::New();
       m_FiberVolumeModImages.at(i)->SetSpacing( m_DwiFeatureImages.at(i)->GetSpacing() );
       m_FiberVolumeModImages.at(i)->SetOrigin( m_DwiFeatureImages.at(i)->GetOrigin() );
       m_FiberVolumeModImages.at(i)->SetDirection( m_DwiFeatureImages.at(i)->GetDirection() );
       m_FiberVolumeModImages.at(i)->SetLargestPossibleRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       m_FiberVolumeModImages.at(i)->SetBufferedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       m_FiberVolumeModImages.at(i)->SetRequestedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       m_FiberVolumeModImages.at(i)->Allocate();
       m_FiberVolumeModImages.at(i)->FillBuffer(1);
     }
 
     if (i>=m_MaskImages.size())
     {
       ItkUcharImgType::Pointer newMask = ItkUcharImgType::New();
       newMask->SetSpacing( m_DwiFeatureImages.at(i)->GetSpacing() );
       newMask->SetOrigin( m_DwiFeatureImages.at(i)->GetOrigin() );
       newMask->SetDirection( m_DwiFeatureImages.at(i)->GetDirection() );
       newMask->SetLargestPossibleRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       newMask->SetBufferedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       newMask->SetRequestedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       newMask->Allocate();
       newMask->FillBuffer(1);
       m_MaskImages.push_back(newMask);
     }
 
     if (m_MaskImages.at(i)==nullptr)
     {
       m_MaskImages.at(i) = ItkUcharImgType::New();
       m_MaskImages.at(i)->SetSpacing( m_DwiFeatureImages.at(i)->GetSpacing() );
       m_MaskImages.at(i)->SetOrigin( m_DwiFeatureImages.at(i)->GetOrigin() );
       m_MaskImages.at(i)->SetDirection( m_DwiFeatureImages.at(i)->GetDirection() );
       m_MaskImages.at(i)->SetLargestPossibleRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       m_MaskImages.at(i)->SetBufferedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       m_MaskImages.at(i)->SetRequestedRegion( m_DwiFeatureImages.at(i)->GetLargestPossibleRegion() );
       m_MaskImages.at(i)->Allocate();
       m_MaskImages.at(i)->FillBuffer(1);
     }
   }
 
   MITK_INFO << "Resampling fibers and calculating number of samples ...";
   m_NumberOfSamples = 0;
   m_SampleUsage.clear();
   for (unsigned int t=0; t<m_Tractograms.size(); t++)
   {
     ItkUcharImgType::Pointer mask = m_MaskImages.at(t);
     ItkUcharImgType::Pointer wmmask;
     if (t<m_WhiteMatterImages.size() && m_WhiteMatterImages.at(t)!=nullptr)
       wmmask = m_WhiteMatterImages.at(t);
     else
     {
       MITK_INFO << "No white-matter mask found. Using fiber envelope.";
       itk::TractDensityImageFilter< ItkUcharImgType >::Pointer env = itk::TractDensityImageFilter< ItkUcharImgType >::New();
       env->SetFiberBundle(m_Tractograms.at(t));
       env->SetInputImage(mask);
       env->SetBinaryOutput(true);
       env->SetUseImageGeometry(true);
       env->Update();
       wmmask = env->GetOutput();
       if (t>=m_WhiteMatterImages.size())
         m_WhiteMatterImages.push_back(wmmask);
       else
         m_WhiteMatterImages.at(t) = wmmask;
     }
 
     // Calculate white-matter samples
     if (m_WmSampleDistance<0)
     {
       typename DwiFeatureImageType::Pointer image = m_DwiFeatureImages.at(t);
       float minSpacing = 1;
       if(image->GetSpacing()[0]<image->GetSpacing()[1] && image->GetSpacing()[0]<image->GetSpacing()[2])
         minSpacing = image->GetSpacing()[0];
       else if (image->GetSpacing()[1] < image->GetSpacing()[2])
         minSpacing = image->GetSpacing()[1];
       else
         minSpacing = image->GetSpacing()[2];
       m_WmSampleDistance = minSpacing*0.5;
     }
 
     m_Tractograms.at(t)->ResampleLinear(m_WmSampleDistance);
 
     int wmSamples = m_Tractograms.at(t)->GetNumberOfPoints()-2*m_Tractograms.at(t)->GetNumFibers();
     if (m_BidirectionalFiberSampling)
       wmSamples *= 2;
     if (m_ZeroDirWmFeatures)
       wmSamples *= (m_NumPreviousDirections+1);
 
     MITK_INFO << "White matter samples available: " << wmSamples;
 
     // upper limit for samples
     if (m_MaxNumWmSamples>0 && wmSamples>m_MaxNumWmSamples)
     {
       if ((float)m_MaxNumWmSamples/wmSamples > 0.8)
       {
         m_SampleUsage.push_back(std::vector<bool>(wmSamples, true));
         m_NumberOfSamples += wmSamples;
       }
       else
       {
         m_SampleUsage.push_back(std::vector<bool>(wmSamples, false));
         m_NumberOfSamples += m_MaxNumWmSamples;
         wmSamples = m_MaxNumWmSamples;
         MITK_INFO << "Limiting white matter samples to: " << m_MaxNumWmSamples;
 
         itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randgen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
         randgen->SetSeed();
         int c = 0;
         while (c<m_MaxNumWmSamples)
         {
           int idx = randgen->GetIntegerVariate(m_MaxNumWmSamples-1);
           if (m_SampleUsage[t][idx]==false)
           {
             m_SampleUsage[t][idx]=true;
             ++c;
           }
         }
       }
     }
     else
     {
       m_SampleUsage.push_back(std::vector<bool>(wmSamples, true));
       m_NumberOfSamples += wmSamples;
     }
 
     // calculate gray-matter samples
     itk::ImageRegionConstIterator<ItkUcharImgType> it(wmmask, wmmask->GetLargestPossibleRegion());
     int OUTOFWM = 0;
     while(!it.IsAtEnd())
     {
       if (it.Get()==0 && mask->GetPixel(it.GetIndex())>0)
         OUTOFWM++;
       ++it;
     }
     MITK_INFO << "Non-white matter voxels: " << OUTOFWM;
 
     if (m_GmSamplesPerVoxel>0)
     {
       m_GmSamples.push_back(m_GmSamplesPerVoxel);
       m_NumberOfSamples += m_GmSamplesPerVoxel*OUTOFWM;
     }
     else if (OUTOFWM>0)
     {
       int gm_per_voxel = 0.5+(float)wmSamples/(float)OUTOFWM;
       if (gm_per_voxel<=0)
         gm_per_voxel = 1;
       m_GmSamples.push_back(gm_per_voxel);
       m_NumberOfSamples += m_GmSamples.back()*OUTOFWM;
       MITK_INFO << "Non-white matter samples per voxel: " << m_GmSamples.back();
     }
     else
     {
       m_GmSamples.push_back(0);
     }
     MITK_INFO << "Non-white matter samples: " << m_GmSamples.back()*OUTOFWM;
   }
   MITK_INFO << "Number of samples: " << m_NumberOfSamples;
 }
 
 template< int ShOrder, int NumberOfSignalFeatures >
 void TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::CalculateTrainingSamples()
 {
   vnl_vector_fixed<float,3> ref; ref.fill(0); ref[0]=1;
 
   m_FeatureData.reshape( vigra::Shape2(m_NumberOfSamples, NumberOfSignalFeatures+m_NumPreviousDirections*3+m_AdditionalFeatureImages.at(0).size()) );
   m_LabelData.reshape( vigra::Shape2(m_NumberOfSamples,1) );
   m_Weights.reshape( vigra::Shape2(m_NumberOfSamples,1) );
   MITK_INFO << "Number of features: " << m_FeatureData.shape(1);
 
   itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
   m_RandGen->SetSeed();
   MITK_INFO <<  "Creating training data ...";
   unsigned int sampleCounter = 0;
   for (unsigned int t=0; t<m_Tractograms.size(); t++)
   {
     ItkFloatImgType::Pointer fiber_folume = m_FiberVolumeModImages.at(t);
     typename DwiFeatureImageType::Pointer image = m_DwiFeatureImages.at(t);
     ItkUcharImgType::Pointer wmMask = m_WhiteMatterImages.at(t);
     ItkUcharImgType::Pointer mask;
     if (t<m_MaskImages.size())
       mask = m_MaskImages.at(t);
 
     // non-white matter samples
     itk::ImageRegionConstIterator<ItkUcharImgType> it(wmMask, wmMask->GetLargestPossibleRegion());
     while(!it.IsAtEnd())
     {
       if (it.Get()==0 && (mask.IsNull() || (mask.IsNotNull() && mask->GetPixel(it.GetIndex())>0)))
       {
         typename DwiFeatureImageType::PixelType pix = image->GetPixel(it.GetIndex());
 
         // random directions
         for (unsigned int i=0; i<m_GmSamples.at(t); i++)
         {
           // diffusion signal features
           for (unsigned int f=0; f<NumberOfSignalFeatures; f++)
           {
             m_FeatureData(sampleCounter,f) = pix[f];
             if(m_FeatureData(sampleCounter,f)!=m_FeatureData(sampleCounter,f))
               m_FeatureData(sampleCounter,f) = 0;
           }
 
           // direction feature
           int num_zero_dirs = m_RandGen->GetIntegerVariate(m_NumPreviousDirections);  // how many directions should be zero?
           for (unsigned int i=0; i<m_NumPreviousDirections; i++)
           {
             int c=0;
             vnl_vector_fixed<float,3> probe;
             if (static_cast<int>(i)<num_zero_dirs)
               probe.fill(0.0);
             else
             {
               probe[0] = m_RandGen->GetVariate()*2-1;
               probe[1] = m_RandGen->GetVariate()*2-1;
               probe[2] = m_RandGen->GetVariate()*2-1;
               probe.normalize();
               if (dot_product(ref, probe)<0)
                 probe *= -1;
             }
             for (unsigned int f=NumberOfSignalFeatures+3*i; f<NumberOfSignalFeatures+3*(i+1); f++)
             {
               m_FeatureData(sampleCounter,f) = probe[c];
               c++;
             }
           }
 
           // additional feature images
           int add_feat_c = 0;
           for (auto img : m_AdditionalFeatureImages.at(t))
           {
             itk::Point<float, 3> itkP;
             image->TransformIndexToPhysicalPoint(it.GetIndex(), itkP);
             float v = GetImageValue<float>(itkP, img, false);
             m_FeatureData(sampleCounter,NumberOfSignalFeatures+m_NumPreviousDirections*3+add_feat_c) = v;
             add_feat_c++;
           }
 
           // label and sample weight
           m_LabelData(sampleCounter,0) = m_DirectionContainer.size();
           m_Weights(sampleCounter,0) = 1.0;
           sampleCounter++;
         }
       }
       ++it;
     }
 
     unsigned int num_gm_samples = sampleCounter;
     // white matter samples
     mitk::FiberBundle::Pointer fib = m_Tractograms.at(t);
     vtkSmartPointer< vtkPolyData > polyData = fib->GetFiberPolyData();
     vnl_vector_fixed<float,3> zero_dir; zero_dir.fill(0.0);
     for (int i=0; i<fib->GetNumFibers(); i++)
     {
       vtkCell* cell = polyData->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
       float fiber_weight = fib->GetFiberWeight(i);
 
       for (int n = 0; n <= static_cast<int>(m_NumPreviousDirections); ++n)
       {
         if (!m_ZeroDirWmFeatures)
           n = m_NumPreviousDirections;
         for (bool reverse : {false, true})
         {
           for (int j=1; j<numPoints-1; j++)
           {
             if (!m_SampleUsage[t][sampleCounter-num_gm_samples])
               continue;
 
             itk::Point<float, 3> itkP1, itkP2;
 
             int num_nonzero_dirs = m_NumPreviousDirections;
             if (!reverse)
               num_nonzero_dirs = std::min(n, j);
             else
               num_nonzero_dirs = std::min(n, numPoints-j-1);
 
             vnl_vector_fixed<float,3> dir;
             // zero directions
             for (unsigned int k=0; k<m_NumPreviousDirections-num_nonzero_dirs; k++)
             {
               dir.fill(0.0);
               int c = 0;
               for (unsigned int f=NumberOfSignalFeatures+3*k; f<NumberOfSignalFeatures+3*(k+1); f++)
               {
                 m_FeatureData(sampleCounter,f) = dir[c];
                 c++;
               }
             }
 
             // nonzero directions
             for (int k=0; k<num_nonzero_dirs; k++)
             {
               double* p = nullptr;
               int n_idx = num_nonzero_dirs-k;
               if (!reverse)
               {
                 p = points->GetPoint(j-n_idx);
                 itkP1[0] = p[0]; itkP1[1] = p[1]; itkP1[2] = p[2];
                 p = points->GetPoint(j-n_idx+1);
                 itkP2[0] = p[0]; itkP2[1] = p[1]; itkP2[2] = p[2];
               }
               else
               {
                 p = points->GetPoint(j+n_idx);
                 itkP1[0] = p[0]; itkP1[1] = p[1]; itkP1[2] = p[2];
                 p = points->GetPoint(j+n_idx-1);
                 itkP2[0] = p[0]; itkP2[1] = p[1]; itkP2[2] = p[2];
               }
 
               dir[0]=itkP1[0]-itkP2[0];
               dir[1]=itkP1[1]-itkP2[1];
               dir[2]=itkP1[2]-itkP2[2];
 
               if (dir.magnitude()<0.0001)
                 mitkThrow() << "streamline error!";
               dir.normalize();
               if (dir[0]!=dir[0] || dir[1]!=dir[1] || dir[2]!=dir[2])
                 mitkThrow() << "ERROR: NaN direction!";
 
               if (dot_product(ref, dir)<0)
                 dir *= -1;
 
               int c = 0;
               for (unsigned int f=NumberOfSignalFeatures+3*(k+m_NumPreviousDirections-num_nonzero_dirs); f<NumberOfSignalFeatures+3*(k+1+m_NumPreviousDirections-num_nonzero_dirs); f++)
               {
                 m_FeatureData(sampleCounter,f) = dir[c];
                 c++;
               }
             }
 
             // get target direction
             double* p = points->GetPoint(j);
             itkP1[0] = p[0]; itkP1[1] = p[1]; itkP1[2] = p[2];
             if (reverse)
             {
               p = points->GetPoint(j-1);
               itkP2[0] = p[0]; itkP2[1] = p[1]; itkP2[2] = p[2];
             }
             else
             {
               p = points->GetPoint(j+1);
               itkP2[0] = p[0]; itkP2[1] = p[1]; itkP2[2] = p[2];
             }
             dir[0]=itkP2[0]-itkP1[0];
             dir[1]=itkP2[1]-itkP1[1];
             dir[2]=itkP2[2]-itkP1[2];
 
             if (dir.magnitude()<0.0001)
               mitkThrow() << "streamline error!";
             dir.normalize();
             if (dir[0]!=dir[0] || dir[1]!=dir[1] || dir[2]!=dir[2])
               mitkThrow() << "ERROR: NaN direction!";
             if (dot_product(ref, dir)<0)
               dir *= -1;
 
             // image features
             float volume_mod = GetImageValue<float>(itkP1, fiber_folume, false);
 
             // diffusion signal features
             typename DwiFeatureImageType::PixelType pix = GetDwiFeaturesAtPosition(itkP1, image, m_Interpolate);
             for (unsigned int f=0; f<NumberOfSignalFeatures; f++)
               m_FeatureData(sampleCounter,f) = pix[f];
 
             // additional feature images
             int add_feat_c = 0;
             for (auto img : m_AdditionalFeatureImages.at(t))
             {
               float v = GetImageValue<float>(itkP1, img, false);
               add_feat_c++;
               m_FeatureData(sampleCounter,NumberOfSignalFeatures+2+add_feat_c) = v;
             }
 
             // set label values
             float angle = 0;
             float m = dir.magnitude();
             if (m>0.0001)
             {
               int l = 0;
               for (auto d : m_DirectionContainer)
               {
                 float a = fabs(dot_product(dir, d));
                 if (a>angle)
                 {
                   m_LabelData(sampleCounter,0) = l;
                   m_Weights(sampleCounter,0) = fiber_weight*volume_mod;
                   angle = a;
                 }
                 l++;
               }
             }
 
             sampleCounter++;
           }
           if (!m_BidirectionalFiberSampling)  // don't sample fibers backward
             break;
         }
       }
     }
   }
   m_Tractograms.clear();
   MITK_INFO << "done";
 }
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkTractographyForest.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkTractographyForest.cpp
index 670a6e8d91..7187027c20 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkTractographyForest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkTractographyForest.cpp
@@ -1,116 +1,119 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #define _USE_MATH_DEFINES
 #include "mitkTractographyForest.h"
 #include <mitkExceptionMacro.h>
+#include <mitkGeometry3D.h>
 
 using namespace std;
 
 namespace mitk
 {
 
 TractographyForest::TractographyForest( std::shared_ptr< vigra::RandomForest<int> > forest )
 {
   m_Forest = forest;
+  mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
+  SetGeometry(geometry);
 }
 
 TractographyForest::~TractographyForest()
 {
 
 }
 
 void TractographyForest::PredictProbabilities(vigra::MultiArray<2, float>& features, vigra::MultiArray<2, float>& probabilities) const
 {
   m_Forest->predictProbabilities(features, probabilities);
 }
 
 int TractographyForest::GetNumFeatures() const
 {
   if (!HasForest())
     mitkThrow() << "Forest is NULL";
   return m_Forest->feature_count();
 }
 
 int TractographyForest::GetNumTrees() const
 {
   if (!HasForest())
     mitkThrow() << "Forest is NULL";
   return m_Forest->tree_count();
 }
 
 int TractographyForest::GetNumClasses() const
 {
   if (!HasForest())
     mitkThrow() << "Forest is NULL";
   return m_Forest->class_count();
 }
 
 int TractographyForest::GetMaxTreeDepth() const
 {
   if (!HasForest())
     mitkThrow() << "Forest is NULL";
   return m_Forest->ext_param_.max_tree_depth;
 }
 
 int TractographyForest::IndexToClassLabel(int idx) const
 {
   if (!HasForest())
     mitkThrow() << "Forest is NULL";
   unsigned int classLabel = 0;
   m_Forest->ext_param_.to_classlabel(idx, classLabel);
   return classLabel;
 }
 
 bool TractographyForest::HasForest() const
 {
   return m_Forest!=nullptr;
 }
 
 void TractographyForest::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
 //  Superclass::PrintSelf(os, indent);
   os << indent << this->GetNameOfClass() << ":\n";
   os << indent << "Number of features: " << GetNumFeatures() << std::endl;
   os << indent << "Number of classes: " << GetNumClasses() << std::endl;
   os << indent << "Number of trees: " << GetNumTrees() << std::endl;
   os << indent << "Maximum tree depth: " << GetMaxTreeDepth() << std::endl;
 }
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
 void TractographyForest::UpdateOutputInformation()
 {
 
 }
 void TractographyForest::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool TractographyForest::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 bool TractographyForest::VerifyRequestedRegion()
 {
   return true;
 }
 void TractographyForest::SetRequestedRegion(const itk::DataObject* )
 {
 
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkMLBTView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkMLBTView.cpp
index 504fb9bea6..3a017d6b22 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkMLBTView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkMLBTView.cpp
@@ -1,238 +1,246 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable: 4244)
+#endif
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMLBTView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QString>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkImageCast.h>
 #include <mitkEnumerationProperty.h>
 #include <mitkPointSetShapeProperty.h>
 #include <mitkPointSet.h>
 #include <mitkNodePredicateIsDWI.h>
 #include <mitkTractographyForest.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkMLBTView::VIEW_ID = "org.mitk.views.mlbtview";
 using namespace berry;
 
 QmitkMLBTView::QmitkMLBTView()
   : QmitkAbstractView()
   , m_Controls( 0 )
 {
 }
 
 // Destructor
 QmitkMLBTView::~QmitkMLBTView()
 {
   delete m_ForestHandler;
 }
 
 void QmitkMLBTView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMLBTViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->m_StartTrainingButton, SIGNAL ( clicked() ), this, SLOT( StartTrainingThread() ) );
     connect( &m_TrainingWatcher, SIGNAL ( finished() ), this, SLOT( OnTrainingThreadStop() ) );
     connect( m_Controls->m_AddTwButton, SIGNAL ( clicked() ), this, SLOT( AddTrainingWidget() ) );
     connect( m_Controls->m_RemoveTwButton, SIGNAL ( clicked() ), this, SLOT( RemoveTrainingWidget() ) );
 
     mitk::NodePredicateIsDWI::Pointer isDiffusionImage = mitk::NodePredicateIsDWI::New();
 
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
     mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
     AddTrainingWidget();
   }
 
 }
 
 void QmitkMLBTView::SetFocus()
 {
 }
 
 void QmitkMLBTView::AddTrainingWidget()
 {
   std::shared_ptr<QmitkMlbstTrainingDataWidget> tw = std::make_shared<QmitkMlbstTrainingDataWidget>();
   tw->SetDataStorage(this->GetDataStorage());
   m_Controls->m_TwFrame->layout()->addWidget(tw.get());
   m_TrainingWidgets.push_back(tw);
 }
 
 void QmitkMLBTView::RemoveTrainingWidget()
 {
   if(m_TrainingWidgets.size()>1)
   {
     m_TrainingWidgets.back().reset();
     m_TrainingWidgets.pop_back();
   }
 }
 
 void QmitkMLBTView::StartTrainingThread()
 {
   if (!this->IsTrainingInputValid())
   {
     QMessageBox::warning(nullptr, "Training aborted", "Training could not be started. Not all necessary datasets were selected.");
     return;
   }
 
   if (m_Controls->m_FeatureTypeBox->currentIndex()==0)
     m_ForestHandler = new mitk::TrackingHandlerRandomForest<6,28>();
   else
     m_ForestHandler = new mitk::TrackingHandlerRandomForest<6,100>();
 
   QFuture<void> future = QtConcurrent::run( this, &QmitkMLBTView::StartTraining );
   m_TrainingWatcher.setFuture(future);
   m_Controls->m_StartTrainingButton->setEnabled(false);
   m_Controls->m_StartTrainingButton->setText("Training in progress ...");
   m_Controls->m_StartTrainingButton->setToolTip("Training in progress. This can take up to a couple of hours.");
   m_Controls->m_StartTrainingButton->setCursor(Qt::WaitCursor);
   QApplication::processEvents();
 }
 
 void QmitkMLBTView::OnTrainingThreadStop()
 {
   m_Controls->m_StartTrainingButton->setEnabled(true);
   m_Controls->m_StartTrainingButton->setCursor(Qt::ArrowCursor);
   m_Controls->m_StartTrainingButton->setText("Start Training");
   m_Controls->m_StartTrainingButton->setToolTip("Start Training. This can take up to a couple of hours.");
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
 
   switch (m_Controls->m_FeatureTypeBox->currentIndex())
   {
   case 0:
     if (dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->IsForestValid())
       node->SetData(dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->GetForest());
     break;
   case 1:
     if (dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->IsForestValid())
       node->SetData(dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->GetForest());
     break;
   default:
     mitkThrow() << "Unknown feature type!";
   }
 
   QString name("Forest");
   node->SetName(name.toStdString());
   GetDataStorage()->Add(node);
 
   delete m_ForestHandler;
 
   QApplication::processEvents();
 }
 
 void QmitkMLBTView::StartTraining()
 {
   std::vector< mitk::Image::Pointer > m_SelectedDiffImages;
   std::vector< mitk::FiberBundle::Pointer > m_SelectedFB;
   std::vector< ItkUcharImgType::Pointer > m_MaskImages;
   std::vector< ItkUcharImgType::Pointer > m_WhiteMatterImages;
 
   for (auto w : m_TrainingWidgets)
   {
     m_SelectedDiffImages.push_back(dynamic_cast<mitk::Image*>(w->GetImage()->GetData()));
     m_SelectedFB.push_back(dynamic_cast<mitk::FiberBundle*>(w->GetFibers()->GetData()));
 
     if (w->GetMask().IsNotNull())
     {
       mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(w->GetMask()->GetData());
       ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
       mitk::CastToItkImage(img, itkMask);
       m_MaskImages.push_back(itkMask);
     }
     else
       m_MaskImages.push_back(nullptr);
 
     if (w->GetWhiteMatter().IsNotNull())
     {
       mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(w->GetWhiteMatter()->GetData());
       ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
       mitk::CastToItkImage(img, itkMask);
       m_WhiteMatterImages.push_back(itkMask);
     }
     else
       m_WhiteMatterImages.push_back(nullptr);
   }
 
   switch (m_Controls->m_FeatureTypeBox->currentIndex())
   {
   case 0:
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetDwis(m_SelectedDiffImages);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetTractograms(m_SelectedFB);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetMaskImages(m_MaskImages);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetWhiteMatterImages(m_WhiteMatterImages);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetNumTrees(m_Controls->m_NumTreesBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetMaxTreeDepth(m_Controls->m_MaxDepthBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetGrayMatterSamplesPerVoxel(m_Controls->m_GmSamplingBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetSampleFraction(m_Controls->m_SampleFractionBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetFiberSamplingStep(m_Controls->m_TrainingStepSizeBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->SetNumPreviousDirections(m_Controls->m_NumPrevDirs->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_ForestHandler)->StartTraining();
     break;
   case 1:
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetDwis(m_SelectedDiffImages);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetTractograms(m_SelectedFB);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetMaskImages(m_MaskImages);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetWhiteMatterImages(m_WhiteMatterImages);
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetNumTrees(m_Controls->m_NumTreesBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetMaxTreeDepth(m_Controls->m_MaxDepthBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetGrayMatterSamplesPerVoxel(m_Controls->m_GmSamplingBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetSampleFraction(m_Controls->m_SampleFractionBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetFiberSamplingStep(m_Controls->m_TrainingStepSizeBox->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->SetNumPreviousDirections(m_Controls->m_NumPrevDirs->value());
     dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_ForestHandler)->StartTraining();
     break;
   default:
     mitkThrow() << "Unknown feature type!";
   }
 }
 
 bool QmitkMLBTView::IsTrainingInputValid(void) const
 {
   for (auto widget : m_TrainingWidgets)
   {
     if (widget->GetImage().IsNull() || widget->GetFibers().IsNull())
     {
       return false;
     }
   }
 
   return true;
 }
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
index 503be0b386..8e058b5ec6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
@@ -1,819 +1,839 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStreamlineTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkImageToItk.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkQBallImage.h>
 #include <mitkSliceNavigationController.h>
 
 // VTK
 #include <vtkRenderWindowInteractor.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 #include <itkTensorImageToQBallImageFilter.h>
 #include <omp.h>
 
 const std::string QmitkStreamlineTrackingView::VIEW_ID = "org.mitk.views.streamlinetracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStreamlineTrackingWorker::QmitkStreamlineTrackingWorker(QmitkStreamlineTrackingView* view)
     : m_View(view)
 {
 }
 
 void QmitkStreamlineTrackingWorker::run()
 {
     m_View->m_Tracker->Update();
     m_View->m_TrackingThread.quit();
 }
 
 QmitkStreamlineTrackingView::QmitkStreamlineTrackingView()
   : m_TrackingWorker(this)
   , m_Controls(nullptr)
+  , m_FirstTensorProbRun(true)
+  , m_FirstInteractiveRun(true)
   , m_TrackingHandler(nullptr)
   , m_ThreadIsRunning(false)
+  , m_DeleteTrackingHandler(false)
 {
   m_TrackingWorker.moveToThread(&m_TrackingThread);
   connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
   connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
   m_TrackingTimer = new QTimer(this);
 }
 
 // Destructor
 QmitkStreamlineTrackingView::~QmitkStreamlineTrackingView()
 {
   if (m_Tracker.IsNull())
     return;
 
   m_Tracker->SetStopTracking(true);
   m_TrackingThread.wait();
 }
 
 void QmitkStreamlineTrackingView::CreateQtPartControl( QWidget *parent )
 {
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkStreamlineTrackingViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_FaImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_SeedImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MaskImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_StopImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_TissueImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ForestBox->SetDataStorage(this->GetDataStorage());
 
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::TNodePredicateDataType<mitk::TractographyForest>::Pointer isTractographyForest = mitk::TNodePredicateDataType<mitk::TractographyForest>::New();
 
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New( isBinaryPredicate );
     mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New( isImagePredicate, isNotBinaryPredicate );
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
     m_Controls->m_ForestBox->SetPredicate(isTractographyForest);
     m_Controls->m_FaImageBox->SetPredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
     m_Controls->m_FaImageBox->SetZeroEntryText("--");
     m_Controls->m_SeedImageBox->SetPredicate( mitk::NodePredicateAnd::New(isBinaryPredicate, dimensionPredicate) );
     m_Controls->m_SeedImageBox->SetZeroEntryText("--");
     m_Controls->m_MaskImageBox->SetPredicate( mitk::NodePredicateAnd::New(isBinaryPredicate, dimensionPredicate) );
     m_Controls->m_MaskImageBox->SetZeroEntryText("--");
     m_Controls->m_StopImageBox->SetPredicate( mitk::NodePredicateAnd::New(isBinaryPredicate, dimensionPredicate) );
     m_Controls->m_StopImageBox->SetZeroEntryText("--");
     m_Controls->m_TissueImageBox->SetPredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
     m_Controls->m_TissueImageBox->SetZeroEntryText("--");
 
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
     connect( m_Controls->commandLinkButton_2, SIGNAL(clicked()), this, SLOT(StopTractography()) );
     connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
     connect( m_Controls->m_InteractiveBox, SIGNAL(stateChanged(int)), this, SLOT(ToggleInteractive()) );
     connect( m_Controls->m_TissueImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()) );
     connect( m_Controls->m_FaImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(DeleteTrackingHandler()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(DeleteTrackingHandler()) );
     connect( m_Controls->m_OutputProbMap, SIGNAL(stateChanged(int)), this, SLOT(OutputStyleSwitched()) );
 
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MaskImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FaImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ForestBox, SIGNAL(currentIndexChanged(int)), this, SLOT(ForestSwitched()) );
     connect( m_Controls->m_ForestBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedsPerVoxelBox, SIGNAL(valueChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_NumFibersBox, SIGNAL(valueChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ScalarThresholdBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_OdfCutoffBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StepSizeBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SamplingDistanceBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_AngularThresholdBox, SIGNAL(valueChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MinTractLengthBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_fBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_gBox, SIGNAL(valueChanged(double)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_NumSamplesBox, SIGNAL(valueChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedRadiusBox, SIGNAL(valueChanged(double)), this, SLOT(InteractiveSeedChanged()) );
     connect( m_Controls->m_NumSeedsBox, SIGNAL(valueChanged(int)), this, SLOT(InteractiveSeedChanged()) );
     connect( m_Controls->m_OutputProbMap, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SharpenOdfsBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_InterpolationBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedGmBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipXBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipYBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipZBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FrontalSamplesBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopVotesBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
 
-    m_FirstTensorProbRun = true;
     StartStopTrackingGui(false);
   }
 
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::StopTractography()
 {
   if (m_Tracker.IsNull())
     return;
 
   m_Tracker->SetStopTracking(true);
 }
 
 void QmitkStreamlineTrackingView::TimerUpdate()
 {
   if (m_Tracker.IsNull())
     return;
 
   QString status_text(m_Tracker->GetStatusText().c_str());
   m_Controls->m_StatusTextBox->setText(status_text);
 }
 
 void QmitkStreamlineTrackingView::BeforeThread()
 {
   m_TrackingTimer->start(1000);
 }
 
 void QmitkStreamlineTrackingView::AfterThread()
 {
   m_TrackingTimer->stop();
   if (!m_Tracker->GetUseOutputProbabilityMap())
   {
     vtkSmartPointer<vtkPolyData> fiberBundle = m_Tracker->GetFiberPolyData();
 
     if (!m_Controls->m_InteractiveBox->isChecked() && fiberBundle->GetNumberOfLines() == 0)
     {
       QMessageBox warnBox;
       warnBox.setWindowTitle("Warning");
       warnBox.setText("No fiberbundle was generated!");
       warnBox.setDetailedText("No fibers were generated using the chosen parameters. Typical reasons are:\n\n- Cutoff too high. Some images feature very low FA/GFA/peak size. Try to lower this parameter.\n- Angular threshold too strict. Try to increase this parameter.\n- A small step sizes also means many steps to go wrong. Especially in the case of probabilistic tractography. Try to adjust the angular threshold.");
       warnBox.setIcon(QMessageBox::Warning);
       warnBox.exec();
+
+      if (m_InteractivePointSetNode.IsNotNull())
+        m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
+      StartStopTrackingGui(false);
+      if (m_DeleteTrackingHandler)
+        DeleteTrackingHandler();
+      UpdateGui();
+
       return;
     }
 
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())->GetGeometry());
-    if (m_Controls->m_ResampleFibersBox->isChecked())
+    if (m_Controls->m_ResampleFibersBox->isChecked() && fiberBundle->GetNumberOfLines()>0)
       fib->Compress(m_Controls->m_FiberErrorBox->value());
     fib->ColorFibersByOrientation();
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(fib);
 
       if (auto renderWindowPart = this->GetRenderWindowPart())
           renderWindowPart->RequestUpdate();
     }
     else
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(fib);
       QString name("FiberBundle_");
       name += m_InputImageNodes.at(0)->GetName().c_str();
       name += "_Streamline";
       node->SetName(name.toStdString());
       GetDataStorage()->Add(node, m_InputImageNodes.at(0));
     }
   }
   else
   {
     TrackerType::ItkDoubleImgType::Pointer outImg = m_Tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(img);
 
       mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
       lut->SetType(mitk::LookupTable::JET_TRANSPARENT);
       mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
       lut_prop->SetLookupTable(lut);
       m_InteractiveNode->SetProperty("LookupTable", lut_prop);
       m_InteractiveNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
       if (auto renderWindowPart = this->GetRenderWindowPart())
           renderWindowPart->RequestUpdate();
     }
     else
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(img);
       QString name("ProbabilityMap_");
       name += m_InputImageNodes.at(0)->GetName().c_str();
       node->SetName(name.toStdString());
 
       mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
       lut->SetType(mitk::LookupTable::JET_TRANSPARENT);
       mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
       lut_prop->SetLookupTable(lut);
       node->SetProperty("LookupTable", lut_prop);
       node->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
       GetDataStorage()->Add(node, m_InputImageNodes.at(0));
     }
   }
+  if (m_InteractivePointSetNode.IsNotNull())
+    m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
   StartStopTrackingGui(false);
+  if (m_DeleteTrackingHandler)
+    DeleteTrackingHandler();
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::InteractiveSeedChanged(bool posChanged)
 {
+  if (m_ThreadIsRunning)
+    return;
   if (!posChanged && (!m_Controls->m_InteractiveBox->isChecked() || !m_Controls->m_ParamUpdateBox->isChecked()))
     return;
 
   std::srand(std::time(0));
   m_SeedPoints.clear();
 
   itk::Point<float> world_pos = this->GetRenderWindowPart()->GetSelectedPosition();
 
   m_SeedPoints.push_back(world_pos);
   float radius = m_Controls->m_SeedRadiusBox->value();
   int num = m_Controls->m_NumSeedsBox->value();
 
   mitk::PointSet::Pointer pointset = mitk::PointSet::New();
   pointset->InsertPoint(0, world_pos);
   m_InteractivePointSetNode->SetProperty("pointsize", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetProperty("point 2D size", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetData(pointset);
 
   for (int i=1; i<num; i++)
   {
     itk::Vector<float> p;
     p[0] = rand()%1000-500;
     p[1] = rand()%1000-500;
     p[2] = rand()%1000-500;
     p.Normalize();
     p *= radius;
     m_SeedPoints.push_back(world_pos+p);
   }
-
+  m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,0,0));
   DoFiberTracking();
 }
 
 void QmitkStreamlineTrackingView::OnParameterChanged()
 {
   if (m_Controls->m_InteractiveBox->isChecked() && m_Controls->m_ParamUpdateBox->isChecked())
     DoFiberTracking();
 }
 
 void QmitkStreamlineTrackingView::ToggleInteractive()
 {
   UpdateGui();
 
-  mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
-
   m_Controls->m_SeedsPerVoxelBox->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->m_SeedsPerVoxelLabel->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->m_SeedGmBox->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->m_SeedImageBox->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->label_6->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->m_TissueImageBox->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->label_10->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
 
   if ( m_Controls->m_InteractiveBox->isChecked() )
   {
+    if (m_FirstInteractiveRun)
+    {
+      QMessageBox::information(nullptr, "Information", "Place and move a spherical seed region anywhere in the image by left-clicking and dragging. If the seed region is colored red, tracking is in progress. If the seed region is colored white, tracking is finished.\nPlacing the seed region for the first time in a newly selected dataset might cause a short delay, since the tracker needs to be initialized.");
+      m_FirstInteractiveRun = false;
+    }
+
     QApplication::setOverrideCursor(Qt::PointingHandCursor);
     QApplication::processEvents();
 
     m_InteractivePointSetNode = mitk::DataNode::New();
     m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
     m_InteractivePointSetNode->SetName("InteractiveSeedRegion");
     mitk::PointSetShapeProperty::Pointer shape_prop = mitk::PointSetShapeProperty::New();
     shape_prop->SetValue(mitk::PointSetShapeProperty::PointSetShape::CIRCLE);
     m_InteractivePointSetNode->SetProperty("Pointset.2D.shape", shape_prop);
     GetDataStorage()->Add(m_InteractivePointSetNode);
 
-    if (renderWindow)
-    {
-      {
-        mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("axial"))->GetSliceNavigationController();
-        itk::ReceptorMemberCommand<QmitkStreamlineTrackingView>::Pointer command = itk::ReceptorMemberCommand<QmitkStreamlineTrackingView>::New();
-        command->SetCallbackFunction( this, &QmitkStreamlineTrackingView::OnSliceChanged );
-        m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), command );
-      }
-
-      {
-        mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("sagittal"))->GetSliceNavigationController();
-        itk::ReceptorMemberCommand<QmitkStreamlineTrackingView>::Pointer command = itk::ReceptorMemberCommand<QmitkStreamlineTrackingView>::New();
-        command->SetCallbackFunction( this, &QmitkStreamlineTrackingView::OnSliceChanged );
-        m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), command );
-      }
 
-      {
-        mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("coronal"))->GetSliceNavigationController();
-        itk::ReceptorMemberCommand<QmitkStreamlineTrackingView>::Pointer command = itk::ReceptorMemberCommand<QmitkStreamlineTrackingView>::New();
-        command->SetCallbackFunction( this, &QmitkStreamlineTrackingView::OnSliceChanged );
-        m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), command );
-      }
-    }
+    m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
+    connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
   }
   else
   {
     QApplication::restoreOverrideCursor();
     QApplication::processEvents();
 
     m_InteractiveNode = nullptr;
     m_InteractivePointSetNode = nullptr;
 
-    if (renderWindow)
-    {
-      mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("axial"))->GetSliceNavigationController();
-      slicer->RemoveObserver(m_SliceObserverTag1);
-      slicer = renderWindow->GetQmitkRenderWindow(QString("sagittal"))->GetSliceNavigationController();
-      slicer->RemoveObserver(m_SliceObserverTag2);
-      slicer = renderWindow->GetQmitkRenderWindow(QString("coronal"))->GetSliceNavigationController();
-      slicer->RemoveObserver(m_SliceObserverTag3);
-    }
+    m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
+    disconnect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
   }
 }
 
-void QmitkStreamlineTrackingView::OnSliceChanged(const itk::EventObject& /*e*/)
+void QmitkStreamlineTrackingView::OnSliceChanged()
 {
   InteractiveSeedChanged(true);
 }
 
 void QmitkStreamlineTrackingView::SetFocus()
 {
 }
 
 void QmitkStreamlineTrackingView::DeleteTrackingHandler()
 {
-  if (m_TrackingHandler != nullptr)
+  if (!m_ThreadIsRunning && m_TrackingHandler != nullptr)
   {
     delete m_TrackingHandler;
     m_TrackingHandler = nullptr;
+    m_DeleteTrackingHandler = false;
+  }
+  else if (m_ThreadIsRunning)
+  {
+    m_DeleteTrackingHandler = true;
   }
 }
 
 void QmitkStreamlineTrackingView::ForestSwitched()
 {
   DeleteTrackingHandler();
 }
 
 void QmitkStreamlineTrackingView::OutputStyleSwitched()
 {
   if (m_InteractiveNode.IsNotNull())
     GetDataStorage()->Remove(m_InteractiveNode);
   m_InteractiveNode = nullptr;
 }
 
 void QmitkStreamlineTrackingView::OnSelectionChanged( berry::IWorkbenchPart::Pointer , const QList<mitk::DataNode::Pointer>& nodes )
 {
+  std::vector< mitk::DataNode::Pointer > last_nodes = m_InputImageNodes;
   m_InputImageNodes.clear();
   m_InputImages.clear();
   m_AdditionalInputImages.clear();
-  DeleteTrackingHandler();
+  bool retrack = false;
 
   for( auto node : nodes )
   {
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       if( dynamic_cast<mitk::TensorImage*>(node->GetData()) )
       {
         m_InputImageNodes.push_back(node);
         m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
+        retrack = true;
       }
       else if ( dynamic_cast<mitk::QBallImage*>(node->GetData()) )
       {
         m_InputImageNodes.push_back(node);
         m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
+        retrack = true;
       }
       else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) )
       {
         m_InputImageNodes.push_back(node);
         m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
+        retrack = true;
       }
       else
       {
         mitk::Image* img = dynamic_cast<mitk::Image*>(node->GetData());
         if (img!=nullptr)
         {
           int dim = img->GetDimension();
           unsigned int* dimensions = img->GetDimensions();
           if (dim==4 && dimensions[3]%3==0)
           {
             m_InputImageNodes.push_back(node);
             m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
+            retrack = true;
           }
           else if (dim==3)
           {
             m_AdditionalInputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
           }
         }
       }
     }
   }
 
+  // sometimes the OnSelectionChanged event is sent twice and actually no selection has changed for the first event. We need to catch that.
+  if (last_nodes.size() == m_InputImageNodes.size())
+  {
+    bool same_nodes = true;
+    for (unsigned int i=0; i<m_InputImageNodes.size(); i++)
+      if (last_nodes.at(i)!=m_InputImageNodes.at(i))
+      {
+        same_nodes = false;
+        break;
+      }
+    if (same_nodes)
+      return;
+  }
+
+  DeleteTrackingHandler();
   UpdateGui();
-  OnParameterChanged();
+  if (retrack)
+    OnParameterChanged();
 }
 
 void QmitkStreamlineTrackingView::UpdateGui()
 {
   m_Controls->m_TensorImageLabel->setText("<font color='red'>mandatory</font>");
 
   m_Controls->m_fBox->setEnabled(false);
   m_Controls->m_fLabel->setEnabled(false);
   m_Controls->m_gBox->setEnabled(false);
   m_Controls->m_gLabel->setEnabled(false);
   m_Controls->m_FaImageBox->setEnabled(false);
   m_Controls->mFaImageLabel->setEnabled(false);
   m_Controls->m_OdfCutoffBox->setEnabled(false);
   m_Controls->m_OdfCutoffLabel->setEnabled(false);
   m_Controls->m_SharpenOdfsBox->setEnabled(false);
   m_Controls->m_ForestBox->setEnabled(false);
   m_Controls->m_ForestLabel->setEnabled(false);
   m_Controls->commandLinkButton->setEnabled(false);
 
   if (m_Controls->m_TissueImageBox->GetSelectedNode().IsNotNull())
     m_Controls->m_SeedGmBox->setEnabled(true);
   else
     m_Controls->m_SeedGmBox->setEnabled(false);
 
   if(!m_InputImageNodes.empty())
   {
     if (m_InputImageNodes.size()>1)
       m_Controls->m_TensorImageLabel->setText(m_InputImageNodes.size()+" images selected");
     else
       m_Controls->m_TensorImageLabel->setText(m_InputImageNodes.at(0)->GetName().c_str());
     m_Controls->m_InputData->setTitle("Input Data");
     m_Controls->commandLinkButton->setEnabled(!m_Controls->m_InteractiveBox->isChecked() && !m_ThreadIsRunning);
 
     m_Controls->m_ScalarThresholdBox->setEnabled(true);
     m_Controls->m_FaThresholdLabel->setEnabled(true);
 
     if ( dynamic_cast<mitk::TensorImage*>(m_InputImageNodes.at(0)->GetData()) )
     {
       m_Controls->m_fBox->setEnabled(true);
       m_Controls->m_fLabel->setEnabled(true);
       m_Controls->m_gBox->setEnabled(true);
       m_Controls->m_gLabel->setEnabled(true);
       m_Controls->mFaImageLabel->setEnabled(true);
       m_Controls->m_FaImageBox->setEnabled(true);
     }
     else if ( dynamic_cast<mitk::QBallImage*>(m_InputImageNodes.at(0)->GetData()) )
     {
       m_Controls->mFaImageLabel->setEnabled(true);
       m_Controls->m_FaImageBox->setEnabled(true);
 
       m_Controls->m_OdfCutoffBox->setEnabled(true);
       m_Controls->m_OdfCutoffLabel->setEnabled(true);
       m_Controls->m_SharpenOdfsBox->setEnabled(true);
     }
     else if (  mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_InputImageNodes.at(0)->GetData())) )
     {
       m_Controls->m_ForestBox->setEnabled(true);
       m_Controls->m_ForestLabel->setEnabled(true);
       m_Controls->m_ScalarThresholdBox->setEnabled(false);
       m_Controls->m_FaThresholdLabel->setEnabled(false);
     }
   }
   else
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
 }
 
 void QmitkStreamlineTrackingView::StartStopTrackingGui(bool start)
 {
   m_ThreadIsRunning = start;
 
   if (!m_Controls->m_InteractiveBox->isChecked())
   {
     m_Controls->commandLinkButton_2->setVisible(start);
     m_Controls->commandLinkButton->setVisible(!start);
     m_Controls->m_InteractiveBox->setEnabled(!start);
     m_Controls->m_StatusTextBox->setVisible(start);
   }
 }
 
 void QmitkStreamlineTrackingView::DoFiberTracking()
 {
   if (m_ThreadIsRunning)
     return;
   if (m_InputImages.empty())
     return;
   if (m_Controls->m_InteractiveBox->isChecked() && m_SeedPoints.empty())
     return;
   StartStopTrackingGui(true);
 
   m_Tracker = TrackerType::New();
 
   if( dynamic_cast<mitk::TensorImage*>(m_InputImageNodes.at(0)->GetData()) )
   {
     typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
     typedef mitk::ImageToItk<TensorImageType> CasterType;
 
     if (m_Controls->m_ModeBox->currentIndex()==1)
     {
       if (m_InputImages.size()>1)
       {
         QMessageBox::information(nullptr, "Information", "Probabilistic tensor tractography is only implemented for single-tensor mode!");
         StartStopTrackingGui(false);
         return;
       }
 
       if (m_FirstTensorProbRun)
       {
         QMessageBox::information(nullptr, "Information", "Internally calculating ODF from tensor image and performing probabilistic ODF tractography. ODFs are sharpened (min-max normalized and raised to the power of 4). TEND parameters are ignored.");
         m_FirstTensorProbRun = false;
       }
 
       if (m_TrackingHandler==nullptr)
       {
         typedef mitk::ImageToItk< mitk::TrackingHandlerOdf::ItkOdfImageType > CasterType;
         m_TrackingHandler = new mitk::TrackingHandlerOdf();
         TensorImageType::Pointer itkImg = TensorImageType::New();
         mitk::CastToItkImage(m_InputImages.at(0), itkImg);
 
         typedef itk::TensorImageToQBallImageFilter< float, float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput( itkImg );
         filter->Update();
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(filter->GetOutput());
 
         if (m_Controls->m_FaImageBox->GetSelectedNode().IsNotNull())
         {
           ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
           mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaImage(itkImg);
         }
       }
 
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaThreshold(m_Controls->m_ScalarThresholdBox->value());
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfThreshold(0);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetSharpenOdfs(true);
     }
     else
     {
       if (m_TrackingHandler==nullptr)
       {
         m_TrackingHandler = new mitk::TrackingHandlerTensor();
         for (int i=0; i<(int)m_InputImages.size(); i++)
         {
           TensorImageType::Pointer itkImg = TensorImageType::New();
           mitk::CastToItkImage(m_InputImages.at(i), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->AddTensorImage(itkImg);
         }
 
         if (m_Controls->m_FaImageBox->GetSelectedNode().IsNotNull())
         {
           ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
           mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetFaImage(itkImg);
         }
       }
 
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetFaThreshold(m_Controls->m_ScalarThresholdBox->value());
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetF((float)m_Controls->m_fBox->value());
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetG((float)m_Controls->m_gBox->value());
     }
   }
   else if ( dynamic_cast<mitk::QBallImage*>(m_InputImageNodes.at(0)->GetData()) )
   {
     if (m_TrackingHandler==nullptr)
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerOdf::ItkOdfImageType > CasterType;
       m_TrackingHandler = new mitk::TrackingHandlerOdf();
       mitk::TrackingHandlerOdf::ItkOdfImageType::Pointer itkImg = mitk::TrackingHandlerOdf::ItkOdfImageType::New();
       mitk::CastToItkImage(m_InputImages.at(0), itkImg);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(itkImg);
 
       if (m_Controls->m_FaImageBox->GetSelectedNode().IsNotNull())
       {
         ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
         mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()), itkImg);
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaImage(itkImg);
       }
     }
 
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaThreshold(m_Controls->m_ScalarThresholdBox->value());
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfThreshold(m_Controls->m_OdfCutoffBox->value());
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetSharpenOdfs(m_Controls->m_SharpenOdfsBox->isChecked());
   }
   else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())) )
   {
     if ( m_Controls->m_ForestBox->GetSelectedNode().IsNull() )
     {
       QMessageBox::information(nullptr, "Information", "Not random forest for machine learning based tractography selected.");
       StartStopTrackingGui(false);
       return;
     }
 
     if (m_TrackingHandler==nullptr)
     {
       mitk::TractographyForest::Pointer forest = dynamic_cast<mitk::TractographyForest*>(m_Controls->m_ForestBox->GetSelectedNode()->GetData());
       mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData());
 
       std::vector< std::vector< ItkFloatImageType::Pointer > > additionalFeatureImages;
       additionalFeatureImages.push_back(std::vector< ItkFloatImageType::Pointer >());
       for (auto img : m_AdditionalInputImages)
       {
         ItkFloatImageType::Pointer itkimg = ItkFloatImageType::New();
         mitk::CastToItkImage(img, itkimg);
         additionalFeatureImages.at(0).push_back(itkimg);
       }
 
       bool forest_valid = false;
       if (forest->GetNumFeatures()>=100)
       {
         int num_previous_directions = (forest->GetNumFeatures() - (100 + additionalFeatureImages.at(0).size()))/3;
         m_TrackingHandler = new mitk::TrackingHandlerRandomForest<6, 100>();
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->AddDwi(dwi);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetAdditionalFeatureImages(additionalFeatureImages);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetForest(forest);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetNumPreviousDirections(num_previous_directions);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->IsForestValid();
       }
       else
       {
         int num_previous_directions = (forest->GetNumFeatures() - (28 + additionalFeatureImages.at(0).size()))/3;
         m_TrackingHandler = new mitk::TrackingHandlerRandomForest<6, 28>();
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->AddDwi(dwi);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetAdditionalFeatureImages(additionalFeatureImages);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetForest(forest);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetNumPreviousDirections(num_previous_directions);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->IsForestValid();
       }
 
       if (!forest_valid)
       {
         QMessageBox::information(nullptr, "Information", "Random forest is invalid. The forest signatue does not match the parameters of TrackingHandlerRandomForest.");
         StartStopTrackingGui(false);
         return;
       }
     }
   }
   else
   {
     if (m_Controls->m_ModeBox->currentIndex()==1)
     {
       QMessageBox::information(nullptr, "Information", "Probabilstic tractography is not implemented for peak images.");
       StartStopTrackingGui(false);
       return;
     }
     try {
 
       if (m_TrackingHandler==nullptr)
       {
         typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(m_InputImages.at(0));
         caster->Update();
         mitk::TrackingHandlerPeaks::PeakImgType::Pointer itkImg = caster->GetOutput();
         m_TrackingHandler = new mitk::TrackingHandlerPeaks();
         dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler)->SetPeakImage(itkImg);
       }
 
       dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler)->SetPeakThreshold(m_Controls->m_ScalarThresholdBox->value());
     }
     catch(...)
     {
       StartStopTrackingGui(false);
       return;
     }
   }
 
   m_TrackingHandler->SetFlipX(m_Controls->m_FlipXBox->isChecked());
   m_TrackingHandler->SetFlipY(m_Controls->m_FlipYBox->isChecked());
   m_TrackingHandler->SetFlipZ(m_Controls->m_FlipZBox->isChecked());
   m_TrackingHandler->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
   switch (m_Controls->m_ModeBox->currentIndex())
   {
   case 0:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
     break;
   case 1:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
     break;
   default:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
   }
 
   if (m_Controls->m_InteractiveBox->isChecked())
   {
     m_Tracker->SetSeedPoints(m_SeedPoints);
   }
   else if (m_Controls->m_SeedImageBox->GetSelectedNode().IsNotNull())
   {
     ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_SeedImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetSeedImage(mask);
   }
 
   if (m_Controls->m_MaskImageBox->GetSelectedNode().IsNotNull())
   {
     ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_MaskImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetMaskImage(mask);
   }
 
   if (m_Controls->m_StopImageBox->GetSelectedNode().IsNotNull())
   {
     ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_StopImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetStoppingRegions(mask);
   }
 
   if (m_Controls->m_TissueImageBox->GetSelectedNode().IsNotNull())
   {
     ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_TissueImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetTissueImage(mask);
     m_Tracker->SetSeedOnlyGm(m_Controls->m_SeedGmBox->isChecked());
   }
 
+  m_Tracker->SetVerbose(!m_Controls->m_InteractiveBox->isChecked());
   m_Tracker->SetSeedsPerVoxel(m_Controls->m_SeedsPerVoxelBox->value());
   m_Tracker->SetStepSize(m_Controls->m_StepSizeBox->value());
   m_Tracker->SetSamplingDistance(m_Controls->m_SamplingDistanceBox->value());
   m_Tracker->SetUseStopVotes(m_Controls->m_StopVotesBox->isChecked());
   m_Tracker->SetOnlyForwardSamples(m_Controls->m_FrontalSamplesBox->isChecked());
   m_Tracker->SetAposterioriCurvCheck(false);
   m_Tracker->SetMaxNumTracts(m_Controls->m_NumFibersBox->value());
   m_Tracker->SetNumberOfSamples(m_Controls->m_NumSamplesBox->value());
   m_Tracker->SetTrackingHandler(m_TrackingHandler);
   m_Tracker->SetAngularThreshold(m_Controls->m_AngularThresholdBox->value());
   m_Tracker->SetMinTractLength(m_Controls->m_MinTractLengthBox->value());
   m_Tracker->SetUseOutputProbabilityMap(m_Controls->m_OutputProbMap->isChecked());
 
   m_TrackingThread.start(QThread::LowestPriority);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h
index 4c377537d2..097653bee0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h
@@ -1,140 +1,143 @@
 /*===================================================================
 
 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 QmitkStreamlineTrackingView_h
 #define QmitkStreamlineTrackingView_h
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkStreamlineTrackingViewControls.h"
 
 #include <mitkTensorImage.h>
 #include <mitkDataStorage.h>
 #include <mitkDataNode.h>
 #include <mitkImage.h>
 #include <itkImage.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h>
 #include <random>
 #include <mitkPointSet.h>
 #include <mitkPointSetShapeProperty.h>
 #include <mitkTractographyForest.h>
 #include <QThread>
 #include <QTimer>
+#include <QmitkStdMultiWidget.h>
+#include <QmitkSliceNavigationListener.h>
 
 class QmitkStreamlineTrackingView;
 
 class QmitkStreamlineTrackingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkStreamlineTrackingWorker(QmitkStreamlineTrackingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkStreamlineTrackingView* m_View;
 };
 
 /*!
 \brief View for tensor based deterministic streamline fiber tracking.
 */
 class QmitkStreamlineTrackingView : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   typedef itk::Image< unsigned char, 3 >  ItkUCharImageType;
   typedef itk::Image< float, 3 >          ItkFloatImageType;
   typedef itk::StreamlineTrackingFilter   TrackerType;
 
   QmitkStreamlineTrackingView();
   virtual ~QmitkStreamlineTrackingView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Sets the focus to an internal widget.
   ///
   virtual void SetFocus() override;
 
   TrackerType::Pointer              m_Tracker;
   QmitkStreamlineTrackingWorker     m_TrackingWorker;
   QThread                           m_TrackingThread;
 
 protected slots:
 
   void DoFiberTracking();   ///< start fiber tracking
   void UpdateGui();
   void ToggleInteractive();
   void DeleteTrackingHandler();
   void OnParameterChanged();
   void InteractiveSeedChanged(bool posChanged=false);
   void ForestSwitched();
   void OutputStyleSwitched();
   void AfterThread();                       ///< update gui etc. after tracking has finished
   void BeforeThread();                      ///< start timer etc.
   void TimerUpdate();
   void StopTractography();
+  void OnSliceChanged();
 
 protected:
 
   /// \brief called by QmitkAbstractView when DataManager's selection has changed
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkStreamlineTrackingViewControls* m_Controls;
 
 protected slots:
 
 private:
 
   void StartStopTrackingGui(bool start);
-  void OnSliceChanged(const itk::EventObject& e);
 
-  int m_SliceObserverTag1;
-  int m_SliceObserverTag2;
-  int m_SliceObserverTag3;
   std::vector< itk::Point<float> >        m_SeedPoints;
   mitk::DataNode::Pointer                 m_InteractiveNode;
   mitk::DataNode::Pointer                 m_InteractivePointSetNode;
 
   std::vector< mitk::DataNode::Pointer >  m_InputImageNodes; ///< input image nodes
   std::vector< mitk::Image::Pointer >     m_InputImages; ///< input images
   std::vector< mitk::Image::Pointer >     m_AdditionalInputImages;
   bool                                    m_FirstTensorProbRun;
+  bool                                    m_FirstInteractiveRun;
 
   mitk::TrackingDataHandler*              m_TrackingHandler;
   bool                                    m_ThreadIsRunning;
   QTimer*                                 m_TrackingTimer;
+  bool                                    m_DeleteTrackingHandler;
+  QmitkSliceNavigationListener            m_SliceChangeListener;
+
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index 6f3df84521..7fe4b64111 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1178 +1,1179 @@
 /*===================================================================
 
 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 "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkTbssImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "mitkPlanarFigureInteractor.h"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkConnectomicsNetwork.h>
 #include "usModuleRegistry.h"
 
 #include <mitkBaseRenderer.h>
 #include "mitkPlaneGeometry.h"
 #include <QmitkRenderWindow.h>
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include <itkTractDensityImageFilter.h>
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 #include <QRgb>
 #include <itkMultiThreader.h>
 
 #include <ciso646>
 
 #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
   : QmitkAbstractView(),
     m_Controls(nullptr),
     m_CurrentSelection(0),
     m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
     m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
     m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
     m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
     m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
     m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
     m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
     m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
     m_GlyIsOn_T(false),
     m_GlyIsOn_C(false),
     m_GlyIsOn_S(false),
     m_CurrentPickingNode(0),
     m_FiberBundleObserverTag(0),
     m_FiberBundleObserveOpacityTag(0)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = nullptr;
   int numThread = itk::MultiThreader::GetGlobalMaximumNumberOfThreads();
   if (numThread > 12)
     numThread = 12;
   itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThread);
 }
 
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener.data());
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
 {
   currentThickSlicesMode = action->data().toInt();
 
   switch( currentThickSlicesMode )
   {
     case 0: // toInt() returns 0 'otherwise'.
       return; // dummy code/todo: implement stuff.
 
     case 1:
       this->m_Controls->m_TSMenu->setText("MIP");
       break;
 
     case 2:
       this->m_Controls->m_TSMenu->setText("SUM");
       break;
 
     case 3:
       this->m_Controls->m_TSMenu->setText("WEIGH");
       break;
 
     default:
       return; // dummy code/todo: implement stuff.
   }
 
   if (auto renderWindowPart = this->GetRenderWindowPart(OPEN))
   {
     /// TODO There is no way to access the individual crosshair planes through the render window part API.
     /// There could be a new 'mitk::DataNode* mitk::ILinkedRenderWindowPart::GetSlicingPlane(const std::string& name) const'
     /// function for this purpose. For the time being, I comment out the lines below, but they are valid
     /// and they have to be re-enabled after the crosshair planes can be accessed again.
 
 //    mitk::DataNode* n;
 //    n = renderWindowPart->GetSlicingPlane("axial");
 //    if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
 
 //    n = renderWindowPart->GetSlicingPlane("sagittal");
 //    if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
 
 //    n = renderWindowPart->GetSlicingPlane("coronal");
 //    if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
 
 
     mitk::BaseRenderer::Pointer renderer;
     renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer();
     if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer();
     if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer();
     if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer->GetRenderingManager()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnTSNumChanged( int num )
 {
   if (auto renderWindowPart = this->GetRenderWindowPart(OPEN))
   {
 
     /// TODO There is no way to access the individual crosshair planes through the render window part API.
     /// There could be a new 'mitk::DataNode* mitk::ILinkedRenderWindowPart::GetSlicingPlane(const std::string& name) const'
     /// function for this purpose. For the time being, I comment out the lines below, but they are valid
     /// and they have to be re-enabled after the crosshair planes can be accessed again.
 
 //    if(num==0)
 //    {
 //      mitk::DataNode* n;
 //      n = renderWindowPart->GetSlicingPlane("axial");
 //      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
 //      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
 //      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 //
 //      n = renderWindowPart->GetSlicingPlane("sagittal");
 //      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
 //      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
 //      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 //
 //      n = renderWindowPart->GetSlicingPlane("coronal");
 //      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
 //      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
 //      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 //    }
 //    else
 //    {
 //      mitk::DataNode* n;
 //      n = renderWindowPart->GetSlicingPlane("axial");
 //      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 //      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
 //      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 //
 //      n = renderWindowPart->GetSlicingPlane("sagittal");
 //      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 //      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
 //      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 //
 //      n = renderWindowPart->GetSlicingPlane("coronal");
 //      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 //      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
 //      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 //    }
 
     m_TSLabel->setText(QString::number( num*2 + 1 ));
 
     mitk::BaseRenderer::Pointer renderer;
     renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer();
     if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer = nullptr;
     renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer();
     if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer = nullptr;
     renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer();
     if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     // hide warning (ODFs in rotated planes)
     m_Controls->m_lblRotatedPlanesWarning->hide();
 
     m_MyMenu = new QMenu(parent);
     m_Controls->m_TSMenu->setMenu( m_MyMenu );
 
     QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
     m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     int size = m_Controls->m_AdditionalScaling->count();
     for(int t=0; t<size; t++)
     {
       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
       {
         m_Controls->m_AdditionalScaling->removeItem(t);
       }
     }
 #endif
 
     m_Controls->m_ScalingFrame->setVisible(false);
     m_Controls->m_NormalizationFrame->setVisible(false);
+    m_Controls->m_Crosshair->setVisible(false);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFocus()
 {
   m_Controls->m_TSMenu->setFocus();
 }
 
 
 void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
 {
   // test if plane rotated
   if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
   {
     if( this->IsPlaneRotated() )
     {
       // show label
       m_Controls->m_lblRotatedPlanesWarning->show();
     }
     else
     {
       //hide label
       m_Controls->m_lblRotatedPlanesWarning->hide();
     }
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::NodeRemoved(const mitk::DataNode* /*node*/)
 {
 }
 
 
 #include <mitkMessage.h>
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
     connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
     connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
     connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
     connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
     connect((QObject*) m_Controls->m_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged()));
     connect((QObject*) m_Controls->m_TubeWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(TubeRadiusChanged()));
     connect( (QObject*) m_Controls->m_EllipsoidViewRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnTensorViewChanged() ) );
     connect( (QObject*) m_Controls->m_colouriseRainbowRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnColourisationModeChanged() ) );
     connect( (QObject*) m_Controls->m_randomModeRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnRandomModeChanged() ) );
   }
 }
 
 
 // set diffusion image channel to b0 volume
 void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
 {
   mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
 
   if (isDiffusionImage)
   {
     mitk::Image::Pointer dimg = dynamic_cast<mitk::Image*>(notConst->GetData());
 
     // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
     // and hence we cannot set the Property directly to .front()
     int displayChannelPropertyValue = 0;
     mitk::BValueMapProperty* bmapproperty
         = static_cast<mitk::BValueMapProperty*>
         (dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() );
 
     mitk::DiffusionPropertyHelper::BValueMapType map = bmapproperty->GetBValueMap();
 
     if( map[0].size() > 0) { displayChannelPropertyValue = map[0].front(); }
 
     notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
   }
 }
 
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
 implement SelectionService Listener explicitly */
 void QmitkControlVisualizationPropertiesView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   m_Controls->m_BundleControlsFrame->setVisible(false);
   m_Controls->m_ImageControlsFrame->setVisible(false);
 
   if (nodes.size()>1) // only do stuff if one node is selected
     return;
 
   m_Controls->m_NumberGlyphsFrame->setVisible(false);
   m_Controls->m_GlyphFrame->setVisible(false);
   m_Controls->m_TSMenu->setVisible(false);
 
   m_SelectedNode = nullptr;
 
   int numOdfImages = 0;
   for (mitk::DataNode::Pointer node: nodes)
   {
     if(node.IsNull())
       continue;
 
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == nullptr)
       continue;
 
     m_SelectedNode = node;
 
     if (dynamic_cast<mitk::FiberBundle*>(nodeData))
     {
       // handle fiber bundle property observers
       if (m_Color.IsNotNull()) { m_Color->RemoveObserver(m_FiberBundleObserverTag); }
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command
           = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
       m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", nullptr));
       if (m_Color.IsNotNull())
         m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
 
       if (m_Opacity.IsNotNull())
       {
         m_Opacity->RemoveObserver(m_FiberBundleObserveOpacityTag);
       }
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2
           = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity );
       m_Opacity = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("opacity", nullptr));
 
       if (m_Opacity.IsNotNull())
       {
         m_FiberBundleObserveOpacityTag = m_Opacity->AddObserver( itk::ModifiedEvent(), command2 );
       }
 
       m_Controls->m_BundleControlsFrame->setVisible(true);
 
       if(m_CurrentPickingNode != 0 && node.GetPointer() != m_CurrentPickingNode)
       { m_Controls->m_Crosshair->setEnabled(false); }
       else
       { m_Controls->m_Crosshair->setEnabled(true); }
 
       int width;
       node->GetIntProperty("shape.linewidth", width);
       m_Controls->m_LineWidth->setValue(width);
 
       float radius;
       node->GetFloatProperty("shape.tuberadius", radius);
       m_Controls->m_TubeWidth->setValue(radius);
 
       float range;
       node->GetFloatProperty("Fiber2DSliceThickness",range);
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
       mitk::BaseGeometry::Pointer geo = fib->GetGeometry();
       mitk::ScalarType max = geo->GetExtentInMM(0);
       max = std::max(max, geo->GetExtentInMM(1));
       max = std::max(max, geo->GetExtentInMM(2));
 
       m_Controls->m_FiberThicknessSlider->setMaximum(max * 10);
       m_Controls->m_FiberThicknessSlider->setValue(range * 10);
     }
     else if(dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData))
     {
       m_Controls->m_ImageControlsFrame->setVisible(true);
       m_Controls->m_NumberGlyphsFrame->setVisible(true);
       m_Controls->m_GlyphFrame->setVisible(true);
       m_Controls->m_NormalizationFrame->setVisible(true);
 
       if(m_NodeUsedForOdfVisualization.IsNotNull())
       {
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
       }
       m_NodeUsedForOdfVisualization = node;
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
 
       int val;
       node->GetIntProperty("ShowMaxNumber", val);
       m_Controls->m_ShowMaxNumber->setValue(val);
 
       m_Controls->m_NormalizationDropdown
           ->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))
                             ->GetValueAsId());
 
       float fval;
       node->GetFloatProperty("Scaling",fval);
       m_Controls->m_ScalingFactor->setValue(fval);
 
       m_Controls->m_AdditionalScaling
           ->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
       bool switchTensorViewValue = false;
       node->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", switchTensorViewValue );
       if( dynamic_cast<mitk::TensorImage*>(nodeData) )
       {
         m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( true );
         m_Controls-> m_EllipsoidViewRadioButton-> setChecked( switchTensorViewValue );
       }
       else
       {
         m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( false );
         m_Controls-> m_EllipsoidViewRadioButton-> setChecked( false );
       }
 
       bool colourisationModeBit = false;
       node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", colourisationModeBit );
       m_Controls-> m_colouriseSimpleRadioButton-> setChecked( colourisationModeBit );
 
       bool randomModeBit = false;
       node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", randomModeBit );
       m_Controls-> m_randomModeRadioButton-> setChecked( randomModeBit );
 
       numOdfImages++;
     }
     else if(dynamic_cast<mitk::PlanarFigure*>(nodeData))
     {
       PlanarFigureFocus();
     }
     else if( dynamic_cast<mitk::Image*>(nodeData) )
     {
       m_Controls->m_ImageControlsFrame->setVisible(true);
       m_Controls->m_TSMenu->setVisible(true);
     }
   }
 
   if( nodes.empty() ) { return; }
 
   mitk::DataNode::Pointer node = nodes.at(0);
 
   if( node.IsNull() ) { return; }
 
   QMenu *myMenu = m_MyMenu;
   myMenu->clear();
 
   QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
   thickSlicesActionGroup->setExclusive(true);
 
   int currentTSMode = 0;
   {
     mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(node->GetProperty( "reslice.thickslices" ));
     if( m.IsNotNull() )
       currentTSMode = m->GetValueAsId();
   }
 
   int maxTS = 30;
 
   for (auto node: nodes)
   {
     mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
     if (image)
     {
       int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2)));
 
       if (size>maxTS) { maxTS=size; }
     }
   }
   maxTS /= 2;
 
   int currentNum = 0;
   {
     mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(node->GetProperty( "reslice.thickslices.num" ));
     if( m.IsNotNull() )
     {
       currentNum = m->GetValue();
       if(currentNum < 0) { currentNum = 0; }
       if(currentNum > maxTS) { currentNum = maxTS; }
     }
   }
 
   if(currentTSMode==0) { currentNum=0; }
 
   QSlider *m_TSSlider = new QSlider(myMenu);
   m_TSSlider->setMinimum(0);
   m_TSSlider->setMaximum(maxTS-1);
   m_TSSlider->setValue(currentNum);
 
   m_TSSlider->setOrientation(Qt::Horizontal);
 
   connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
 
   QHBoxLayout* _TSLayout = new QHBoxLayout;
   _TSLayout->setContentsMargins(4,4,4,4);
   _TSLayout->addWidget(m_TSSlider);
   _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
 
   QWidget* _TSWidget = new QWidget;
   _TSWidget->setLayout(_TSLayout);
 
   QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
   thickSliceModeActionGroup->setExclusive(true);
 
   QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
   m_TSSliderAction->setDefaultWidget(_TSWidget);
   myMenu->addAction(m_TSSliderAction);
 
   QAction* mipThickSlicesAction = new QAction(myMenu);
   mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   mipThickSlicesAction->setText("MIP (max. intensity proj.)");
   mipThickSlicesAction->setCheckable(true);
   mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
   mipThickSlicesAction->setData(1);
   myMenu->addAction( mipThickSlicesAction );
 
   QAction* sumThickSlicesAction = new QAction(myMenu);
   sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   sumThickSlicesAction->setText("SUM (sum intensity proj.)");
   sumThickSlicesAction->setCheckable(true);
   sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
   sumThickSlicesAction->setData(2);
   myMenu->addAction( sumThickSlicesAction );
 
   QAction* weightedThickSlicesAction = new QAction(myMenu);
   weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
   weightedThickSlicesAction->setCheckable(true);
   weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
   weightedThickSlicesAction->setData(3);
   myMenu->addAction( weightedThickSlicesAction );
 
   connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
 }
 
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
   m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is nullptr";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
   m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is nullptr";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
   m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is nullptr";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
 {
   mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
   if( currentImage == nullptr )
   {
     MITK_ERROR << " Casting problems. Returning false";
     return false;
   }
 
   mitk::Vector3D imageNormal0 = currentImage->GetSlicedGeometry()->GetAxisVector(0);
   mitk::Vector3D imageNormal1 = currentImage->GetSlicedGeometry()->GetAxisVector(1);
   mitk::Vector3D imageNormal2 = currentImage->GetSlicedGeometry()->GetAxisVector(2);
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   auto renderWindowPart = this->GetRenderWindowPart();
 
   double eps = 0.000001;
   // for all 2D renderwindows of the render window part check alignment
   {
     mitk::PlaneGeometry::ConstPointer displayPlane
         = dynamic_cast<const mitk::PlaneGeometry*>
         ( renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()->GetCurrentWorldPlaneGeometry() );
 
     if (displayPlane.IsNull()) { return false; }
 
     mitk::Vector3D normal = displayPlane->GetNormal();
     normal.Normalize();
     int test = 0;
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; }
 
     if (test==3) { return true; }
   }
   {
     mitk::PlaneGeometry::ConstPointer displayPlane
         = dynamic_cast<const mitk::PlaneGeometry*>
         ( renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer()->GetCurrentWorldPlaneGeometry() );
 
     if (displayPlane.IsNull()) { return false; }
 
     mitk::Vector3D normal = displayPlane->GetNormal();
     normal.Normalize();
     int test = 0;
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; }
 
     if (test==3) { return true; }
   }
   {
     mitk::PlaneGeometry::ConstPointer displayPlane
         = dynamic_cast<const mitk::PlaneGeometry*>
         ( renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer()->GetCurrentWorldPlaneGeometry() );
 
     if (displayPlane.IsNull()) { return false; }
 
     mitk::Vector3D normal = displayPlane->GetNormal();
     normal.Normalize();
     int test = 0;
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; }
 
     if (test==3) { return true; }
   }
 
   return false;
 }
 
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetIntProperty("ShowMaxNumber", maxNr);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
     case 0:
       normMeth->SetNormalizationToMinMax();
     break;
     case 1:
       normMeth->SetNormalizationToMax();
     break;
     case 2:
       normMeth->SetNormalizationToNone();
     break;
     case 3:
       normMeth->SetNormalizationToGlobalMax();
     break;
     default:
       normMeth->SetNormalizationToMinMax();
   }
 
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetProperty("Normalization", normMeth.GetPointer());
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetFloatProperty("Scaling", scalingFactor);
   }
 
   if (auto renderWindowPart = this->GetRenderWindowPart())
   {
     renderWindowPart->RequestUpdate();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
     case 0:
       scaleBy->SetScaleByNothing();
     break;
     case 1:
       scaleBy->SetScaleByGFA();
       //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
     case 2:
       scaleBy->SetScaleByPrincipalCurvature();
       // commented in for SPIE paper, Principle curvature scaling
       //m_Controls->params_frame->setVisible(true);
     break;
 #endif
     default:
       scaleBy->SetScaleByNothing();
   }
 
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetProperty("Normalization", scaleBy.GetPointer());
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible( m_Controls->m_ScalingCheckbox->isChecked() );
 
   if( ! m_Controls->m_ScalingCheckbox->isChecked() )
   {
     m_Controls->m_AdditionalScaling->setCurrentIndex(0);
     m_Controls->m_ScalingFactor->setValue(1.0);
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
 {
   if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()) )
   {
     bool currentMode;
     m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
     m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
     dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
 {
   if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
     float currentThickness = 0;
     m_SelectedNode->GetFloatProperty("Fiber2DSliceThickness", currentThickness);
     if ( fabs(fibThickness-currentThickness) < 0.001 )
     {
       return;
     }
 
     m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
     dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
 {
   QString label = "Range %1 mm";
   label = label.arg(value * 0.1);
   m_Controls->label_range->setText(label);
   FiberSlicingThickness2D();
 }
 
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity(const itk::EventObject& /*e*/)
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     fib->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     float color[3];
     m_SelectedNode->GetColor(color);
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     fib->SetFiberColors(color[0]*255, color[1]*255, color[2]*255);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     fib->ColorFibersByOrientation();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       auto renderWindowPart = this->GetRenderWindowPart(OPEN);
 
       QmitkRenderWindow* axialRenderWindow =
           renderWindowPart->GetQmitkRenderWindow("axial");
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
                                           PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
       {
         selectedRenderWindow = axialRenderWindow;
       }
 
       QmitkRenderWindow* sagittalRenderWindow =
           renderWindowPart->GetQmitkRenderWindow("sagittal");
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
             "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
             sagittalRenderWindow->GetRenderer()))
       {
         selectedRenderWindow = sagittalRenderWindow;
       }
 
       QmitkRenderWindow* coronalRenderWindow =
           renderWindowPart->GetQmitkRenderWindow("coronal");
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
             "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
             coronalRenderWindow->GetRenderer()))
       {
         selectedRenderWindow = coronalRenderWindow;
       }
 
       QmitkRenderWindow* _3DRenderWindow =
           renderWindowPart->GetQmitkRenderWindow("3d");
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
             "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
             _3DRenderWindow->GetRenderer()))
       {
         selectedRenderWindow = _3DRenderWindow;
       }
 
       const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
           axialRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
           dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
           sagittalRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
           dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
           coronalRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
           dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = axialRenderWindow;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = sagittalRenderWindow;
         }
         else
         {
           selectedRenderWindow = coronalRenderWindow;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
               centerP, _PlaneGeometry->GetNormal());
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::SetInteractor()
 {
   // BUG 19179
   //    typedef std::vector<mitk::DataNode*> Container;
   //    Container _NodeSet = this->GetDataManagerSelection();
   //    mitk::DataNode* node = 0;
   //    mitk::FiberBundle* bundle = 0;
   //    mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   //    // finally add all nodes to the model
   //    for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
   //        ; it++)
   //    {
   //        node = const_cast<mitk::DataNode*>(*it);
   //        bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
   //        if(bundle)
   //        {
   //            bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
   //            if(bundleInteractor.IsNotNull())
   //                mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
   //            if(!m_Controls->m_Crosshair->isChecked())
   //            {
   //                m_Controls->m_Crosshair->setChecked(false);
   //                this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
   //                m_CurrentPickingNode = 0;
   //            }
   //            else
   //            {
   //                m_Controls->m_Crosshair->setChecked(true);
   //                bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
   //                mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
   //                this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
   //                m_CurrentPickingNode = node;
   //            }
 
   //        }
   //    }
 }
 
 
 void QmitkControlVisualizationPropertiesView::TubeRadiusChanged()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     float newRadius = m_Controls->m_TubeWidth->value();
     m_SelectedNode->SetFloatProperty("shape.tuberadius", newRadius);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::LineWidthChanged()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     int newWidth = m_Controls->m_LineWidth->value();
     int currentWidth = 0;
     m_SelectedNode->GetIntProperty("shape.linewidth", currentWidth);
     if (currentWidth==newWidth)
       return;
     m_SelectedNode->SetIntProperty("shape.linewidth", newWidth);
     dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()
       ->ShowIntro(GetSite()->GetWorkbenchWindow(), false);
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnTensorViewChanged()
 {
   if( m_NodeUsedForOdfVisualization.IsNotNull() )
   {
     if( m_Controls-> m_EllipsoidViewRadioButton-> isChecked() )
     {
       if ( m_SelectedNode and dynamic_cast<mitk::TensorImage*>( m_SelectedNode->GetData() ) )
       {
         m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( true ) );
 
         mitk::OdfNormalizationMethodProperty::Pointer normalizationProperty
             = mitk::OdfNormalizationMethodProperty::New( mitk::ODFN_MAX );
 
         m_SelectedNode-> SetProperty( "Normalization", normalizationProperty ); // type OdfNormalizationMethodProperty
 
         m_Controls-> m_NormalizationDropdown->setCurrentIndex
             ( dynamic_cast<mitk::EnumerationProperty*>( m_SelectedNode->GetProperty("Normalization") )->GetValueAsId() );
       }
       else
       {
         m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( false ) );
         m_Controls-> m_OdfViewRadioButton-> setChecked(true);
         m_Controls-> m_EllipsoidViewRadioButton-> setEnabled(false);
       }
     }
     else if( m_Controls-> m_OdfViewRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( false ) );
     }
     mitk::RenderingManager::GetInstance()-> RequestUpdateAll();
   }
   else
   {
     MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnTensorViewChanged()"
                   " was called but m_NodeUsedForOdfVisualization was Null.";
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnColourisationModeChanged()
 {
   if( m_SelectedNode and m_NodeUsedForOdfVisualization.IsNotNull() )
   {
     if( m_Controls-> m_colouriseRainbowRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( false ) );
     }
     else if ( m_Controls-> m_colouriseSimpleRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( true ) );
     }
     mitk::RenderingManager::GetInstance()-> RequestUpdateAll();
   }
   else
   {
     MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnColourisationModeChanged()"
                   " was called but m_NodeUsedForOdfVisualization was Null.";
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnRandomModeChanged()
 {
   if( m_SelectedNode and m_NodeUsedForOdfVisualization.IsNotNull() )
   {
     if( m_Controls-> m_randomModeRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( true ) );
     }
     else if ( m_Controls-> m_orderedModeRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( false ) );
     }
     mitk::RenderingManager::GetInstance()-> RequestUpdateAll();
   }
   else
   {
     MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnRandomModeChanged()"
                   " was called but m_NodeUsedForOdfVisualization was Null.";
   }
 }