diff --git a/Modules/DiffusionImaging/DiffusionCore/include/mitkDiffusionFunctionCollection.h b/Modules/DiffusionImaging/DiffusionCore/include/mitkDiffusionFunctionCollection.h
index e786b92807..d11532fc2e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/include/mitkDiffusionFunctionCollection.h
+++ b/Modules/DiffusionImaging/DiffusionCore/include/mitkDiffusionFunctionCollection.h
@@ -1,63 +1,118 @@
 /*===================================================================
 
 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 __mitkDiffusionFunctionCollection_h_
 #define __mitkDiffusionFunctionCollection_h_
 
 
 #include <MitkDiffusionCoreExports.h>
-#include "vnl/vnl_vector.h"
-#include "vnl/vnl_vector_fixed.h"
-#include "itkVectorContainer.h"
+#include <vnl/vnl_vector.h>
+#include <vnl/vnl_vector_fixed.h>
+#include <itkVectorContainer.h>
+#include <itkImage.h>
+#include <itkLinearInterpolateImageFunction.h>
+#include <mitkImage.h>
 
 namespace mitk{
 
+class imv
+{
+public:
+
+  template< class TPixelType, class TOutPixelType=TPixelType >
+  static TOutPixelType GetImageValue(const itk::Point<float, 3>& itkP, bool interpolate, typename itk::LinearInterpolateImageFunction< itk::Image< TPixelType, 3 >, float >::Pointer interpolator)
+  {
+    if (interpolator==nullptr)
+      return 0.0;
+
+    itk::ContinuousIndex< float, 3> cIdx;
+    interpolator->ConvertPointToContinuousIndex(itkP, cIdx);
+
+    if (interpolator->IsInsideBuffer(cIdx))
+    {
+      if (interpolate)
+        return interpolator->EvaluateAtContinuousIndex(cIdx);
+      else
+      {
+        itk::Index<3> idx;
+        interpolator->ConvertContinuousIndexToNearestIndex(cIdx, idx);
+        return interpolator->EvaluateAtIndex(idx);
+      }
+    }
+    else
+      return 0.0;
+  }
+
+  template< class TPixelType=unsigned char >
+  static bool IsInsideMask(const itk::Point<float, 3>& itkP, bool interpolate, typename itk::LinearInterpolateImageFunction< itk::Image< TPixelType, 3 >, float >::Pointer interpolator, float threshold=0.5)
+  {
+    if (interpolator==nullptr)
+      return false;
+
+    itk::ContinuousIndex< float, 3> cIdx;
+    interpolator->ConvertPointToContinuousIndex(itkP, cIdx);
+
+    if (interpolator->IsInsideBuffer(cIdx))
+    {
+      double value = 0.0;
+      if (interpolate)
+        value = interpolator->EvaluateAtContinuousIndex(cIdx);
+      else
+      {
+        itk::Index<3> idx;
+        interpolator->ConvertContinuousIndexToNearestIndex(cIdx, idx);
+        value = interpolator->EvaluateAtIndex(idx);
+      }
+
+      if (value>=threshold)
+        return true;
+    }
+    return false;
+  }
+
+};
+
 class MITKDIFFUSIONCORE_EXPORT sh
 {
 public:
   static double factorial(int number);
   static void Cart2Sph(double x, double y, double z, double* cart);
   static double legendre0(int l);
   static double spherical_harmonic(int m,int l,double theta,double phi, bool complexPart);
   static double Yj(int m, int k, double theta, double phi);
 };
 
 class MITKDIFFUSIONCORE_EXPORT gradients
 {
 private:
   typedef std::vector<unsigned int> IndiciesVector;
   typedef std::map<unsigned int, IndiciesVector > BValueMap;
   typedef itk::VectorContainer< unsigned int, vnl_vector_fixed< double, 3 > > GradientDirectionContainerType;
   typedef vnl_vector_fixed<double , 3 > GradientDirectionType;
 
 public:
   static std::vector<unsigned int> GetAllUniqueDirections(const BValueMap &bValueMap, GradientDirectionContainerType *refGradientsContainer );
 
   static bool CheckForDifferingShellDirections(const BValueMap &bValueMap, GradientDirectionContainerType::ConstPointer refGradientsContainer);
   static vnl_matrix<double> ComputeSphericalHarmonicsBasis(const vnl_matrix<double> & QBallReference, const unsigned int & LOrder);
   static vnl_matrix<double> ComputeSphericalFromCartesian(const IndiciesVector  & refShell, const GradientDirectionContainerType * refGradientsContainer);
   static mitk::gradients::GradientDirectionContainerType::Pointer CreateNormalizedUniqueGradientDirectionContainer(const BValueMap &bValueMap, const GradientDirectionContainerType * origninalGradentcontainer);
-
-
-  template<typename type>
-  static double dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 );
-
 };
 
 }
 
 #endif //__mitkDiffusionFunctionCollection_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp b/Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp
index 2b8e6cdf94..f0a064d50e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/src/mitkDiffusionFunctionCollection.cpp
@@ -1,253 +1,245 @@
 /*===================================================================
 
 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 "mitkDiffusionFunctionCollection.h"
 #include <math.h>
 #include "mitkNumericTypes.h"
 
 // for Windows
 #ifndef M_PI
 #define M_PI  3.14159265358979323846
 #endif
 
 // Namespace ::SH
 #include <boost/math/special_functions/legendre.hpp>
 #include <boost/math/special_functions/spherical_harmonic.hpp>
 #include <boost/version.hpp>
 
 
 // Namespace ::Gradients
 #include "itkVectorContainer.h"
 #include "vnl/vnl_vector.h"
 
 //------------------------- SH-function ------------------------------------
 
 double mitk::sh::factorial(int number) {
   if(number <= 1) return 1;
   double result = 1.0;
   for(int i=1; i<=number; i++)
     result *= i;
   return result;
 }
 
 void mitk::sh::Cart2Sph(double x, double y, double z, double *cart)
 {
   double phi, th, rad;
   rad = sqrt(x*x+y*y+z*z);
   if( rad < mitk::eps )
   {
     th = M_PI/2;
     phi = M_PI/2;
   }
   else
   {
     th = acos(z/rad);
     phi = atan2(y, x);
   }
   cart[0] = phi;
   cart[1] = th;
   cart[2] = rad;
 }
 
 double mitk::sh::legendre0(int l)
 {
   if( l%2 != 0 )
   {
     return 0;
   }
   else
   {
     double prod1 = 1.0;
     for(int i=1;i<l;i+=2) prod1 *= i;
     double prod2 = 1.0;
     for(int i=2;i<=l;i+=2) prod2 *= i;
     return pow(-1.0,l/2.0)*(prod1/prod2);
   }
 }
 
 
 double mitk::sh::Yj(int m, int l, double theta, double phi)
 {
   if (m<0)
     return sqrt(2.0)*::boost::math::spherical_harmonic_r(l, -m, theta, phi);
   else if (m==0)
     return ::boost::math::spherical_harmonic_r(l, m, theta, phi);
   else
     return pow(-1.0,m)*sqrt(2.0)*::boost::math::spherical_harmonic_i(l, m, theta, phi);
 
   return 0;
 }
 
 
 
 //------------------------- gradients-function ------------------------------------
 
 std::vector<unsigned int> mitk::gradients::GetAllUniqueDirections(const BValueMap & refBValueMap, GradientDirectionContainerType *refGradientsContainer )
 {
 
   IndiciesVector directioncontainer;
   auto mapIterator = refBValueMap.begin();
 
   if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
     mapIterator++; //skip bzero Values
 
   for( ; mapIterator != refBValueMap.end(); mapIterator++){
 
     IndiciesVector currentShell = mapIterator->second;
 
     while(currentShell.size()>0)
     {
       unsigned int wntIndex = currentShell.back();
       currentShell.pop_back();
 
       auto containerIt = directioncontainer.begin();
       bool directionExist = false;
       while(containerIt != directioncontainer.end())
       {
-        if (fabs(dot(refGradientsContainer->ElementAt(*containerIt), refGradientsContainer->ElementAt(wntIndex)))  > 0.9998)
+        if (fabs(dot_product(refGradientsContainer->ElementAt(*containerIt), refGradientsContainer->ElementAt(wntIndex)))  > 0.9998)
         {
           directionExist = true;
           break;
         }
         containerIt++;
       }
       if(!directionExist)
       {
         directioncontainer.push_back(wntIndex);
       }
     }
   }
 
   return directioncontainer;
 }
 
 
 bool mitk::gradients::CheckForDifferingShellDirections(const BValueMap & refBValueMap, GradientDirectionContainerType::ConstPointer refGradientsContainer)
 {
   auto mapIterator = refBValueMap.begin();
 
   if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
     mapIterator++; //skip bzero Values
 
   for( ; mapIterator != refBValueMap.end(); mapIterator++){
 
     auto mapIterator_2 = refBValueMap.begin();
     if(refBValueMap.find(0) != refBValueMap.end() && refBValueMap.size() > 1)
       mapIterator_2++; //skip bzero Values
 
     for( ; mapIterator_2 != refBValueMap.end(); mapIterator_2++){
 
       if(mapIterator_2 == mapIterator) continue;
 
       IndiciesVector currentShell = mapIterator->second;
       IndiciesVector testShell = mapIterator_2->second;
       for (unsigned int i = 0; i< currentShell.size(); i++)
-        if (fabs(dot(refGradientsContainer->ElementAt(currentShell[i]), refGradientsContainer->ElementAt(testShell[i])))  <= 0.9998) { return true; }
+        if (fabs(dot_product(refGradientsContainer->ElementAt(currentShell[i]), refGradientsContainer->ElementAt(testShell[i])))  <= 0.9998) { return true; }
 
     }
   }
   return false;
 }
 
-
-template<typename type>
-double mitk::gradients::dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )
-{
-  double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());
-  return result ;
-}
-
 vnl_matrix<double> mitk::gradients::ComputeSphericalFromCartesian(const IndiciesVector & refShell, const GradientDirectionContainerType * refGradientsContainer)
 {
 
   vnl_matrix<double> Q(3, refShell.size());
   Q.fill(0.0);
 
   for(unsigned int i = 0; i < refShell.size(); i++)
   {
     GradientDirectionType dir = refGradientsContainer->ElementAt(refShell[i]);
     double x = dir.normalize().get(0);
     double y = dir.normalize().get(1);
     double z = dir.normalize().get(2);
     double cart[3];
     mitk::sh::Cart2Sph(x,y,z,cart);
     Q(0,i) = cart[0];
     Q(1,i) = cart[1];
     Q(2,i) = cart[2];
   }
   return Q;
 }
 
 vnl_matrix<double> mitk::gradients::ComputeSphericalHarmonicsBasis(const vnl_matrix<double> & QBallReference, const unsigned int & LOrder)
 {
   vnl_matrix<double> SHBasisOutput(QBallReference.cols(), (LOrder+1)*(LOrder+2)*0.5);
   SHBasisOutput.fill(0.0);
   for(int i=0; i< (int)SHBasisOutput.rows(); i++)
     for(int k = 0; k <= (int)LOrder; k += 2)
       for(int m =- k; m <= k; m++)
       {
         int j = ( k * k + k + 2 ) / 2.0 + m - 1;
         double phi = QBallReference(0,i);
         double th = QBallReference(1,i);
         double val = mitk::sh::Yj(m,k,th,phi);
         SHBasisOutput(i,j) = val;
       }
   return SHBasisOutput;
 }
 
 mitk::gradients::GradientDirectionContainerType::Pointer mitk::gradients::CreateNormalizedUniqueGradientDirectionContainer(const mitk::gradients::BValueMap & bValueMap,
     const GradientDirectionContainerType *origninalGradentcontainer)
 {
   mitk::gradients::GradientDirectionContainerType::Pointer directioncontainer = mitk::gradients::GradientDirectionContainerType::New();
   auto mapIterator = bValueMap.begin();
 
   if(bValueMap.find(0) != bValueMap.end() && bValueMap.size() > 1){
     mapIterator++; //skip bzero Values
     vnl_vector_fixed<double, 3> vec;
     vec.fill(0.0);
     directioncontainer->push_back(vec);
   }
 
   for( ; mapIterator != bValueMap.end(); mapIterator++){
 
     IndiciesVector currentShell = mapIterator->second;
 
     while(currentShell.size()>0)
     {
       unsigned int wntIndex = currentShell.back();
       currentShell.pop_back();
 
       mitk::gradients::GradientDirectionContainerType::Iterator containerIt = directioncontainer->Begin();
       bool directionExist = false;
       while(containerIt != directioncontainer->End())
       {
-        if (fabs(dot(containerIt.Value(), origninalGradentcontainer->ElementAt(wntIndex)))  > 0.9998)
+        if (fabs(dot_product(containerIt.Value(), origninalGradentcontainer->ElementAt(wntIndex)))  > 0.9998)
         {
           directionExist = true;
           break;
         }
         containerIt++;
       }
       if(!directionExist)
       {
         GradientDirectionType dir(origninalGradentcontainer->ElementAt(wntIndex));
         directioncontainer->push_back(dir.normalize());
       }
     }
   }
 
   return directioncontainer;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h
index 010510ed15..9bbf13b8c6 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h
@@ -1,59 +1,61 @@
 /*===================================================================
 
 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 _ClusteringMetric
 #define _ClusteringMetric
 
+#include <mitkDiffusionFunctionCollection.h>
+
 namespace mitk
 {
 
 /**
 * \brief Base class for fiber clustering metrics  */
 
 class ClusteringMetric
 {
 
 public:
 
   ClusteringMetric()
     : m_Scale(1.0)
   {}
   virtual ~ClusteringMetric(){}
 
   virtual float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped) = 0;
 
   float GetScale() const;
   void SetScale(float Scale);
 
 protected:
 
   float m_Scale;
 
 };
 
 float ClusteringMetric::GetScale() const
 {
   return m_Scale;
 }
 
 void ClusteringMetric::SetScale(float Scale)
 {
   m_Scale = Scale;
 }
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
index 5ff8dc27dc..3609281a1f 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
@@ -1,127 +1,131 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _ClusteringMetricScalarMap
 #define _ClusteringMetricScalarMap
 
 #include <mitkClusteringMetric.h>
 #include <itkImage.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkNumericTraits.h>
 #include <mitkTrackingDataHandler.h>
 
 namespace mitk
 {
 
 /**
 * \brief Fiber clustering metric based on the scalar image values along a tract */
 
 class ClusteringMetricScalarMap : public ClusteringMetric
 {
 
 public:
 
   typedef itk::Image<float, 3>  ItkFloatImgType;
 
   ClusteringMetricScalarMap()
-  {}
+  {
+    m_Interpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
+  }
   virtual ~ClusteringMetricScalarMap(){}
 
   float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped)
   {
     float d_direct = 0;
     float d_flipped = 0;
     float map_distance = 0;
 
     vnl_vector<float> dists_d; dists_d.set_size(s.cols());
     vnl_vector<float> dists_f; dists_f.set_size(s.cols());
 
     int inc = s.cols()/4;
     for (unsigned int i=0; i<s.cols(); i += inc)
     {
       d_direct += (s.get_column(i)-t.get_column(i)).magnitude();
       d_flipped += (s.get_column(i)-t.get_column(s.cols()-i-1)).magnitude();
     }
 
     if (d_direct>d_flipped)
     {
       flipped = true;
 
       for (unsigned int i=0; i<s.cols(); ++i)
       {
         itk::Point<float, 3> p;
         p[0] = s[0][i];
         p[1] = s[1][i];
         p[2] = s[2][i];
         vnl_vector<float> vals1 = GetImageValuesAtPoint(p);
 
         p[0] = t[0][s.cols()-i-1];
         p[1] = t[1][s.cols()-i-1];
         p[2] = t[2][s.cols()-i-1];
         vnl_vector<float> vals2 = GetImageValuesAtPoint(p);
 
         map_distance += (vals1-vals2).magnitude();
       }
     }
     else
     {
       flipped = false;
 
       for (unsigned int i=0; i<s.cols(); ++i)
       {
         itk::Point<float, 3> p;
         p[0] = s[0][i];
         p[1] = s[1][i];
         p[2] = s[2][i];
         vnl_vector<float> vals1 = GetImageValuesAtPoint(p);
 
         p[0] = t[0][i];
         p[1] = t[1][i];
         p[2] = t[2][i];
         vnl_vector<float> vals2 = GetImageValuesAtPoint(p);
 
         map_distance += (vals1-vals2).magnitude();
       }
     }
 
     return m_Scale*map_distance;
   }
 
   vnl_vector<float> GetImageValuesAtPoint(itk::Point<float, 3>& itkP)
   {
     vnl_vector<float> vals; vals.set_size(m_ScalarMaps.size());
     int c = 0;
     for (auto map : m_ScalarMaps)
     {
-      vals[c] = mitk::TrackingDataHandler::GetImageValue<float>(itkP, map, true);
+      m_Interpolator->SetInputImage(map);
+      vals[c] = mitk::imv::GetImageValue<float>(itkP, true, m_Interpolator);
       ++c;
     }
     return vals;
   }
 
   void SetImages(const std::vector<ItkFloatImgType::Pointer> &Parcellations)
   {
     m_ScalarMaps = Parcellations;
   }
 
 protected:
 
   std::vector< ItkFloatImgType::Pointer > m_ScalarMaps;
+  itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::Pointer   m_Interpolator;
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingDataHandler.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingDataHandler.h
index be789cb90d..41da218e5a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingDataHandler.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingDataHandler.h
@@ -1,401 +1,120 @@
 /*===================================================================
 
 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 _TrackingDataHandler
 #define _TrackingDataHandler
 
 #include <mitkBaseData.h>
 #include <itkPoint.h>
 #include <itkImage.h>
 #include <deque>
 #include <MitkFiberTrackingExports.h>
 #include <boost/random/discrete_distribution.hpp>
 #include <boost/random/variate_generator.hpp>
 #include <boost/random/mersenne_twister.hpp>
+#include <mitkDiffusionFunctionCollection.h>
+#include <itkLinearInterpolateImageFunction.h>
 
 namespace mitk
 {
 
 /**
 * \brief  Abstract class for tracking handler. A tracking handler deals with determining the next progression direction of a streamline fiber. There are different handlers for tensor images, peak images, ... */
 
 class MITKFIBERTRACKING_EXPORT TrackingDataHandler
 {
 
 public:
 
     enum MODE {
         DETERMINISTIC,
         PROBABILISTIC
     };
 
     TrackingDataHandler();
     virtual ~TrackingDataHandler(){}
 
     typedef itk::Statistics::MersenneTwisterRandomVariateGenerator ItkRngType;
     typedef boost::mt19937                BoostRngType;
     typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
     typedef itk::Image<short, 3>          ItkShortImgType;
     typedef itk::Image<float, 3>          ItkFloatImgType;
     typedef itk::Image<double, 3>         ItkDoubleImgType;
     typedef vnl_vector_fixed< float, 3 >  TrackingDirectionType;
 
     virtual TrackingDirectionType ProposeDirection(const itk::Point<float, 3>& pos, std::deque< TrackingDirectionType >& olddirs, itk::Index<3>& oldIndex) = 0;  ///< predicts next progression direction at the given position
 
     virtual void InitForTracking() = 0;
     virtual itk::Vector<double, 3> GetSpacing() = 0;
     virtual itk::Point<float,3> GetOrigin() = 0;
     virtual itk::Matrix<double, 3, 3> GetDirection() = 0;
     virtual itk::ImageRegion<3> GetLargestPossibleRegion() = 0;
     virtual bool WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index) = 0;
     virtual void SetMode(MODE m) = 0;
     MODE GetMode(){ return m_Mode; }
 
     void SetInterpolate( bool interpolate ){ m_Interpolate = interpolate; }
     bool GetInterpolate() const { return m_Interpolate; }
 
     void SetAngularThreshold( float a ){ m_AngularThreshold = a; }
     void SetFlipX( bool f ){ m_FlipX = f; }
     void SetFlipY( bool f ){ m_FlipY = f; }
     void SetFlipZ( bool f ){ m_FlipZ = f; }
     void SetRandom( bool random )
     {
       m_Random = random;
       if (!random)
       {
         m_Rng.seed(0);
         std::srand(0);
         m_RngItk->SetSeed(0);
       }
       else
       {
         m_Rng.seed();
         m_RngItk->SetSeed();
         std::srand(std::time(0));
       }
     }
 
     double GetRandDouble(const double & a, const double & b)
     {
       return m_RngItk->GetUniformVariate(a, b);
     }
 
-    static bool IsInsideMask(const itk::Point<float, 3> &pos, ItkUcharImgType::Pointer mask, bool interpolate)
-    {
-      if (mask.IsNull())
-        return true;
-
-      if (interpolate)
-      {
-        if ( mitk::TrackingDataHandler::GetImageValue<unsigned char, double>(pos, mask, true)<0.5)
-          return false;
-      }
-      else
-      {
-        if ( mitk::TrackingDataHandler::GetImageValue<unsigned char>(pos, mask, false)==0)
-          return false;
-      }
-
-      return true;
-    }
-
-    template< class TPixelType >
-    static TPixelType GetImageValue(const itk::Point<float, 3>& itkP, itk::Image<TPixelType, 3>* image, vnl_vector_fixed<float, 8>& interpWeights){
-      // transform physical point to index coordinates
-      itk::Index<3> idx;
-      itk::ContinuousIndex< float, 3> cIdx;
-      image->TransformPhysicalPointToIndex(itkP, idx);
-      image->TransformPhysicalPointToContinuousIndex(itkP, cIdx);
-
-      TPixelType pix = 0.0;
-      if ( image->GetLargestPossibleRegion().IsInside(idx) )
-      {
-        pix = image->GetPixel(idx);
-      }
-      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] < image->GetLargestPossibleRegion().GetSize(0)-1 &&
-          idx[1] >= 0 && idx[1] < image->GetLargestPossibleRegion().GetSize(1)-1 &&
-          idx[2] >= 0 && idx[2] < image->GetLargestPossibleRegion().GetSize(2)-1)
-      {
-        // trilinear interpolation
-        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 itk::Image<TPixelType, 3>::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];
-      }
-
-      if (pix!=pix)
-      {
-        pix = 0;
-        MITK_WARN << "nan values in image!";
-      }
-
-      return pix;
-    }
-
-    template< class TPixelType, class TOutPixelType=TPixelType >
-    static TPixelType GetImageValue(const itk::Point<float, 3>& itkP, itk::Image<TPixelType, 3>* 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);
-
-      TOutPixelType pix = 0.0;
-      if ( image->GetLargestPossibleRegion().IsInside(idx) )
-      {
-        pix = (TOutPixelType)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 itk::Image<TPixelType, 3>::IndexType tmpIdx = idx; tmpIdx[0]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[1];
-
-        tmpIdx = idx; tmpIdx[1]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[2];
-
-        tmpIdx = idx; tmpIdx[2]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[3];
-
-        tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[4];
-
-        tmpIdx = idx; tmpIdx[1]++; tmpIdx[2]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[5];
-
-        tmpIdx = idx; tmpIdx[2]++; tmpIdx[0]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[6];
-
-        tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
-        pix +=  (TOutPixelType)image->GetPixel(tmpIdx) * interpWeights[7];
-      }
-
-      if (pix!=pix)
-      {
-        pix = 0;
-        MITK_WARN << "nan values in image!";
-      }
-
-      return pix;
-    }
-
-    template< class TPixelType, int components >
-    static itk::Vector< TPixelType, components > GetImageValue(const itk::Point<float, 3>& itkP, itk::Image<itk::Vector< TPixelType, components >, 3>* 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);
-
-      itk::Vector< TPixelType, components > 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 itk::Image<itk::Vector< TPixelType, components >, 3>::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];
-      }
-
-      if (pix!=pix)
-      {
-        pix.Fill(0.0);
-        mitkThrow() << "nan values in image!";
-      }
-
-      return pix;
-    }
-
 protected:
 
     float               m_AngularThreshold;
     bool                m_Interpolate;
     bool                m_FlipX;
     bool                m_FlipY;
     bool                m_FlipZ;
     MODE                m_Mode;
     BoostRngType        m_Rng;
     ItkRngType::Pointer m_RngItk;
     bool                m_NeedsDataInit;
     bool                m_Random;
 
     void DataModified()
     {
       m_NeedsDataInit = true;
     }
 
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
index b2a16baa35..dd83b1f7db 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
@@ -1,290 +1,294 @@
 /*===================================================================
 
 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 <itkDiffusionOdfGeneralizedFaImageFilter.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)
   , m_OdfFromTensor(false)
 {
-
+  m_GfaInterpolator = itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::New();
+  m_OdfInterpolator = itk::LinearInterpolateImageFunction< itk::Image< ItkOdfImageType::PixelType, 3 >, float >::New();
 }
 
 TrackingHandlerOdf::~TrackingHandlerOdf()
 {
 }
 
 bool TrackingHandlerOdf::WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index)
 {
   m_OdfImage->TransformPhysicalPointToIndex(pos, index);
   return m_OdfImage->GetLargestPossibleRegion().IsInside(index);
 }
 
 void TrackingHandlerOdf::InitForTracking()
 {
   MITK_INFO << "Initializing ODF tracker.";
 
   if (m_NeedsDataInit)
   {
     m_OdfHemisphereIndices.clear();
     itk::OrientationDistributionFunction< float, ODF_SAMPLING_SIZE > odf;
     vnl_vector_fixed<double,3> ref; ref.fill(0); ref[0]=1;
 
     for (int i=0; i<ODF_SAMPLING_SIZE; 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::DiffusionOdfGeneralizedFaImageFilter<float,float,ODF_SAMPLING_SIZE> GfaFilterType;
       GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
       gfaFilter->SetInput(m_OdfImage);
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
       gfaFilter->Update();
       m_GfaImage = gfaFilter->GetOutput();
     }
 
     m_NeedsDataInit = false;
   }
 
+  m_GfaInterpolator->SetInputImage(m_GfaImage);
+  m_OdfInterpolator->SetInputImage(m_OdfImage);
+
   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;
 }
 
 void TrackingHandlerOdf::SetIsOdfFromTensor(bool OdfFromTensor)
 {
   m_OdfFromTensor = OdfFromTensor;
 }
 
 bool TrackingHandlerOdf::GetIsOdfFromTensor() const
 {
   return m_OdfFromTensor;
 }
 
 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);
+  float gfa = mitk::imv::GetImageValue<float>(pos, m_Interpolate, m_GfaInterpolator);
   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, ODF_SAMPLING_SIZE>(pos, m_OdfImage, m_Interpolate);
+  ItkOdfImageType::PixelType odf_values = mitk::imv::GetImageValue<ItkOdfImageType::PixelType>(pos, m_Interpolate, m_OdfInterpolator);
   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)
   {
     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/mitkTrackingHandlerOdf.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h
index 4d9fa71edb..7eaf5b0e28 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h
@@ -1,85 +1,88 @@
 /*===================================================================
 
 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 _TrackingHandlerOdf
 #define _TrackingHandlerOdf
 
 #include "mitkTrackingDataHandler.h"
 #include <mitkOdfImage.h>
 #include <mitkTensorImage.h>
 #include <itkOrientationDistributionFunction.h>
 #include <MitkFiberTrackingExports.h>
 
 namespace mitk
 {
 
 /**
 * \brief Enables streamline tracking on tensor images. Supports multi tensor tracking by adding multiple tensor images. */
 
 class MITKFIBERTRACKING_EXPORT TrackingHandlerOdf : public TrackingDataHandler
 {
 
 public:
 
   TrackingHandlerOdf();
   ~TrackingHandlerOdf();
 
   typedef TensorImage::PixelType    TensorType;
   typedef OdfImage::ItkOdfImageType ItkOdfImageType;
   typedef itk::Image< vnl_vector_fixed<float,3>, 3>  ItkPDImgType;
 
 
   void InitForTracking();     ///< calls InputDataValidForTracking() and creates feature images
   vnl_vector_fixed<float,3> ProposeDirection(const itk::Point<float, 3>& pos, std::deque< vnl_vector_fixed<float,3> >& olddirs, itk::Index<3>& oldIndex);  ///< predicts next progression direction at the given position
   bool WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index);
 
   void SetSharpenOdfs(bool doSharpen) { m_SharpenOdfs=doSharpen; }
   void SetOdfThreshold(float odfThreshold){ m_OdfThreshold = odfThreshold; }
   void SetGfaThreshold(float gfaThreshold){ m_GfaThreshold = gfaThreshold; }
   void SetOdfImage( ItkOdfImageType::Pointer img ){ m_OdfImage = img; DataModified(); }
   void SetGfaImage( ItkFloatImgType::Pointer img ){ m_GfaImage = img; DataModified(); }
   void SetMode( MODE m ){ m_Mode = m; }
 
   ItkUcharImgType::SpacingType GetSpacing(){ return m_OdfImage->GetSpacing(); }
   itk::Point<float,3> GetOrigin(){ return m_OdfImage->GetOrigin(); }
   ItkUcharImgType::DirectionType GetDirection(){ return m_OdfImage->GetDirection(); }
   ItkUcharImgType::RegionType GetLargestPossibleRegion(){ return m_OdfImage->GetLargestPossibleRegion(); }
 
   int OdfPower() const;
   void SetNumProbSamples(int NumProbSamples);
 
   bool GetIsOdfFromTensor() const;
   void SetIsOdfFromTensor(bool OdfFromTensor);
 
 protected:
 
   int SampleOdf(vnl_vector< float >& probs, vnl_vector< float >& angles);
 
   float                           m_GfaThreshold;
   float                           m_OdfThreshold;
   bool                            m_SharpenOdfs;
   ItkFloatImgType::Pointer        m_GfaImage;     ///< GFA image used to determine streamline termination.
   ItkOdfImageType::Pointer        m_OdfImage;     ///< Input odf image.
   ItkOdfImageType::Pointer        m_WorkingOdfImage;     ///< Modified odf image.
   std::vector< int >              m_OdfHemisphereIndices;
   vnl_matrix< float >             m_OdfFloatDirs;
   int                             m_NumProbSamples;
   bool                            m_OdfFromTensor;
+
+  itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::Pointer   m_GfaInterpolator;
+  itk::LinearInterpolateImageFunction< itk::Image< ItkOdfImageType::PixelType, 3 >, float >::Pointer   m_OdfInterpolator;
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp
index 0206c82f0a..c53b78eec2 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.cpp
@@ -1,939 +1,899 @@
 /*===================================================================
 
 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 >
 bool TrackingHandlerRandomForest< ShOrder, NumberOfSignalFeatures >::WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index)
 {
   m_DwiFeatureImages.at(0)->TransformPhysicalPointToIndex(pos, index);
   return m_DwiFeatureImages.at(0)->GetLargestPossibleRegion().IsInside(index);
 }
 
-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));
+
+    // initialize interpolators
+    m_DwiFeatureImageInterpolator = DwiFeatureImageInterpolatorType::New();
+    m_DwiFeatureImageInterpolator->SetInputImage(m_DwiFeatureImages.at(0));
+
+    m_AdditionalFeatureImageInterpolators.clear();
+    for (auto afi_vec : m_AdditionalFeatureImages)
+    {
+      std::vector< FloatImageInterpolatorType::Pointer > v;
+      for (auto img : afi_vec)
+      {
+        FloatImageInterpolatorType::Pointer interp = FloatImageInterpolatorType::New();
+        interp->SetInputImage(img);
+        v.push_back(interp);
+      }
+      m_AdditionalFeatureImageInterpolators.push_back(v);
+    }
+
     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);
+  typename DwiFeatureImageType::PixelType dwiFeaturePixel = mitk::imv::GetImageValue< typename DwiFeatureImageType::PixelType >(pos, m_Interpolate, m_DwiFeatureImageInterpolator);
   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))
+    for (auto interpolator : m_AdditionalFeatureImageInterpolators.at(0))
     {
-      float v = GetImageValue<float>(pos, img, false);
+      float v = mitk::imv::GetImageValue<float>(pos, false, interpolator);
       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)
         {
           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?
           {
             if (abs_angle>=m_AngularThreshold)         // is angle between the directions smaller than our hard threshold?
             {
               if (angle<0)                          // make sure we don't walk backwards
                 d *= -1;
               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)
   {
     boost::random::discrete_distribution<int, float> dist(probs2.begin(), probs2.end());
     int sampled_idx = 0;
 
     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);
     }
   }
 
+  // initialize interpolators
+  m_AdditionalFeatureImageInterpolators.clear();
+  for (auto afi_vec : m_AdditionalFeatureImages)
+  {
+    std::vector< FloatImageInterpolatorType::Pointer > v;
+    for (auto img : afi_vec)
+    {
+      FloatImageInterpolatorType::Pointer interp = FloatImageInterpolatorType::New();
+      interp->SetInputImage(img);
+      v.push_back(interp);
+    }
+    m_AdditionalFeatureImageInterpolators.push_back(v);
+  }
+
   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);
+    FloatImageInterpolatorType::Pointer volume_interpolator = FloatImageInterpolatorType::New();
+    volume_interpolator->SetInputImage(fiber_folume);
     typename DwiFeatureImageType::Pointer image = m_DwiFeatureImages.at(t);
+    typename DwiFeatureImageInterpolatorType::Pointer dwi_interp = DwiFeatureImageInterpolatorType::New();
+    dwi_interp->SetInputImage(image);
+
     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))
+          for (auto interpolator : m_AdditionalFeatureImageInterpolators.at(t))
           {
             itk::Point<float, 3> itkP;
             image->TransformIndexToPhysicalPoint(it.GetIndex(), itkP);
-            float v = GetImageValue<float>(itkP, img, false);
+            float v = mitk::imv::GetImageValue<float>(itkP, false, interpolator);
             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);
+            float volume_mod = mitk::imv::GetImageValue<float>(itkP1, false, volume_interpolator);
 
             // diffusion signal features
-            typename DwiFeatureImageType::PixelType pix = GetDwiFeaturesAtPosition(itkP1, image, m_Interpolate);
+            typename DwiFeatureImageType::PixelType pix = mitk::imv::GetImageValue< typename DwiFeatureImageType::PixelType >(itkP1, m_Interpolate, dwi_interp);
             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))
+            for (auto interpolator : m_AdditionalFeatureImageInterpolators.at(t))
             {
-              float v = GetImageValue<float>(itkP1, img, false);
+              float v = mitk::imv::GetImageValue<float>(itkP1, false, interpolator);
               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/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h
index 8595555f5c..8c773e71ab 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h
@@ -1,162 +1,166 @@
 /*===================================================================
 
 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
 #define _TrackingForestHandler
 
 #include <mitkTrackingDataHandler.h>
 
 #include <mitkFiberBundle.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 #include <itkOrientationDistributionFunction.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 #include <itkOrientationDistributionFunction.h>
 #include <chrono>
 
 #include <mitkTractographyForest.h>
 
 #undef DIFFERENCE
 #define VIGRA_STATIC_LIB
 #include <vigra/random_forest.hxx>
 #include <vigra/multi_array.hxx>
 #include <vigra/random_forest_hdf5_impex.hxx>
 #include <mitkLinearSplitting.h>
 #include <mitkThresholdSplit.h>
 #include <mitkImpurityLoss.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace mitk
 {
 
 /**
 * \brief  Manages random forests for fiber tractography. The preparation of the features from the inputa data and the training process are handled here. The data preprocessing and actual prediction for the tracking process is also performed here. The tracking itself is performed in MLBSTrackingFilter. */
 
 template< int ShOrder, int NumberOfSignalFeatures >
 class TrackingHandlerRandomForest : public TrackingDataHandler
 {
 
 public:
 
+
   TrackingHandlerRandomForest();
   ~TrackingHandlerRandomForest();
 
   typedef itk::Image< itk::Vector< float, NumberOfSignalFeatures > , 3 >      DwiFeatureImageType;
+  typedef itk::LinearInterpolateImageFunction< DwiFeatureImageType, float >   DwiFeatureImageInterpolatorType;
+  typedef itk::LinearInterpolateImageFunction< ItkFloatImgType, float >       FloatImageInterpolatorType;
 
   typedef mitk::ThresholdSplit<mitk::LinearSplitting< mitk::ImpurityLoss<> >,int,vigra::ClassificationTag> DefaultSplitType;
 
   void SetDwis( std::vector< Image::Pointer > images ){ m_InputDwis = images; DataModified(); }
   void AddDwi( Image::Pointer img ){ m_InputDwis.push_back(img); DataModified(); }
   void SetTractograms( std::vector< FiberBundle::Pointer > tractograms )
   {
     m_Tractograms.clear();
     for (auto fib : tractograms)
       m_Tractograms.push_back(fib);
     DataModified();
   }
   void SetMaskImages( std::vector< ItkUcharImgType::Pointer > images ){ m_MaskImages = images; DataModified(); }
   void SetWhiteMatterImages( std::vector< ItkUcharImgType::Pointer > images ){ m_WhiteMatterImages = images; DataModified(); }
   void SetFiberVolumeModImages( std::vector< ItkFloatImgType::Pointer > images ){ m_FiberVolumeModImages = images; DataModified(); }
   void SetAdditionalFeatureImages( std::vector< std::vector< ItkFloatImgType::Pointer > > images ){ m_AdditionalFeatureImages = images; DataModified(); }
 
   void StartTraining();
 
   void SetMode( MODE m ){ m_Mode = m; }
   void SetForest(mitk::TractographyForest::Pointer forest){ m_Forest = forest; }
   void SetMaxNumWmSamples(int num){ m_MaxNumWmSamples=num; }
   void SetNumPreviousDirections( int num ){ m_NumPreviousDirections=num; }
   void SetNumTrees(int num){ m_NumTrees = num; }
   void SetMaxTreeDepth(int depth){ m_MaxTreeDepth = depth; }
   void SetFiberSamplingStep(float step){ m_WmSampleDistance = step; }
   void SetGrayMatterSamplesPerVoxel(int samples){ m_GmSamplesPerVoxel = samples; }
   void SetSampleFraction(float fraction){ m_SampleFraction = fraction; }
   void SetBidirectionalFiberSampling(bool val) { m_BidirectionalFiberSampling = val; }
   void SetZeroDirWmFeatures(bool val) { m_ZeroDirWmFeatures = val; }
 
   void InitForTracking();     ///< calls InputDataValidForTracking() and creates feature images
   vnl_vector_fixed<float,3> ProposeDirection(const itk::Point<float, 3>& pos, std::deque< vnl_vector_fixed<float,3> >& olddirs, itk::Index<3>& oldIndex);  ///< predicts next progression direction at the given position
   bool WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index);
 
   bool IsForestValid();   ///< true is forest is not null, has more than 0 trees and the correct number of features (NumberOfSignalFeatures + 3)
 
   mitk::TractographyForest::Pointer GetForest(){ return m_Forest; }
 
   ItkUcharImgType::SpacingType GetSpacing(){ return m_DwiFeatureImages.at(0)->GetSpacing(); }
   itk::Point<float,3> GetOrigin(){ return m_DwiFeatureImages.at(0)->GetOrigin(); }
   ItkUcharImgType::DirectionType GetDirection(){ return m_DwiFeatureImages.at(0)->GetDirection(); }
   ItkUcharImgType::RegionType GetLargestPossibleRegion(){ return m_DwiFeatureImages.at(0)->GetLargestPossibleRegion(); }
 
 protected:
 
   void InputDataValidForTracking();                                                   ///< check if raw data is set and tracking forest is valid
 
   template<typename T=bool>
   typename std::enable_if<NumberOfSignalFeatures <= 99, T>::type InitDwiImageFeatures(mitk::Image::Pointer mitk_dwi);
 
   template<typename T=bool>
   typename std::enable_if<NumberOfSignalFeatures >= 100, T>::type InitDwiImageFeatures(mitk::Image::Pointer mitk_dwi);
 
   void InputDataValidForTraining();       ///< Check if everything is tehere for training (raw datasets, fiber tracts)
   void InitForTraining();  ///< Generate masks if necessary, resample fibers, spherically interpolate raw DWIs
   void CalculateTrainingSamples();    ///< Calculate GM and WM features using the interpolated raw data, the WM masks and the fibers
-  typename DwiFeatureImageType::PixelType GetDwiFeaturesAtPosition(itk::Point<float, 3> itkP, typename DwiFeatureImageType::Pointer image, bool interpolate);   ///< get trilinearly interpolated raw image values at given world position
-
 
   std::vector< Image::Pointer >                               m_InputDwis;                ///< original input DWI data
   mitk::TractographyForest::Pointer                           m_Forest;                   ///< random forest classifier
   std::chrono::time_point<std::chrono::system_clock>          m_StartTime;
   std::chrono::time_point<std::chrono::system_clock>          m_EndTime;
 
 
   std::vector< typename DwiFeatureImageType::Pointer >        m_DwiFeatureImages;
   std::vector< std::vector< ItkFloatImgType::Pointer > >      m_AdditionalFeatureImages;
 
   std::vector< ItkFloatImgType::Pointer >                     m_FiberVolumeModImages;     ///< used to correct the fiber density
   std::vector< FiberBundle::Pointer >                         m_Tractograms;              ///< training tractograms
   std::vector< ItkUcharImgType::Pointer >                     m_MaskImages;               ///< binary mask images to constrain training to a certain area (e.g. brain mask)
   std::vector< ItkUcharImgType::Pointer >                     m_WhiteMatterImages;        ///< defines white matter voxels. if not set, theses mask images are automatically generated from the input tractograms
 
   float                                                       m_WmSampleDistance;         ///< deterines the number of white matter samples (distance of sampling points on each fiber).
   int                                                         m_NumTrees;                 ///< number of trees in random forest
   int                                                         m_MaxTreeDepth;             ///< limits the tree depth
   float                                                       m_SampleFraction;           ///< fraction of samples used to train each tree
   unsigned int                                                m_NumberOfSamples;          ///< stores overall number of samples used for training
   std::vector< unsigned int >                                 m_GmSamples;                ///< number of gray matter samples
   int                                                         m_GmSamplesPerVoxel;        ///< number of gray matter samplees per voxel. if -1, then the number is automatically chosen to gain an overall number of GM samples close to the number of WM samples.
   vigra::MultiArray<2, float>                                 m_FeatureData;              ///< vigra container for training features
   unsigned int                                                m_NumPreviousDirections;        ///< How many "old" directions should be used as classification features?
 
   // only for tracking
   vigra::MultiArray<2, float>                                 m_LabelData;                    ///< vigra container for training labels
   vigra::MultiArray<2, double>                                m_Weights;                      ///< vigra container for training sample weights
   std::vector< vnl_vector_fixed<float,3> >                    m_DirectionContainer;
   vnl_matrix< float >                                         m_OdfFloatDirs;
 
   bool                                                        m_BidirectionalFiberSampling;
   bool                                                        m_ZeroDirWmFeatures;
   int                                                         m_MaxNumWmSamples;
   std::vector< std::vector< bool > >                          m_SampleUsage;
 
   vnl_matrix_fixed<float,3,3>                                 m_ImageDirection;
   vnl_matrix_fixed<float,3,3>                                 m_ImageDirectionInverse;
+
+  typename DwiFeatureImageInterpolatorType::Pointer           m_DwiFeatureImageInterpolator;
+  std::vector< std::vector< FloatImageInterpolatorType::Pointer > >   m_AdditionalFeatureImageInterpolators;
 };
 
 }
 
 #include "mitkTrackingHandlerRandomForest.cpp"
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp
index 148ca0dabf..e0b380be56 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp
@@ -1,367 +1,369 @@
 /*===================================================================
 
 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 "mitkTrackingHandlerTensor.h"
 
 namespace mitk
 {
 
 TrackingHandlerTensor::TrackingHandlerTensor()
   : m_FaThreshold(0.1)
   , m_F(1.0)
   , m_G(0.0)
   , m_InterpolateTensors(true)
   , m_NumberOfInputs(0)
 {
-
+  m_FaInterpolator = itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::New();
 }
 
 TrackingHandlerTensor::~TrackingHandlerTensor()
 {
 }
 
 void TrackingHandlerTensor::InitForTracking()
 {
   MITK_INFO << "Initializing tensor tracker.";
 
   if (m_NeedsDataInit)
   {
     m_NumberOfInputs = m_TensorImages.size();
     for (int i=0; i<m_NumberOfInputs; i++)
     {
       ItkPDImgType::Pointer pdImage = ItkPDImgType::New();
       pdImage->SetSpacing( m_TensorImages.at(0)->GetSpacing() );
       pdImage->SetOrigin( m_TensorImages.at(0)->GetOrigin() );
       pdImage->SetDirection( m_TensorImages.at(0)->GetDirection() );
       pdImage->SetRegions( m_TensorImages.at(0)->GetLargestPossibleRegion() );
       pdImage->Allocate();
       m_PdImage.push_back(pdImage);
 
       ItkDoubleImgType::Pointer emaxImage = ItkDoubleImgType::New();
       emaxImage->SetSpacing( m_TensorImages.at(0)->GetSpacing() );
       emaxImage->SetOrigin( m_TensorImages.at(0)->GetOrigin() );
       emaxImage->SetDirection( m_TensorImages.at(0)->GetDirection() );
       emaxImage->SetRegions( m_TensorImages.at(0)->GetLargestPossibleRegion() );
       emaxImage->Allocate();
       emaxImage->FillBuffer(1.0);
       m_EmaxImage.push_back(emaxImage);
     }
 
     bool useUserFaImage = true;
     if (m_FaImage.IsNull())
     {
       m_FaImage = ItkFloatImgType::New();
       m_FaImage->SetSpacing( m_TensorImages.at(0)->GetSpacing() );
       m_FaImage->SetOrigin( m_TensorImages.at(0)->GetOrigin() );
       m_FaImage->SetDirection( m_TensorImages.at(0)->GetDirection() );
       m_FaImage->SetRegions( m_TensorImages.at(0)->GetLargestPossibleRegion() );
       m_FaImage->Allocate();
       m_FaImage->FillBuffer(0.0);
       useUserFaImage = false;
     }
 
     typedef itk::DiffusionTensor3D<float>    TensorType;
 
     for (int x=0; x<(int)m_TensorImages.at(0)->GetLargestPossibleRegion().GetSize()[0]; x++)
       for (int y=0; y<(int)m_TensorImages.at(0)->GetLargestPossibleRegion().GetSize()[1]; y++)
         for (int z=0; z<(int)m_TensorImages.at(0)->GetLargestPossibleRegion().GetSize()[2]; z++)
         {
           ItkTensorImageType::IndexType index;
           index[0] = x; index[1] = y; index[2] = z;
           for (int i=0; i<m_NumberOfInputs; i++)
           {
             TensorType::EigenValuesArrayType eigenvalues;
             TensorType::EigenVectorsMatrixType eigenvectors;
 
             ItkTensorImageType::PixelType tensor;
             vnl_vector_fixed<float,3> dir;
             tensor = m_TensorImages.at(i)->GetPixel(index);
             tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
 
             dir[0] = eigenvectors(2, 0);
             dir[1] = eigenvectors(2, 1);
             dir[2] = eigenvectors(2, 2);
             if (dir.magnitude()>mitk::eps)
               dir.normalize();
             else
               dir.fill(0.0);
 
             m_PdImage.at(i)->SetPixel(index, dir);
             if (!useUserFaImage)
               m_FaImage->SetPixel(index, m_FaImage->GetPixel(index)+tensor.GetFractionalAnisotropy());
             m_EmaxImage.at(i)->SetPixel(index, 2/eigenvalues[2]);
           }
           if (!useUserFaImage)
             m_FaImage->SetPixel(index, m_FaImage->GetPixel(index)/m_NumberOfInputs);
         }
 
     m_NeedsDataInit = false;
   }
 
 
   if (m_F+m_G>1.0)
   {
     float temp = m_F+m_G;
     m_F /= temp;
     m_G /= temp;
   }
 
+  m_FaInterpolator->SetInputImage(m_FaImage);
+
   std::cout << "TrackingHandlerTensor - FA threshold: " << m_FaThreshold << std::endl;
   std::cout << "TrackingHandlerTensor - f: " << m_F << std::endl;
   std::cout << "TrackingHandlerTensor - g: " << m_G << std::endl;
 }
 
 vnl_vector_fixed<float,3> TrackingHandlerTensor::GetMatchingDirection(itk::Index<3> idx, vnl_vector_fixed<float,3>& oldDir, int& image_num)
 {
   vnl_vector_fixed<float,3> out_dir; out_dir.fill(0);
   float angle = 0;
   float mag = oldDir.magnitude();
   if (mag<mitk::eps)
   {
     for (unsigned int i=0; i<m_PdImage.size(); i++)
     {
       out_dir = m_PdImage.at(i)->GetPixel(idx);
 
       if (out_dir.magnitude()>0.5)
       {
         image_num = i;
         oldDir[0] = out_dir[0];
         oldDir[1] = out_dir[1];
         oldDir[2] = out_dir[2];
         break;
       }
     }
   }
   else
   {
     for (unsigned int i=0; i<m_PdImage.size(); i++)
     {
       vnl_vector_fixed<float,3> dir = m_PdImage.at(i)->GetPixel(idx);
 
       float a = dot_product(dir, oldDir);
       if (fabs(a)>angle)
       {
         image_num = i;
         angle = fabs(a);
         if (a<0)
           out_dir = -dir;
         else
           out_dir = dir;
         out_dir *= angle; // shrink contribution of direction if is less parallel to previous direction
       }
     }
   }
 
   return out_dir;
 }
 
 bool TrackingHandlerTensor::WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index)
 {
   m_TensorImages.at(0)->TransformPhysicalPointToIndex(pos, index);
   return m_TensorImages.at(0)->GetLargestPossibleRegion().IsInside(index);
 }
 
 vnl_vector_fixed<float,3> TrackingHandlerTensor::GetDirection(itk::Point<float, 3> itkP, vnl_vector_fixed<float,3> oldDir, TensorType& tensor)
 {
   // transform physical point to index coordinates
   itk::Index<3> idx;
   itk::ContinuousIndex< float, 3> cIdx;
   m_FaImage->TransformPhysicalPointToIndex(itkP, idx);
   m_FaImage->TransformPhysicalPointToContinuousIndex(itkP, cIdx);
 
   vnl_vector_fixed<float,3> dir; dir.fill(0.0);
   if ( !m_FaImage->GetLargestPossibleRegion().IsInside(idx) )
     return dir;
 
   int image_num = -1;
   if (!m_Interpolate)
   {
     dir = GetMatchingDirection(idx, oldDir, image_num);
     if (image_num>=0)
       tensor = m_TensorImages[image_num]->GetPixel(idx) * m_EmaxImage[image_num]->GetPixel(idx);
   }
   else
   {
     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>(m_FaImage->GetLargestPossibleRegion().GetSize(0) - 1) &&
         idx[1] >= 0 && idx[1] < static_cast<itk::IndexValueType>(m_FaImage->GetLargestPossibleRegion().GetSize(1) - 1) &&
         idx[2] >= 0 && idx[2] < static_cast<itk::IndexValueType>(m_FaImage->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);
 
       dir = GetMatchingDirection(idx, oldDir, image_num) * interpWeights[0];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(idx) * m_EmaxImage[image_num]->GetPixel(idx) * interpWeights[0];
 
       itk::Index<3> tmpIdx = idx; tmpIdx[0]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[1];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[1];
 
       tmpIdx = idx; tmpIdx[1]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[2];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[2];
 
       tmpIdx = idx; tmpIdx[2]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[3];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[3];
 
       tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[4];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[4];
 
       tmpIdx = idx; tmpIdx[1]++; tmpIdx[2]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[5];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[5];
 
       tmpIdx = idx; tmpIdx[2]++; tmpIdx[0]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[6];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[6];
 
       tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
       dir +=  GetMatchingDirection(tmpIdx, oldDir, image_num) * interpWeights[7];
       if (image_num>=0)
         tensor += m_TensorImages[image_num]->GetPixel(tmpIdx) * m_EmaxImage[image_num]->GetPixel(tmpIdx) * interpWeights[7];
     }
   }
 
   return dir;
 }
 
 vnl_vector_fixed<float,3> TrackingHandlerTensor::GetLargestEigenvector(TensorType& tensor)
 {
   vnl_vector_fixed<float,3> dir;
   TensorType::EigenValuesArrayType eigenvalues;
   TensorType::EigenVectorsMatrixType eigenvectors;
   tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
   dir[0] = eigenvectors(2, 0);
   dir[1] = eigenvectors(2, 1);
   dir[2] = eigenvectors(2, 2);
   if (dir.magnitude()<mitk::eps)
     dir.fill(0.0);
 
   return dir;
 }
 
 vnl_vector_fixed<float,3> TrackingHandlerTensor::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);
   TensorType tensor; tensor.Fill(0);
 
   try
   {
     itk::Index<3> index;
     m_TensorImages.at(0)->TransformPhysicalPointToIndex(pos, index);
 
-    float fa = GetImageValue<float>(pos, m_FaImage, m_Interpolate);
+    float fa = mitk::imv::GetImageValue<float>(pos, m_Interpolate, m_FaInterpolator);
     if (fa<m_FaThreshold)
       return output_direction;
 
     vnl_vector_fixed<float,3> oldDir = olddirs.back();
 
     if (m_FlipX)
       oldDir[0] *= -1;
     if (m_FlipY)
       oldDir[1] *= -1;
     if (m_FlipZ)
       oldDir[2] *= -1;
 
     float old_mag = oldDir.magnitude();
 
     if (!m_Interpolate && oldIndex==index)
       return oldDir;
 
     output_direction = GetDirection(pos, oldDir, tensor);
     float mag = output_direction.magnitude();
 
     if (mag>=mitk::eps)
     {
       output_direction.normalize();
 
       if (old_mag>0.5 && m_G>mitk::eps)  // TEND tracking
       {
 
         output_direction[0] = m_F*output_direction[0] + (1-m_F)*( (1-m_G)*oldDir[0] + m_G*(tensor[0]*oldDir[0] + tensor[1]*oldDir[1] + tensor[2]*oldDir[2]));
         output_direction[1] = m_F*output_direction[1] + (1-m_F)*( (1-m_G)*oldDir[1] + m_G*(tensor[1]*oldDir[0] + tensor[3]*oldDir[1] + tensor[4]*oldDir[2]));
         output_direction[2] = m_F*output_direction[2] + (1-m_F)*( (1-m_G)*oldDir[2] + m_G*(tensor[2]*oldDir[0] + tensor[4]*oldDir[1] + tensor[5]*oldDir[2]));
         output_direction.normalize();
       }
 
       float a = 1;
       if (old_mag>0.5)
         a = dot_product(output_direction, oldDir);
       if (a>=m_AngularThreshold)
         output_direction *= mag;
       else
         output_direction.fill(0);
     }
     else
       output_direction.fill(0);
 
   }
   catch(...)
   {
 
   }
 
   if (m_FlipX)
     output_direction[0] *= -1;
   if (m_FlipY)
     output_direction[1] *= -1;
   if (m_FlipZ)
     output_direction[2] *= -1;
 
   return output_direction;
 }
 
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h
index beac1606ae..094e1e4ff1 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h
@@ -1,91 +1,94 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _TrackingHandlerTensor
 #define _TrackingHandlerTensor
 
 #include "mitkTrackingDataHandler.h"
 #include <itkDiffusionTensor3D.h>
 #include <MitkFiberTrackingExports.h>
 #include <mitkTensorImage.h>
+#include <itkLinearInterpolateImageFunction.h>
 
 namespace mitk
 {
 
 /**
 * \brief Enables streamline tracking on tensor images. Supports multi tensor tracking by adding multiple tensor images. */
 
 class MITKFIBERTRACKING_EXPORT TrackingHandlerTensor : public TrackingDataHandler
 {
 
 public:
 
   TrackingHandlerTensor();
   ~TrackingHandlerTensor();
 
   typedef TensorImage::PixelType    TensorType;
   typedef TensorImage::ItkTensorImageType ItkTensorImageType;
   typedef itk::Image< vnl_vector_fixed<float,3>, 3>  ItkPDImgType;
 
 
   void InitForTracking();     ///< calls InputDataValidForTracking() and creates feature images
   vnl_vector_fixed<float,3> ProposeDirection(const itk::Point<float, 3>& pos, std::deque< vnl_vector_fixed<float,3> >& olddirs, itk::Index<3>& oldIndex);  ///< predicts next progression direction at the given position
   bool WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index);
 
   void SetF(float f){ m_F = f; }
   void SetG(float g){ m_G = g; }
   void SetFaThreshold(float FaThreshold){ m_FaThreshold = FaThreshold; }
   void AddTensorImage( ItkTensorImageType::ConstPointer img ){ m_TensorImages.push_back(img); DataModified(); }
   void SetTensorImage( ItkTensorImageType::ConstPointer img ){ m_TensorImages.clear(); m_TensorImages.push_back(img); DataModified(); }
   void ClearTensorImages(){ m_TensorImages.clear(); DataModified(); }
   void SetFaImage( ItkFloatImgType::Pointer img ){ m_FaImage = img; DataModified(); }
   void SetInterpolateTensors( bool interpolateTensors ){ m_InterpolateTensors = interpolateTensors; }
   void SetMode( MODE m )
   {
     if (m==MODE::DETERMINISTIC)
       m_Mode = m;
     else
       mitkThrow() << "Tensor tracker is only implemented for deterministic mode.";
   }
   int GetNumTensorImages() const { return m_TensorImages.size(); }
 
 
   ItkUcharImgType::SpacingType GetSpacing(){ return m_FaImage->GetSpacing(); }
   itk::Point<float,3> GetOrigin(){ return m_FaImage->GetOrigin(); }
   ItkUcharImgType::DirectionType GetDirection(){ return m_FaImage->GetDirection(); }
   ItkUcharImgType::RegionType GetLargestPossibleRegion(){ return m_FaImage->GetLargestPossibleRegion(); }
 
 protected:
 
   vnl_vector_fixed<float,3> GetMatchingDirection(itk::Index<3> idx, vnl_vector_fixed<float,3>& oldDir, int& image_num);
   vnl_vector_fixed<float,3> GetDirection(itk::Point<float, 3> itkP, vnl_vector_fixed<float,3> oldDir, TensorType& tensor);
   vnl_vector_fixed<float,3> GetLargestEigenvector(TensorType& tensor);
 
   float   m_FaThreshold;
   float   m_F;
   float   m_G;
 
   std::vector< ItkDoubleImgType::Pointer >        m_EmaxImage;    ///< Stores largest eigenvalues per voxel (one for each tensor)
   ItkFloatImgType::Pointer                        m_FaImage;      ///< FA image used to determine streamline termination.
   std::vector< ItkPDImgType::Pointer >            m_PdImage;      ///< Stores principal direction of each tensor in each voxel.
   std::vector< ItkTensorImageType::ConstPointer > m_TensorImages;   ///< Input tensor images. For multi tensor tracking provide multiple tensor images.
   bool                                            m_InterpolateTensors;   ///< If false, then the peaks are interpolated. Otherwiese, The tensors are interpolated.
   int                                             m_NumberOfInputs;
+
+  itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::Pointer   m_FaInterpolator;
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp
new file mode 100644
index 0000000000..85284a11f0
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp
@@ -0,0 +1,268 @@
+/*===================================================================
+
+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 __itkFiberExtractionFilter_cpp
+#define __itkFiberExtractionFilter_cpp
+
+#include "itkFiberExtractionFilter.h"
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <boost/progress.hpp>
+#include <mitkDiffusionFunctionCollection.h>
+
+namespace itk{
+
+
+template< class PixelType >
+FiberExtractionFilter< PixelType >::FiberExtractionFilter()
+  : m_DontResampleFibers(false)
+  , m_Mode(MODE::OVERLAP)
+  , m_InputType(INPUT::SCALAR_MAP)
+  , m_BothEnds(true)
+  , m_OverlapFraction(0.8)
+  , m_NoNegatives(false)
+  , m_NoPositives(false)
+  , m_Interpolate(false)
+  , m_Threshold(0.5)
+  , m_Labels({1})
+{
+  m_Interpolator = itk::LinearInterpolateImageFunction< itk::Image< PixelType, 3 >, float >::New();
+}
+
+template< class PixelType >
+FiberExtractionFilter< PixelType >::~FiberExtractionFilter()
+{
+
+}
+
+template< class PixelType >
+void FiberExtractionFilter< PixelType >::SetRoiImages(const std::vector<ItkInputImgType*> &rois)
+{
+  for (auto roi : rois)
+  {
+    if (roi==nullptr)
+    {
+      MITK_INFO << "ROI image is NULL!";
+      return;
+    }
+  }
+  m_RoiImages = rois;
+}
+
+template< class PixelType >
+mitk::FiberBundle::Pointer FiberExtractionFilter< PixelType >::CreateFib(std::vector< long >& ids)
+{
+  vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
+  vtkSmartPointer<vtkPolyData> pTmp = m_InputFiberBundle->GeneratePolyDataByIds(ids, weights);
+  mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
+  fib->SetFiberWeights(weights);
+  return fib;
+}
+
+template< class PixelType >
+bool FiberExtractionFilter< PixelType >::IsPositive(const itk::Point<float, 3>& itkP, itk::Image<PixelType, 3>* image)
+{
+  m_Interpolator->SetInputImage(image);
+  if( m_InputType == INPUT::SCALAR_MAP )
+    return mitk::imv::IsInsideMask<PixelType>(itkP, m_Interpolate, m_Interpolator, m_Threshold);
+  else if( m_InputType == INPUT::LABEL_MAP )
+  {
+    auto val = mitk::imv::GetImageValue<PixelType>(itkP, m_Interpolate, m_Interpolator);
+    for (auto l : m_Labels)
+      if (l==val)
+        return true;
+  }
+  else
+    mitkThrow() << "No valid input type selected!";
+  return false;
+}
+
+template< class PixelType >
+void FiberExtractionFilter< PixelType >::ExtractOverlap(mitk::FiberBundle::Pointer fib)
+{
+  MITK_INFO << "Extracting fibers (min. overlap " << m_OverlapFraction << ")";
+  vtkSmartPointer<vtkPolyData> polydata = fib->GetFiberPolyData();
+
+  std::vector< std::vector< long > > positive_ids;
+  positive_ids.resize(m_RoiImages.size());
+
+  std::vector< long > negative_ids; // fibers not overlapping with ANY mask
+
+  boost::progress_display disp(m_InputFiberBundle->GetNumFibers());
+  for (int i=0; i<m_InputFiberBundle->GetNumFibers(); i++)
+  {
+    ++disp;
+    vtkCell* cell = polydata->GetCell(i);
+    int numPoints = cell->GetNumberOfPoints();
+    vtkPoints* points = cell->GetPoints();
+
+    bool positive = false;
+    for (unsigned int m=0; m<m_RoiImages.size(); ++m)
+    {
+      auto roi = m_RoiImages.at(m);
+      int inside = 0;
+      int outside = 0;
+      for (int j=0; j<numPoints; j++)
+      {
+        double* p = points->GetPoint(j);
+
+        itk::Point<float, 3> itkP;
+        itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
+
+        if ( IsPositive(itkP, roi) )
+          inside++;
+        else
+          outside++;
+
+        if ((float)inside/numPoints > m_OverlapFraction)
+        {
+          positive = true;
+          positive_ids[m].push_back(i);
+          break;
+        }
+      }
+    }
+    if (!positive)
+      negative_ids.push_back(i);
+  }
+
+  if (!m_NoNegatives)
+    m_Negatives.push_back(CreateFib(negative_ids));
+  if (!m_NoPositives)
+    for (auto ids : positive_ids)
+      m_Positives.push_back(CreateFib(ids));
+}
+
+template< class PixelType >
+void FiberExtractionFilter< PixelType >::ExtractEndpoints(mitk::FiberBundle::Pointer fib)
+{
+  MITK_INFO << "Extracting fibers (endpoints in mask)";
+  vtkSmartPointer<vtkPolyData> polydata = fib->GetFiberPolyData();
+
+  std::vector< std::vector< long > > positive_ids;
+  positive_ids.resize(m_RoiImages.size());
+
+  std::vector< long > negative_ids; // fibers not overlapping with ANY mask
+
+  boost::progress_display disp(m_InputFiberBundle->GetNumFibers());
+  for (int i=0; i<m_InputFiberBundle->GetNumFibers(); i++)
+  {
+    ++disp;
+    vtkCell* cell = polydata->GetCell(i);
+    int numPoints = cell->GetNumberOfPoints();
+    vtkPoints* points = cell->GetPoints();
+
+    bool positive = false;
+    if (numPoints>1)
+      for (unsigned int m=0; m<m_RoiImages.size(); ++m)
+      {
+        auto roi = m_RoiImages.at(m);
+
+        int inside = 0;
+
+        // check first fiber point
+        {
+          double* p = points->GetPoint(0);
+          itk::Point<float, 3> itkP;
+          itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
+
+          if ( IsPositive(itkP, roi) )
+            inside++;
+        }
+
+        // check second fiber point
+        {
+          double* p = points->GetPoint(numPoints-1);
+          itk::Point<float, 3> itkP;
+          itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
+          itk::Index<3> idx;
+          roi->TransformPhysicalPointToIndex(itkP, idx);
+          if ( IsPositive(itkP, roi) )
+            inside++;
+        }
+
+        if (inside==2 || (inside==1 && !m_BothEnds))
+        {
+          positive = true;
+          positive_ids[m].push_back(i);
+        }
+      }
+    if (!positive)
+      negative_ids.push_back(i);
+  }
+
+  if (!m_NoNegatives)
+    m_Negatives.push_back(CreateFib(negative_ids));
+  if (!m_NoPositives)
+    for (auto ids : positive_ids)
+      m_Positives.push_back(CreateFib(ids));
+}
+
+template< class PixelType >
+void FiberExtractionFilter< PixelType >::SetLabels(const std::vector<unsigned short> &Labels)
+{
+  m_Labels = Labels;
+}
+
+template< class PixelType >
+std::vector<mitk::FiberBundle::Pointer> FiberExtractionFilter< PixelType >::GetNegatives() const
+{
+  return m_Negatives;
+}
+
+template< class PixelType >
+std::vector<mitk::FiberBundle::Pointer> FiberExtractionFilter< PixelType >::GetPositives() const
+{
+  return m_Positives;
+}
+
+template< class PixelType >
+void FiberExtractionFilter< PixelType >::GenerateData()
+{
+  mitk::FiberBundle::Pointer fib = m_InputFiberBundle;
+  if (fib->GetNumFibers()<=0)
+  {
+    MITK_INFO << "No fibers in tractogram!";
+    return;
+  }
+
+  if (m_Mode==MODE::OVERLAP && !m_DontResampleFibers)
+  {
+    float minSpacing = 1;
+    for (auto mask : m_RoiImages)
+    {
+      for (int i=0; i<3; ++i)
+        if(mask->GetSpacing()[i]<minSpacing)
+          minSpacing = mask->GetSpacing()[i];
+    }
+
+    fib = m_InputFiberBundle->GetDeepCopy();
+    fib->ResampleLinear(minSpacing/5);
+  }
+
+  if (m_Mode == MODE::OVERLAP)
+    ExtractOverlap(fib);
+  else if (m_Mode == MODE::ENDPOINTS)
+    ExtractEndpoints(fib);
+}
+
+}
+
+#endif // __itkFiberExtractionFilter_cpp
+
+
+
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h
new file mode 100644
index 0000000000..f3b729f238
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h
@@ -0,0 +1,112 @@
+/*===================================================================
+
+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 itkFiberExtractionFilter_h
+#define itkFiberExtractionFilter_h
+
+// MITK
+#include <mitkFiberBundle.h>
+
+// ITK
+#include <itkProcessObject.h>
+#include <itkLinearInterpolateImageFunction.h>
+
+namespace itk{
+
+/**
+* \brief Extract streamlines from tractograms using binary images */
+
+template< class PixelType >
+class FiberExtractionFilter : public ProcessObject
+{
+public:
+
+  enum MODE {
+    OVERLAP,
+    ENDPOINTS
+  };
+
+  enum INPUT {
+    SCALAR_MAP,  ///< In this case, positive means roi image vlaue > threshold
+    LABEL_MAP    ///< In this case, positive means roi image value in labels vector
+  };
+
+  typedef FiberExtractionFilter Self;
+  typedef ProcessObject                   Superclass;
+  typedef SmartPointer< Self >            Pointer;
+  typedef SmartPointer< const Self >      ConstPointer;
+  typedef itk::Image< PixelType , 3>      ItkInputImgType;
+
+
+  itkFactorylessNewMacro(Self)
+  itkCloneMacro(Self)
+  itkTypeMacro( FiberExtractionFilter, ProcessObject )
+
+  virtual void Update() override{
+    this->GenerateData();
+  }
+
+  itkSetMacro( InputFiberBundle, mitk::FiberBundle::Pointer )
+  itkSetMacro( Mode, MODE )
+  itkSetMacro( InputType, INPUT )
+  itkSetMacro( BothEnds, bool )
+  itkSetMacro( OverlapFraction, float )
+  itkSetMacro( DontResampleFibers, bool )
+  itkSetMacro( NoNegatives, bool )
+  itkSetMacro( NoPositives, bool )
+  itkSetMacro( Interpolate, bool )
+  itkSetMacro( Threshold, float )
+
+  void SetRoiImages(const std::vector< ItkInputImgType* > &rois);
+  void SetLabels(const std::vector<unsigned short> &Labels);
+
+  std::vector<mitk::FiberBundle::Pointer> GetPositives() const;
+  std::vector<mitk::FiberBundle::Pointer> GetNegatives() const;
+
+protected:
+
+  void GenerateData() override;
+
+  FiberExtractionFilter();
+  virtual ~FiberExtractionFilter();
+
+  mitk::FiberBundle::Pointer CreateFib(std::vector< long >& ids);
+  void ExtractOverlap(mitk::FiberBundle::Pointer fib);
+  void ExtractEndpoints(mitk::FiberBundle::Pointer fib);
+  bool IsPositive(const itk::Point<float, 3>& itkP, itk::Image<PixelType, 3>* image);
+
+  mitk::FiberBundle::Pointer                  m_InputFiberBundle;
+  std::vector< mitk::FiberBundle::Pointer >   m_Positives;
+  std::vector< mitk::FiberBundle::Pointer >   m_Negatives;
+  std::vector< ItkInputImgType* >             m_RoiImages;
+  bool                                        m_DontResampleFibers;
+  MODE                                        m_Mode;
+  INPUT                                       m_InputType;
+  bool                                        m_BothEnds;
+  float                                       m_OverlapFraction;
+  bool                                        m_NoNegatives;
+  bool                                        m_NoPositives;
+  bool                                        m_Interpolate;
+  float                                       m_Threshold;
+  std::vector< unsigned short >               m_Labels;
+  typename itk::LinearInterpolateImageFunction< itk::Image< PixelType, 3 >, float >::Pointer   m_Interpolator;
+};
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkFiberExtractionFilter.cpp"
+#endif
+
+#endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.cpp
index 07ff340145..ba6dae923c 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.cpp
@@ -1,718 +1,762 @@
 #include "itkFitFibersToImageFilter.h"
 
 #include <boost/progress.hpp>
 
 namespace itk{
 
 FitFibersToImageFilter::FitFibersToImageFilter()
   : m_PeakImage(nullptr)
   , m_MaskImage(nullptr)
   , m_FitIndividualFibers(true)
   , m_GradientTolerance(1e-5)
-  , m_Lambda(0.1)
+  , m_Lambda(1.0)
   , m_MaxIterations(20)
   , m_FiberSampling(10)
   , m_Coverage(0)
   , m_Overshoot(0)
   , m_RMSE(0.0)
   , m_FilterOutliers(true)
   , m_MeanWeight(1.0)
   , m_MedianWeight(1.0)
   , m_MinWeight(1.0)
   , m_MaxWeight(1.0)
   , m_Verbose(true)
   , m_DeepCopy(true)
   , m_ResampleFibers(true)
   , m_NumUnknowns(0)
   , m_NumResiduals(0)
   , m_NumCoveredDirections(0)
   , m_SignalModel(nullptr)
   , sz_x(0)
   , sz_y(0)
   , sz_z(0)
-  , TD(0)
-  , FD(0)
+  , m_MeanTractDensity(0)
+  , m_MeanSignal(0)
   , fiber_count(0)
+  , m_Regularization(VnlCostFunction::REGU::Local_MSE)
 {
   this->SetNumberOfRequiredOutputs(3);
 }
 
 FitFibersToImageFilter::~FitFibersToImageFilter()
 {
 
 }
 
 void FitFibersToImageFilter::CreateDiffSystem()
 {
   sz_x = m_DiffImage->GetLargestPossibleRegion().GetSize(0);
   sz_y = m_DiffImage->GetLargestPossibleRegion().GetSize(1);
   sz_z = m_DiffImage->GetLargestPossibleRegion().GetSize(2);
   dim_four_size = m_DiffImage->GetVectorLength();
   int num_voxels = sz_x*sz_y*sz_z;
 
   float minSpacing = 1;
   if(m_DiffImage->GetSpacing()[0]<m_DiffImage->GetSpacing()[1] && m_DiffImage->GetSpacing()[0]<m_DiffImage->GetSpacing()[2])
     minSpacing = m_DiffImage->GetSpacing()[0];
   else if (m_DiffImage->GetSpacing()[1] < m_DiffImage->GetSpacing()[2])
     minSpacing = m_DiffImage->GetSpacing()[1];
   else
     minSpacing = m_DiffImage->GetSpacing()[2];
 
   if (m_ResampleFibers)
     for (unsigned int bundle=0; bundle<m_Tractograms.size(); bundle++)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());
       if (m_DeepCopy)
         m_Tractograms[bundle] = m_Tractograms.at(bundle)->GetDeepCopy();
       m_Tractograms.at(bundle)->ResampleLinear(minSpacing/m_FiberSampling);
       std::cout.rdbuf (old);
     }
 
   m_NumResiduals = num_voxels * dim_four_size;
 
   MITK_INFO << "Num. unknowns: " << m_NumUnknowns;
   MITK_INFO << "Num. residuals: " << m_NumResiduals;
   MITK_INFO << "Creating system ...";
 
   A.set_size(m_NumResiduals, m_NumUnknowns);
   b.set_size(m_NumResiduals); b.fill(0.0);
 
-  TD = 0;
-  FD = 0;
+  m_MeanTractDensity = 0;
+  m_MeanSignal = 0;
   m_NumCoveredDirections = 0;
   fiber_count = 0;
   vnl_vector<int> voxel_indicator; voxel_indicator.set_size(sz_x*sz_y*sz_z); voxel_indicator.fill(0);
 
   for (unsigned int bundle=0; bundle<m_Tractograms.size(); bundle++)
   {
     vtkSmartPointer<vtkPolyData> polydata = m_Tractograms.at(bundle)->GetFiberPolyData();
 
     for (int i=0; i<m_Tractograms.at(bundle)->GetNumFibers(); ++i)
     {
       vtkCell* cell = polydata->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       if (numPoints<2)
         MITK_INFO << "FIBER WITH ONLY ONE POINT ENCOUNTERED!";
 
       for (int j=0; j<numPoints-1; ++j)
       {
         double* p1 = points->GetPoint(j);
         PointType3 p;
         p[0]=p1[0];
         p[1]=p1[1];
         p[2]=p1[2];
 
         itk::Index<3> idx3;
         m_DiffImage->TransformPhysicalPointToIndex(p, idx3);
         if (!m_DiffImage->GetLargestPossibleRegion().IsInside(idx3) || (m_MaskImage.IsNotNull() && m_MaskImage->GetPixel(idx3)==0))
           continue;
 
         double* p2 = points->GetPoint(j+1);
         mitk::DiffusionSignalModel<>::GradientType fiber_dir;
         fiber_dir[0] = p[0]-p2[0];
         fiber_dir[1] = p[1]-p2[1];
         fiber_dir[2] = p[2]-p2[2];
         fiber_dir.Normalize();
 
         int x = idx3[0];
         int y = idx3[1];
         int z = idx3[2];
 
 
         m_SignalModel->SetFiberDirection(fiber_dir);
         mitk::DiffusionSignalModel<>::PixelType simulated_pixel = m_SignalModel->SimulateMeasurement();
         VectorImgType::PixelType measured_pixel = m_DiffImage->GetPixel(idx3);
 
         double simulated_mean = 0;
         double measured_mean = 0;
         int num_nonzero_g = 0;
         for (int g=0; g<dim_four_size; ++g)
         {
           if( m_SignalModel->GetGradientDirection(g).GetNorm()<mitk::eps )
             continue;
           simulated_mean += simulated_pixel[g];
           measured_mean += (double)measured_pixel[g];
           ++num_nonzero_g;
         }
         simulated_mean /= num_nonzero_g;
         measured_mean /= num_nonzero_g;
         simulated_pixel -= simulated_mean;
 
         if (voxel_indicator[x + sz_x*y + sz_x*sz_y*z]==0)
-          FD += measured_mean;
-        TD += simulated_mean;
+          m_MeanSignal += measured_mean;
+        m_MeanTractDensity += simulated_mean;
         voxel_indicator[x + sz_x*y + sz_x*sz_y*z] = 1;
 
         for (int g=0; g<dim_four_size; ++g)
         {
           unsigned int linear_index = x + sz_x*y + sz_x*sz_y*z + sz_x*sz_y*sz_z*g;
 
           if (m_FitIndividualFibers)
           {
             b[linear_index] = (double)measured_pixel[g] - measured_mean;
             A.put(linear_index, fiber_count, A.get(linear_index, fiber_count) + simulated_pixel[g]);
           }
           else
           {
             b[linear_index] = (double)measured_pixel[g] - measured_mean;
             A.put(linear_index, bundle, A.get(linear_index, bundle) + simulated_pixel[g]);
           }
         }
 
       }
 
       ++fiber_count;
     }
   }
 
   m_NumCoveredDirections = voxel_indicator.sum();
-  TD /= (m_NumCoveredDirections*fiber_count);
-  FD /= m_NumCoveredDirections;
-  A /= TD;
-  b *= 100.0/FD;  // times 100 because we want to avoid too small values for computational reasons
+
+  m_MeanTractDensity /= (m_NumCoveredDirections*fiber_count);
+  m_MeanSignal /= m_NumCoveredDirections;
+  A /= m_MeanTractDensity;
+  b *= 100.0/m_MeanSignal;  // times 100 because we want to avoid too small values for computational reasons
+
+  // NEW FIT
+//  m_MeanTractDensity /= m_NumCoveredDirections;
+//  m_MeanSignal /= m_NumCoveredDirections;
+//  b /= m_MeanSignal;
+//  b *= m_MeanTractDensity;
 }
 
 void FitFibersToImageFilter::CreatePeakSystem()
 {
   sz_x = m_PeakImage->GetLargestPossibleRegion().GetSize(0);
   sz_y = m_PeakImage->GetLargestPossibleRegion().GetSize(1);
   sz_z = m_PeakImage->GetLargestPossibleRegion().GetSize(2);
   dim_four_size = m_PeakImage->GetLargestPossibleRegion().GetSize(3)/3 + 1; // +1 for zero - peak
   int num_voxels = sz_x*sz_y*sz_z;
 
   float minSpacing = 1;
   if(m_PeakImage->GetSpacing()[0]<m_PeakImage->GetSpacing()[1] && m_PeakImage->GetSpacing()[0]<m_PeakImage->GetSpacing()[2])
     minSpacing = m_PeakImage->GetSpacing()[0];
   else if (m_PeakImage->GetSpacing()[1] < m_PeakImage->GetSpacing()[2])
     minSpacing = m_PeakImage->GetSpacing()[1];
   else
     minSpacing = m_PeakImage->GetSpacing()[2];
 
   if (m_ResampleFibers)
     for (unsigned int bundle=0; bundle<m_Tractograms.size(); bundle++)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());
       if (m_DeepCopy)
         m_Tractograms[bundle] = m_Tractograms.at(bundle)->GetDeepCopy();
       m_Tractograms.at(bundle)->ResampleLinear(minSpacing/m_FiberSampling);
       std::cout.rdbuf (old);
     }
 
   m_NumResiduals = num_voxels * dim_four_size;
 
   MITK_INFO << "Num. unknowns: " << m_NumUnknowns;
   MITK_INFO << "Num. residuals: " << m_NumResiduals;
   MITK_INFO << "Creating system ...";
 
   A.set_size(m_NumResiduals, m_NumUnknowns);
   b.set_size(m_NumResiduals); b.fill(0.0);
 
-  TD = 0;
-  FD = 0;
+  m_MeanTractDensity = 0;
+  m_MeanSignal = 0;
   m_NumCoveredDirections = 0;
   fiber_count = 0;
 
   for (unsigned int bundle=0; bundle<m_Tractograms.size(); bundle++)
   {
     vtkSmartPointer<vtkPolyData> polydata = m_Tractograms.at(bundle)->GetFiberPolyData();
 
     for (int i=0; i<m_Tractograms.at(bundle)->GetNumFibers(); ++i)
     {
       vtkCell* cell = polydata->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       if (numPoints<2)
         MITK_INFO << "FIBER WITH ONLY ONE POINT ENCOUNTERED!";
 
       for (int j=0; j<numPoints-1; ++j)
       {
         double* p1 = points->GetPoint(j);
         PointType4 p;
         p[0]=p1[0];
         p[1]=p1[1];
         p[2]=p1[2];
         p[3]=0;
 
         itk::Index<4> idx4;
         m_PeakImage->TransformPhysicalPointToIndex(p, idx4);
         itk::Index<3> idx3; idx3[0] = idx4[0]; idx3[1] = idx4[1]; idx3[2] = idx4[2];
         if (!m_PeakImage->GetLargestPossibleRegion().IsInside(idx4) || (m_MaskImage.IsNotNull() && m_MaskImage->GetPixel(idx3)==0))
           continue;
 
         double* p2 = points->GetPoint(j+1);
         vnl_vector_fixed<float,3> fiber_dir;
         fiber_dir[0] = p[0]-p2[0];
         fiber_dir[1] = p[1]-p2[1];
         fiber_dir[2] = p[2]-p2[2];
         fiber_dir.normalize();
 
         double w = 1;
         int peak_id = dim_four_size-1;
         vnl_vector_fixed<float,3> odf_peak = GetClosestPeak(idx4, m_PeakImage, fiber_dir, peak_id, w);
         float peak_mag = odf_peak.magnitude();
 
         int x = idx4[0];
         int y = idx4[1];
         int z = idx4[2];
 
         unsigned int linear_index = x + sz_x*y + sz_x*sz_y*z + sz_x*sz_y*sz_z*peak_id;
 
         if (b[linear_index] == 0 && peak_id<dim_four_size-1)
         {
           m_NumCoveredDirections++;
-          FD += peak_mag;
+          m_MeanSignal += peak_mag;
         }
-        TD += w;
+        m_MeanTractDensity += w;
 
         if (m_FitIndividualFibers)
         {
           b[linear_index] = peak_mag;
           A.put(linear_index, fiber_count, A.get(linear_index, fiber_count) + w);
         }
         else
         {
           b[linear_index] = peak_mag;
           A.put(linear_index, bundle, A.get(linear_index, bundle) + w);
         }
       }
 
       ++fiber_count;
     }
   }
-
-  TD /= (m_NumCoveredDirections*fiber_count);
-  FD /= m_NumCoveredDirections;
-  A /= TD;
-  b *= 100.0/FD;  // times 100 because we want to avoid too small values for computational reasons
+  m_MeanTractDensity /= (m_NumCoveredDirections*fiber_count);
+  m_MeanSignal /= m_NumCoveredDirections;
+  A /= m_MeanTractDensity;
+  b *= 100.0/m_MeanSignal;  // times 100 because we want to avoid too small values for computational reasons
+
+  // NEW FIT
+//  m_MeanTractDensity /= m_NumCoveredDirections;
+//  m_MeanSignal /= m_NumCoveredDirections;
+//  b /= m_MeanSignal;
+//  b *= m_MeanTractDensity;
 }
 
 void FitFibersToImageFilter::GenerateData()
 {
   m_NumUnknowns = m_Tractograms.size();
   if (m_FitIndividualFibers)
   {
     m_NumUnknowns = 0;
     for (unsigned int bundle=0; bundle<m_Tractograms.size(); bundle++)
       m_NumUnknowns += m_Tractograms.at(bundle)->GetNumFibers();
   }
+  else
+    m_FilterOutliers = false;
+  if (m_NumUnknowns<1)
+  {
+    MITK_INFO << "No fibers in tractogram.";
+    return;
+  }
 
   fiber_count = 0;
   sz_x = 0;
   sz_y = 0;
   sz_z = 0;
-  TD = 0;
-  FD = 0;
+  m_MeanTractDensity = 0;
+  m_MeanSignal = 0;
   if (m_PeakImage.IsNotNull())
     CreatePeakSystem();
   else if (m_DiffImage.IsNotNull())
     CreateDiffSystem();
   else
     mitkThrow() << "No input image set!";
 
   double init_lambda = fiber_count;  // initialization for lambda estimation
 
   itk::TimeProbe clock;
   clock.Start();
 
   cost = VnlCostFunction(m_NumUnknowns);
-  cost.SetProblem(A, b, init_lambda);
-  m_Weights.set_size(m_NumUnknowns); // m_Weights.fill( TD/100.0 * FD/2.0 );
+  cost.SetProblem(A, b, init_lambda, m_Regularization);
+  m_Weights.set_size(m_NumUnknowns);
   m_Weights.fill( 0.0 );
   vnl_lbfgsb minimizer(cost);
   vnl_vector<double> l; l.set_size(m_NumUnknowns); l.fill(0);
   vnl_vector<long> bound_selection; bound_selection.set_size(m_NumUnknowns); bound_selection.fill(1);
   minimizer.set_bound_selection(bound_selection);
   minimizer.set_lower_bound(l);
   minimizer.set_projected_gradient_tolerance(m_GradientTolerance);
 
-  MITK_INFO << "Estimating regularization";
-  minimizer.set_trace(false);
-  minimizer.set_max_function_evals(2);
-  minimizer.minimize(m_Weights);
-  vnl_vector<double> dx; dx.set_size(m_NumUnknowns); dx.fill(0.0);
-  cost.grad_regu_localMSE(m_Weights, dx);
-  double r = dx.magnitude()/m_Weights.magnitude();
-  cost.m_Lambda *= m_Lambda*55.0/r;
-  MITK_INFO << r << " - " << m_Lambda*55.0/r;
-  if (cost.m_Lambda>10e7)
+  MITK_INFO << "Regularization type: " << m_Regularization;
+  if (m_Regularization!=VnlCostFunction::REGU::NONE)  // REMOVE FOR NEW FIT AND SET cost.m_Lambda = m_Lambda
   {
-    MITK_INFO << "Regularization estimation failed. Using default value.";
-    cost.m_Lambda = fiber_count;
+    MITK_INFO << "Estimating regularization";
+    minimizer.set_trace(false);
+    minimizer.set_max_function_evals(2);
+    minimizer.minimize(m_Weights);
+    vnl_vector<double> dx; dx.set_size(m_NumUnknowns); dx.fill(0.0);
+    cost.calc_regularization_gradient(m_Weights, dx);
+    double r = dx.magnitude()/m_Weights.magnitude();  // wtf???
+    cost.m_Lambda *= m_Lambda*55.0/r;
+    MITK_INFO << r << " - " << m_Lambda*55.0/r;
+    if (cost.m_Lambda>10e7)
+    {
+      MITK_INFO << "Regularization estimation failed. Using default value.";
+      cost.m_Lambda = fiber_count;
+    }
   }
   MITK_INFO << "Using regularization factor of " << cost.m_Lambda << " (λ: " << m_Lambda << ")";
 
   MITK_INFO << "Fitting fibers";
   minimizer.set_trace(m_Verbose);
 
   minimizer.set_max_function_evals(m_MaxIterations);
   minimizer.minimize(m_Weights);
 
   std::vector< double > weights;
   if (m_FilterOutliers)
   {
     for (auto w : m_Weights)
       weights.push_back(w);
     std::sort(weights.begin(), weights.end());
     MITK_INFO << "Setting upper weight bound to " << weights.at(m_NumUnknowns*0.99);
     vnl_vector<double> u; u.set_size(m_NumUnknowns); u.fill(weights.at(m_NumUnknowns*0.99));
     minimizer.set_upper_bound(u);
     bound_selection.fill(2);
     minimizer.set_bound_selection(bound_selection);
     minimizer.minimize(m_Weights);
     weights.clear();
   }
 
   for (auto w : m_Weights)
     weights.push_back(w);
   std::sort(weights.begin(), weights.end());
 
   m_MeanWeight = m_Weights.mean();
   m_MedianWeight = weights.at(m_NumUnknowns*0.5);
   m_MinWeight = weights.at(0);
   m_MaxWeight = weights.at(m_NumUnknowns-1);
 
   MITK_INFO << "*************************";
   MITK_INFO << "Weight statistics";
+  MITK_INFO << "Sum: " << m_Weights.sum();
   MITK_INFO << "Mean: " << m_MeanWeight;
+  MITK_INFO << "1% quantile: " << weights.at(m_NumUnknowns*0.01);
+  MITK_INFO << "5% quantile: " << weights.at(m_NumUnknowns*0.05);
+  MITK_INFO << "25% quantile: " << weights.at(m_NumUnknowns*0.25);
   MITK_INFO << "Median: " << m_MedianWeight;
   MITK_INFO << "75% quantile: " << weights.at(m_NumUnknowns*0.75);
   MITK_INFO << "95% quantile: " << weights.at(m_NumUnknowns*0.95);
   MITK_INFO << "99% quantile: " << weights.at(m_NumUnknowns*0.99);
   MITK_INFO << "Min: " << m_MinWeight;
   MITK_INFO << "Max: " << m_MaxWeight;
   MITK_INFO << "*************************";
   MITK_INFO << "NumEvals: " << minimizer.get_num_evaluations();
   MITK_INFO << "NumIterations: " << minimizer.get_num_iterations();
   MITK_INFO << "Residual cost: " << minimizer.get_end_error();
   m_RMSE = cost.S->get_rms_error(m_Weights);
   MITK_INFO << "Final RMS: " << m_RMSE;
 
   clock.Stop();
   int h = clock.GetTotal()/3600;
   int m = ((int)clock.GetTotal()%3600)/60;
   int s = (int)clock.GetTotal()%60;
   MITK_INFO << "Optimization took " << h << "h, " << m << "m and " << s << "s";
 
   MITK_INFO << "Weighting fibers";
-  m_RmsDiffPerFiber.set_size(m_Weights.size());
   m_RmsDiffPerBundle.set_size(m_Tractograms.size());
   std::streambuf *old = cout.rdbuf(); // <-- save
   std::stringstream ss;
   std::cout.rdbuf (ss.rdbuf());
   if (m_FitIndividualFibers)
   {
     unsigned int fiber_count = 0;
     for (unsigned int bundle=0; bundle<m_Tractograms.size(); bundle++)
     {
       vnl_vector< double > temp_weights;
       temp_weights.set_size(m_Weights.size());
       temp_weights.copy_in(m_Weights.data_block());
 
       for (int i=0; i<m_Tractograms.at(bundle)->GetNumFibers(); i++)
       {
         m_Tractograms.at(bundle)->SetFiberWeight(i, m_Weights[fiber_count]);
         temp_weights[fiber_count] = 0;
 
         ++fiber_count;
       }
       double d_rms = cost.S->get_rms_error(temp_weights) - m_RMSE;
       m_RmsDiffPerBundle[bundle] = d_rms;
       m_Tractograms.at(bundle)->Compress(0.1);
       m_Tractograms.at(bundle)->ColorFibersByFiberWeights(false, true);
     }
   }
   else
   {
     for (unsigned int i=0; i<m_Tractograms.size(); ++i)
     {
+      vnl_vector< double > temp_weights;
+      temp_weights.set_size(m_Weights.size());
+      temp_weights.copy_in(m_Weights.data_block());
+      temp_weights[i] = 0;
+      double d_rms = cost.S->get_rms_error(temp_weights) - m_RMSE;
+      m_RmsDiffPerBundle[i] = d_rms;
+
       m_Tractograms.at(i)->SetFiberWeights(m_Weights[i]);
       m_Tractograms.at(i)->Compress(0.1);
       m_Tractograms.at(i)->ColorFibersByFiberWeights(false, true);
     }
   }
   std::cout.rdbuf (old);
 
   // transform back
-  A *= FD/100.0;
-  b *= FD/100.0;
+  A *= m_MeanSignal/100.0;
+  b *= m_MeanSignal/100.0;
 
   MITK_INFO << "Generating output images ...";
   if (m_PeakImage.IsNotNull())
     GenerateOutputPeakImages();
   else if (m_DiffImage.IsNotNull())
     GenerateOutputDiffImages();
 
-  m_Coverage = m_Coverage/FD;
-  m_Overshoot = m_Overshoot/FD;
+  m_Coverage = m_Coverage/m_MeanSignal;
+  m_Overshoot = m_Overshoot/m_MeanSignal;
 
   MITK_INFO << std::fixed << "Coverage: " << setprecision(2) << 100.0*m_Coverage << "%";
   MITK_INFO << std::fixed << "Overshoot: " << setprecision(2) << 100.0*m_Overshoot << "%";
 }
 
 void FitFibersToImageFilter::GenerateOutputDiffImages()
 {
   VectorImgType::PixelType pix; pix.SetSize(m_DiffImage->GetVectorLength()); pix.Fill(0);
   itk::ImageDuplicator< VectorImgType >::Pointer duplicator = itk::ImageDuplicator< VectorImgType >::New();
   duplicator->SetInputImage(m_DiffImage);
   duplicator->Update();
   m_UnderexplainedImageDiff = duplicator->GetOutput();
   m_UnderexplainedImageDiff->FillBuffer(pix);
 
   duplicator->SetInputImage(m_UnderexplainedImageDiff);
   duplicator->Update();
   m_OverexplainedImageDiff = duplicator->GetOutput();
   m_OverexplainedImageDiff->FillBuffer(pix);
 
   duplicator->SetInputImage(m_OverexplainedImageDiff);
   duplicator->Update();
   m_ResidualImageDiff = duplicator->GetOutput();
   m_ResidualImageDiff->FillBuffer(pix);
 
   duplicator->SetInputImage(m_ResidualImageDiff);
   duplicator->Update();
   m_FittedImageDiff = duplicator->GetOutput();
   m_FittedImageDiff->FillBuffer(pix);
 
   vnl_vector<double> fitted_b; fitted_b.set_size(b.size());
   cost.S->multiply(m_Weights, fitted_b);
 
   itk::ImageRegionIterator<VectorImgType> it1 = itk::ImageRegionIterator<VectorImgType>(m_DiffImage, m_DiffImage->GetLargestPossibleRegion());
   itk::ImageRegionIterator<VectorImgType> it2 = itk::ImageRegionIterator<VectorImgType>(m_FittedImageDiff, m_FittedImageDiff->GetLargestPossibleRegion());
   itk::ImageRegionIterator<VectorImgType> it3 = itk::ImageRegionIterator<VectorImgType>(m_ResidualImageDiff, m_ResidualImageDiff->GetLargestPossibleRegion());
   itk::ImageRegionIterator<VectorImgType> it4 = itk::ImageRegionIterator<VectorImgType>(m_UnderexplainedImageDiff, m_UnderexplainedImageDiff->GetLargestPossibleRegion());
   itk::ImageRegionIterator<VectorImgType> it5 = itk::ImageRegionIterator<VectorImgType>(m_OverexplainedImageDiff, m_OverexplainedImageDiff->GetLargestPossibleRegion());
 
-  FD = 0;
+  m_MeanSignal = 0;
   m_Coverage = 0;
   m_Overshoot = 0;
 
   while( !it2.IsAtEnd() )
   {
     itk::Index<3> idx3 = it2.GetIndex();
     VectorImgType::PixelType original_pix =it1.Get();
     VectorImgType::PixelType fitted_pix =it2.Get();
     VectorImgType::PixelType residual_pix =it3.Get();
     VectorImgType::PixelType underexplained_pix =it4.Get();
     VectorImgType::PixelType overexplained_pix =it5.Get();
 
     int num_nonzero_g = 0;
     double original_mean = 0;
     for (int g=0; g<dim_four_size; ++g)
     {
       if( m_SignalModel->GetGradientDirection(g).GetNorm()>=mitk::eps )
       {
         original_mean += original_pix[g];
         ++num_nonzero_g;
       }
     }
     original_mean /= num_nonzero_g;
 
     for (int g=0; g<dim_four_size; ++g)
     {
       unsigned int linear_index = idx3[0] + sz_x*idx3[1] + sz_x*sz_y*idx3[2] + sz_x*sz_y*sz_z*g;
 
       fitted_pix[g] = fitted_b[linear_index] + original_mean;
       residual_pix[g] = original_pix[g] - fitted_b[linear_index] - original_mean;
 
       if (residual_pix[g]<0)
       {
         overexplained_pix[g] = residual_pix[g];
         m_Coverage += b[linear_index] + original_mean;
         m_Overshoot -= residual_pix[g];
       }
       else if (residual_pix[g]>=0)
       {
         underexplained_pix[g] = residual_pix[g];
         m_Coverage += fitted_b[linear_index] + original_mean;
       }
-      FD += b[linear_index] + original_mean;
+      m_MeanSignal += b[linear_index] + original_mean;
     }
 
     it2.Set(fitted_pix);
     it3.Set(residual_pix);
     it4.Set(underexplained_pix);
     it5.Set(overexplained_pix);
 
     ++it1;
     ++it2;
     ++it3;
     ++it4;
     ++it5;
   }
 }
 
+VnlCostFunction::REGU FitFibersToImageFilter::GetRegularization() const
+{
+  return m_Regularization;
+}
+
+void FitFibersToImageFilter::SetRegularization(const VnlCostFunction::REGU &Regularization)
+{
+  m_Regularization = Regularization;
+}
+
 void FitFibersToImageFilter::GenerateOutputPeakImages()
 {
   itk::ImageDuplicator< PeakImgType >::Pointer duplicator = itk::ImageDuplicator< PeakImgType >::New();
   duplicator->SetInputImage(m_PeakImage);
   duplicator->Update();
   m_UnderexplainedImage = duplicator->GetOutput();
   m_UnderexplainedImage->FillBuffer(0.0);
 
   duplicator->SetInputImage(m_UnderexplainedImage);
   duplicator->Update();
   m_OverexplainedImage = duplicator->GetOutput();
   m_OverexplainedImage->FillBuffer(0.0);
 
   duplicator->SetInputImage(m_OverexplainedImage);
   duplicator->Update();
   m_ResidualImage = duplicator->GetOutput();
   m_ResidualImage->FillBuffer(0.0);
 
   duplicator->SetInputImage(m_ResidualImage);
   duplicator->Update();
   m_FittedImage = duplicator->GetOutput();
   m_FittedImage->FillBuffer(0.0);
 
   vnl_vector<double> fitted_b; fitted_b.set_size(b.size());
   cost.S->multiply(m_Weights, fitted_b);
 
   for (unsigned int r=0; r<b.size(); r++)
   {
     itk::Index<4> idx4;
     unsigned int linear_index = r;
     idx4[0] = linear_index % sz_x; linear_index /= sz_x;
     idx4[1] = linear_index % sz_y; linear_index /= sz_y;
     idx4[2] = linear_index % sz_z; linear_index /= sz_z;
     int peak_id = linear_index % dim_four_size;
 
     if (peak_id<dim_four_size-1)
     {
       vnl_vector_fixed<float,3> peak_dir;
 
       idx4[3] = peak_id*3;
       peak_dir[0] = m_PeakImage->GetPixel(idx4);
       idx4[3] += 1;
       peak_dir[1] = m_PeakImage->GetPixel(idx4);
       idx4[3] += 1;
       peak_dir[2] = m_PeakImage->GetPixel(idx4);
 
       peak_dir.normalize();
       peak_dir *= fitted_b[r];
 
       idx4[3] = peak_id*3;
       m_FittedImage->SetPixel(idx4, peak_dir[0]);
 
       idx4[3] += 1;
       m_FittedImage->SetPixel(idx4, peak_dir[1]);
 
       idx4[3] += 1;
       m_FittedImage->SetPixel(idx4, peak_dir[2]);
     }
   }
 
-  FD = 0;
+  m_MeanSignal = 0;
   m_Coverage = 0;
   m_Overshoot = 0;
 
   itk::Index<4> idx4;
   for (idx4[0]=0; idx4[0]<sz_x; ++idx4[0])
     for (idx4[1]=0; idx4[1]<sz_y; ++idx4[1])
       for (idx4[2]=0; idx4[2]<sz_z; ++idx4[2])
       {
         itk::Index<3> idx3; idx3[0] = idx4[0]; idx3[1] = idx4[1]; idx3[2] = idx4[2];
         if (m_MaskImage.IsNotNull() && m_MaskImage->GetPixel(idx3)==0)
           continue;
 
         vnl_vector_fixed<float,3> peak_dir;
         vnl_vector_fixed<float,3> fitted_dir;
         vnl_vector_fixed<float,3> overshoot_dir;
         for (idx4[3]=0; idx4[3]<(itk::IndexValueType)m_PeakImage->GetLargestPossibleRegion().GetSize(3); ++idx4[3])
         {
           peak_dir[idx4[3]%3] = m_PeakImage->GetPixel(idx4);
           fitted_dir[idx4[3]%3] = m_FittedImage->GetPixel(idx4);
           m_ResidualImage->SetPixel(idx4, m_PeakImage->GetPixel(idx4) - m_FittedImage->GetPixel(idx4));
 
           if (idx4[3]%3==2)
           {
-            FD += peak_dir.magnitude();
+            m_MeanSignal += peak_dir.magnitude();
 
             itk::Index<4> tidx= idx4;
             if (peak_dir.magnitude()>fitted_dir.magnitude())
             {
               m_Coverage += fitted_dir.magnitude();
               m_UnderexplainedImage->SetPixel(tidx, peak_dir[2]-fitted_dir[2]); tidx[3]--;
               m_UnderexplainedImage->SetPixel(tidx, peak_dir[1]-fitted_dir[1]); tidx[3]--;
               m_UnderexplainedImage->SetPixel(tidx, peak_dir[0]-fitted_dir[0]);
             }
             else
             {
               overshoot_dir[0] = fitted_dir[0]-peak_dir[0];
               overshoot_dir[1] = fitted_dir[1]-peak_dir[1];
               overshoot_dir[2] = fitted_dir[2]-peak_dir[2];
               m_Coverage += peak_dir.magnitude();
               m_Overshoot += overshoot_dir.magnitude();
               m_OverexplainedImage->SetPixel(tidx, overshoot_dir[2]); tidx[3]--;
               m_OverexplainedImage->SetPixel(tidx, overshoot_dir[1]); tidx[3]--;
               m_OverexplainedImage->SetPixel(tidx, overshoot_dir[0]);
             }
           }
         }
       }
 }
 
 vnl_vector_fixed<float,3> FitFibersToImageFilter::GetClosestPeak(itk::Index<4> idx, PeakImgType::Pointer peak_image , vnl_vector_fixed<float,3> fiber_dir, int& id, double& w )
 {
   int m_NumDirs = peak_image->GetLargestPossibleRegion().GetSize()[3]/3;
   vnl_vector_fixed<float,3> out_dir; out_dir.fill(0);
   float angle = 0.9;
 
   for (int i=0; i<m_NumDirs; i++)
   {
     vnl_vector_fixed<float,3> dir;
     idx[3] = i*3;
     dir[0] = peak_image->GetPixel(idx);
     idx[3] += 1;
     dir[1] = peak_image->GetPixel(idx);
     idx[3] += 1;
     dir[2] = peak_image->GetPixel(idx);
 
     float mag = dir.magnitude();
     if (mag<mitk::eps)
       continue;
 
     dir.normalize();
 
     float a = dot_product(dir, fiber_dir);
     if (fabs(a)>angle)
     {
       angle = fabs(a);
       w = angle;
       if (a<0)
         out_dir = -dir;
       else
         out_dir = dir;
       out_dir *= mag;
       id = i;
     }
   }
 
   return out_dir;
 }
 
 std::vector<mitk::FiberBundle::Pointer> FitFibersToImageFilter::GetTractograms() const
 {
   return m_Tractograms;
 }
 
 void FitFibersToImageFilter::SetTractograms(const std::vector<mitk::FiberBundle::Pointer> &tractograms)
 {
   m_Tractograms = tractograms;
 }
 
 void FitFibersToImageFilter::SetSignalModel(mitk::DiffusionSignalModel<> *SignalModel)
 {
   m_SignalModel = SignalModel;
 }
 
 }
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.h
index bebc380de0..3dc30dca0b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFitFibersToImageFilter.h
@@ -1,312 +1,356 @@
 #ifndef __itkFitFibersToImageFilter_h__
 #define __itkFitFibersToImageFilter_h__
 
 // MITK
 #include <mitkFiberBundle.h>
 #include <itkImageSource.h>
 #include <mitkPeakImage.h>
 #include <vnl/algo/vnl_lbfgsb.h>
 #include <vnl/vnl_sparse_matrix.h>
 #include <vnl/vnl_sparse_matrix_linear_system.h>
 #include <itkImageDuplicator.h>
 #include <itkTimeProbe.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkDiffusionSignalModel.h>
 
 class VnlCostFunction : public vnl_cost_function
 {
 public:
 
+  enum REGU
+  {
+    MSM,
+    MSE,
+    Local_MSE,
+    NONE
+  };
+
   vnl_sparse_matrix_linear_system< double >* S;
   vnl_sparse_matrix< double > m_A;
   vnl_sparse_matrix< double > m_A_Ones; // matrix indicating active weights with 1
   vnl_vector< double > m_b;
   double m_Lambda;  // regularization factor
 
   vnl_vector<double> row_sums;  // number of active weights per row
   vnl_vector<double> local_weight_means;  // mean weight of each row
+  REGU regularization;
 
-  void SetProblem(vnl_sparse_matrix< double >& A, vnl_vector<double>& b, double lambda)
+  void SetProblem(vnl_sparse_matrix< double >& A, vnl_vector<double>& b, double lambda, REGU regu)
   {
     S = new vnl_sparse_matrix_linear_system<double>(A, b);
     m_A = A;
     m_b = b;
     m_Lambda = lambda;
 
     m_A_Ones.set_size(m_A.rows(), m_A.cols());
     m_A.reset();
     while (m_A.next())
       m_A_Ones.put(m_A.getrow(), m_A.getcolumn(), 1);
 
     unsigned int N = m_b.size();
     vnl_vector<double> ones; ones.set_size(dim); ones.fill(1.0);
     row_sums.set_size(N);
     m_A_Ones.mult(ones, row_sums);
     local_weight_means.set_size(N);
+    regularization = regu;
   }
 
   VnlCostFunction(const int NumVars=0) : vnl_cost_function(NumVars)
   {
   }
 
+  // Regularization: mean squared deaviation of weights from mean weight (enforce uniform weights)
   void regu_MSE(vnl_vector<double> const &x, double& cost)
   {
     double mean = x.mean();
     vnl_vector<double> tx = x-mean;
-    cost += m_Lambda*1e8*tx.squared_magnitude()/x.size();
+    cost += 10000.0*m_Lambda*tx.squared_magnitude()/dim;
   }
 
+  // Regularization: mean squared magnitude of weight vectors (small weights) L2
   void regu_MSM(vnl_vector<double> const &x, double& cost)
   {
-    cost += m_Lambda*1e8*x.squared_magnitude()/x.size();
+    cost += 10000.0*m_Lambda*x.squared_magnitude()/dim;
   }
 
+  // Regularization: voxel-weise mean squared deaviation of weights from voxel-wise mean weight (enforce locally uniform weights)
   void regu_localMSE(vnl_vector<double> const &x, double& cost)
   {
     m_A_Ones.mult(x, local_weight_means);
     local_weight_means = element_quotient(local_weight_means, row_sums);
 
     m_A_Ones.reset();
     double regu = 0;
     while (m_A_Ones.next())
     {
       double d = 0;
       if (x[m_A_Ones.getcolumn()]>local_weight_means[m_A_Ones.getrow()])
         d = std::exp(x[m_A_Ones.getcolumn()]) - std::exp(local_weight_means[m_A_Ones.getrow()]);
       else
         d = x[m_A_Ones.getcolumn()] - local_weight_means[m_A_Ones.getrow()];
       regu += d*d;
     }
     cost += m_Lambda*regu/dim;
   }
 
+  // gradients of regularization functions
+
   void grad_regu_MSE(vnl_vector<double> const &x, vnl_vector<double> &dx)
   {
     double mean = x.mean();
-    vnl_vector<double> tx = x-mean;
-
-    vnl_vector<double> tx2(dim, 0.0);
-    vnl_vector<double> h(dim, 1.0);
-    for (int c=0; c<dim; c++)
-    {
-      h[c] = dim-1;
-      tx2[c] += dot_product(h,tx);
-      h[c] = 1;
-    }
-    dx += tx2*m_Lambda*1e8*2.0/(dim*dim);
-
+    vnl_vector<double> tx = x-mean; // difference to mean
+    dx += 10000.0*tx*(2.0-2.0/dim)/dim;
   }
 
   void grad_regu_MSM(vnl_vector<double> const &x, vnl_vector<double> &dx)
   {
-    dx += m_Lambda*1e8*2.0*x/dim;
+    dx += 10000.0*m_Lambda*2.0*x/dim;
+  }
+
+  void grad_regu_L1(vnl_vector<double> const &x, vnl_vector<double> &dx)
+  {
+    for (int i=0; i<dim; ++i)
+      if (x[i]>0)
+        dx[i] += 10000.0*m_Lambda/dim;
   }
 
   void grad_regu_localMSE(vnl_vector<double> const &x, vnl_vector<double> &dx)
   {
     m_A_Ones.mult(x, local_weight_means);
     local_weight_means = element_quotient(local_weight_means, row_sums);
 
     vnl_vector<double> exp_x = x.apply(std::exp);
     vnl_vector<double> exp_means = local_weight_means.apply(std::exp);
 
     vnl_vector<double> tdx(dim, 0);
     m_A_Ones.reset();
     while (m_A_Ones.next())
     {
       int c = m_A_Ones.getcolumn();
       int r = m_A_Ones.getrow();
 
       if (x[c]>local_weight_means[r])
         tdx[c] += exp_x[c] * ( exp_x[c] - exp_means[r] );
       else
         tdx[c] += x[c] - local_weight_means[r];
     }
     dx += tdx*2.0*m_Lambda/dim;
   }
 
+  void calc_regularization(vnl_vector<double> const &x, double& cost)
+  {
+    if (regularization==Local_MSE)
+      regu_localMSE(x, cost);
+    else if (regularization==MSE)
+      regu_MSE(x, cost);
+    else if (regularization==MSM)
+      regu_MSM(x, cost);
+  }
 
+  void calc_regularization_gradient(vnl_vector<double> const &x, vnl_vector<double> &dx)
+  {
+    if (regularization==Local_MSE)
+      grad_regu_localMSE(x,dx);
+    else if (regularization==MSE)
+      grad_regu_MSE(x,dx);
+    else if (regularization==MSM)
+      grad_regu_MSM(x,dx);
+  }
+
+  // cost function
   double f(vnl_vector<double> const &x)
   {
+    // RMS error
     double cost = S->get_rms_error(x);
     cost *= cost;
 
-    regu_localMSE(x, cost);
+    // regularize
+    calc_regularization(x, cost);
 
     return cost;
   }
 
+  // gradient of cost function
   void gradf(vnl_vector<double> const &x, vnl_vector<double> &dx)
   {
     dx.fill(0.0);
     unsigned int N = m_b.size();
 
+    // calculate output difference d
     vnl_vector<double> d; d.set_size(N);
     S->multiply(x,d);
     d -= m_b;
 
     S->transpose_multiply(d, dx);
     dx *= 2.0/N;
 
-    grad_regu_localMSE(x,dx);
+    if (regularization==Local_MSE)
+      grad_regu_localMSE(x,dx);
+    else if (regularization==MSE)
+      grad_regu_MSE(x,dx);
+    else if (regularization==MSM)
+      grad_regu_MSM(x,dx);
   }
 };
 
 namespace itk{
 
 /**
-* \brief Fits the tractogram to the input peak image by assigning a weight to each fiber (similar to https://doi.org/10.1016/j.neuroimage.2015.06.092).  */
+* \brief Fits the tractogram to the input image by assigning a weight to each fiber (similar to https://doi.org/10.1016/j.neuroimage.2015.06.092).  */
 
 
 class FitFibersToImageFilter : public ImageSource< mitk::PeakImage::ItkPeakImageType >
 {
 
 public:
 
   typedef FitFibersToImageFilter Self;
   typedef ProcessObject Superclass;
   typedef SmartPointer< Self > Pointer;
   typedef SmartPointer< const Self > ConstPointer;
 
   typedef itk::Point<float, 3> PointType3;
   typedef itk::Point<float, 4> PointType4;
   typedef mitk::DiffusionPropertyHelper::ImageType  VectorImgType;
   typedef mitk::PeakImage::ItkPeakImageType         PeakImgType;
   typedef itk::Image<unsigned char, 3>              UcharImgType;
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( FitFibersToImageFilter, ImageSource )
 
   itkSetMacro( PeakImage, PeakImgType::Pointer)
   itkGetMacro( PeakImage, PeakImgType::Pointer)
   itkSetMacro( DiffImage, VectorImgType::Pointer)
   itkGetMacro( DiffImage, VectorImgType::Pointer)
   itkSetMacro( MaskImage, UcharImgType::Pointer)
   itkGetMacro( MaskImage, UcharImgType::Pointer)
   itkSetMacro( FitIndividualFibers, bool)
   itkGetMacro( FitIndividualFibers, bool)
   itkSetMacro( GradientTolerance, double)
   itkGetMacro( GradientTolerance, double)
   itkSetMacro( Lambda, double)
   itkGetMacro( Lambda, double)
   itkSetMacro( MaxIterations, int)
   itkGetMacro( MaxIterations, int)
   itkSetMacro( FiberSampling, float)
   itkGetMacro( FiberSampling, float)
   itkSetMacro( FilterOutliers, bool)
   itkGetMacro( FilterOutliers, bool)
   itkSetMacro( Verbose, bool)
   itkGetMacro( Verbose, bool)
   itkSetMacro( DeepCopy, bool)
   itkGetMacro( DeepCopy, bool)
   itkSetMacro( ResampleFibers, bool)
   itkGetMacro( ResampleFibers, bool)
 
   itkGetMacro( Weights, vnl_vector<double>)
   itkGetMacro( RmsDiffPerBundle, vnl_vector<double>)
-  itkGetMacro( RmsDiffPerFiber, vnl_vector<double>)
 
   itkGetMacro( FittedImage, PeakImgType::Pointer)
   itkGetMacro( ResidualImage, PeakImgType::Pointer)
   itkGetMacro( OverexplainedImage, PeakImgType::Pointer)
   itkGetMacro( UnderexplainedImage, PeakImgType::Pointer)
 
   itkGetMacro( FittedImageDiff, VectorImgType::Pointer)
   itkGetMacro( ResidualImageDiff, VectorImgType::Pointer)
   itkGetMacro( OverexplainedImageDiff, VectorImgType::Pointer)
   itkGetMacro( UnderexplainedImageDiff, VectorImgType::Pointer)
 
   itkGetMacro( Coverage, double)
   itkGetMacro( Overshoot, double)
   itkGetMacro( RMSE, double)
   itkGetMacro( MeanWeight, double)
   itkGetMacro( MedianWeight, double)
   itkGetMacro( MinWeight, double)
   itkGetMacro( MaxWeight, double)
   itkGetMacro( NumUnknowns, unsigned int)
   itkGetMacro( NumResiduals, unsigned int)
   itkGetMacro( NumCoveredDirections, unsigned int)
 
   void SetTractograms(const std::vector<mitk::FiberBundle::Pointer> &tractograms);
 
   void GenerateData() override;
 
   std::vector<mitk::FiberBundle::Pointer> GetTractograms() const;
 
   void SetSignalModel(mitk::DiffusionSignalModel<> *SignalModel);
 
+  VnlCostFunction::REGU GetRegularization() const;
+  void SetRegularization(const VnlCostFunction::REGU &GetRegularization);
+
 protected:
 
   FitFibersToImageFilter();
   virtual ~FitFibersToImageFilter();
 
   vnl_vector_fixed<float,3> GetClosestPeak(itk::Index<4> idx, PeakImgType::Pointer m_PeakImage , vnl_vector_fixed<float,3> fiber_dir, int& id, double& w );
 
   void CreatePeakSystem();
   void CreateDiffSystem();
 
   void GenerateOutputPeakImages();
   void GenerateOutputDiffImages();
 
   std::vector< mitk::FiberBundle::Pointer >   m_Tractograms;
   PeakImgType::Pointer                        m_PeakImage;
   VectorImgType::Pointer                      m_DiffImage;
   UcharImgType::Pointer                       m_MaskImage;
   bool                                        m_FitIndividualFibers;
   double                                      m_GradientTolerance;
   double                                      m_Lambda;
   int                                         m_MaxIterations;
   float                                       m_FiberSampling;
   double                                      m_Coverage;
   double                                      m_Overshoot;
   double                                      m_RMSE;
   bool                                        m_FilterOutliers;
   double                                      m_MeanWeight;
   double                                      m_MedianWeight;
   double                                      m_MinWeight;
   double                                      m_MaxWeight;
   bool                                        m_Verbose;
   bool                                        m_DeepCopy;
   bool                                        m_ResampleFibers;
   unsigned int                                m_NumUnknowns;
   unsigned int                                m_NumResiduals;
   unsigned int                                m_NumCoveredDirections;
 
   // output
   vnl_vector<double>                          m_RmsDiffPerBundle;
   vnl_vector<double>                          m_Weights;
-  vnl_vector<double>                          m_RmsDiffPerFiber;
 
   PeakImgType::Pointer                        m_UnderexplainedImage;
   PeakImgType::Pointer                        m_OverexplainedImage;
   PeakImgType::Pointer                        m_ResidualImage;
   PeakImgType::Pointer                        m_FittedImage;
 
   VectorImgType::Pointer                      m_UnderexplainedImageDiff;
   VectorImgType::Pointer                      m_OverexplainedImageDiff;
   VectorImgType::Pointer                      m_ResidualImageDiff;
   VectorImgType::Pointer                      m_FittedImageDiff;
 
   mitk::DiffusionSignalModel<>*               m_SignalModel;
 
   vnl_sparse_matrix<double>                   A;
   vnl_vector<double>                          b;
   VnlCostFunction                             cost;
   int                                         sz_x;
   int                                         sz_y;
   int                                         sz_z;
   int                                         dim_four_size;
-  double                                      TD;
-  double                                      FD;
+  double                                      m_MeanTractDensity;
+  double                                      m_MeanSignal;
   unsigned int                                fiber_count;
+
+  VnlCostFunction::REGU                       m_Regularization;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkFitFibersToImageFilter.cpp"
 #endif
 
 #endif // __itkFitFibersToImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
index ece114f169..1e5c3dd017 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
@@ -1,1094 +1,906 @@
 /*===================================================================
 
 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 <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <omp.h>
 #include "itkStreamlineTrackingFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageFileWriter.h>
 #include "itkPointShell.h"
 #include <itkRescaleIntensityImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <TrackingHandlers/mitkTrackingHandlerRandomForest.h>
+#include <mitkDiffusionFunctionCollection.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
 
 StreamlineTrackingFilter
 ::StreamlineTrackingFilter()
   : m_PauseTracking(false)
   , m_AbortTracking(false)
   , m_BuildFibersFinished(false)
   , m_BuildFibersReady(0)
   , m_FiberPolyData(nullptr)
   , m_Points(nullptr)
   , m_Cells(nullptr)
   , m_StoppingRegions(nullptr)
   , m_TargetRegions(nullptr)
   , m_SeedImage(nullptr)
   , m_MaskImage(nullptr)
-  , m_TissueImage(nullptr)
   , m_OutputProbabilityMap(nullptr)
   , m_AngularThresholdDeg(-1)
   , m_StepSizeVox(-1)
   , m_SamplingDistanceVox(-1)
   , m_AngularThreshold(-1)
   , m_StepSize(0)
   , m_MaxLength(10000)
   , m_MinTractLength(20.0)
   , m_MaxTractLength(400.0)
   , m_SeedsPerVoxel(1)
   , m_AvoidStop(true)
   , m_RandomSampling(false)
   , m_SamplingDistance(-1)
   , m_DeflectionMod(1.0)
   , m_OnlyForwardSamples(true)
   , m_UseStopVotes(true)
   , m_NumberOfSamples(30)
   , m_NumPreviousDirections(1)
-  , m_WmLabel(3) // mrtrix 5ttseg labels
-  , m_GmLabel(1) // mrtrix 5ttseg labels
-  , m_SeedOnlyGm(false)
-  , m_ControlGmEndings(false)
   , m_MaxNumTracts(-1)
   , m_Verbose(true)
   , m_AposterioriCurvCheck(false)
   , m_DemoMode(false)
   , m_Random(true)
   , m_UseOutputProbabilityMap(false)
   , m_CurrentTracts(0)
   , m_Progress(0)
   , m_StopTracking(false)
-  , m_InterpolateMask(false)
+  , m_InterpolateMask(true)
 {
   this->SetNumberOfRequiredInputs(0);
 }
 
 std::string StreamlineTrackingFilter::GetStatusText()
 {
   std::string status = "Seedpoints processed: " + boost::lexical_cast<std::string>(m_Progress) + "/" + boost::lexical_cast<std::string>(m_SeedPoints.size());
   if (m_SeedPoints.size()>0)
     status += " (" + boost::lexical_cast<std::string>(100*m_Progress/m_SeedPoints.size()) + "%)";
   if (m_MaxNumTracts>0)
     status += "\nFibers accepted: " + boost::lexical_cast<std::string>(m_CurrentTracts) + "/" + boost::lexical_cast<std::string>(m_MaxNumTracts);
   else
     status += "\nFibers accepted: " + boost::lexical_cast<std::string>(m_CurrentTracts);
 
   return status;
 }
 
 void StreamlineTrackingFilter::BeforeTracking()
 {
   m_StopTracking = false;
   m_TrackingHandler->SetRandom(m_Random);
   m_TrackingHandler->InitForTracking();
   m_FiberPolyData = PolyDataType::New();
   m_Points = vtkSmartPointer< vtkPoints >::New();
   m_Cells = vtkSmartPointer< vtkCellArray >::New();
 
   itk::Vector< double, 3 > imageSpacing = m_TrackingHandler->GetSpacing();
 
   float minSpacing;
   if(imageSpacing[0]<imageSpacing[1] && imageSpacing[0]<imageSpacing[2])
     minSpacing = imageSpacing[0];
   else if (imageSpacing[1] < imageSpacing[2])
     minSpacing = imageSpacing[1];
   else
     minSpacing = imageSpacing[2];
 
   if (m_StepSizeVox<mitk::eps)
     m_StepSize = 0.5*minSpacing;
   else
     m_StepSize = m_StepSizeVox*minSpacing;
 
   if (m_AngularThresholdDeg<0)
   {
     if  (m_StepSize/minSpacing<=1.0)
       m_AngularThreshold = std::cos( 0.5 * M_PI * m_StepSize/minSpacing );
     else
       m_AngularThreshold = std::cos( 0.5 * M_PI );
   }
   else
     m_AngularThreshold = std::cos( m_AngularThresholdDeg*M_PI/180.0 );
   m_TrackingHandler->SetAngularThreshold(m_AngularThreshold);
 
   if (m_SamplingDistanceVox<mitk::eps)
     m_SamplingDistance = minSpacing*0.25;
   else
     m_SamplingDistance = m_SamplingDistanceVox * minSpacing;
 
   m_PolyDataContainer.clear();
   for (unsigned int i=0; i<this->GetNumberOfThreads(); i++)
   {
     PolyDataType poly = PolyDataType::New();
     m_PolyDataContainer.push_back(poly);
   }
 
   if (m_UseOutputProbabilityMap)
   {
     m_OutputProbabilityMap = ItkDoubleImgType::New();
     m_OutputProbabilityMap->SetSpacing(imageSpacing);
     m_OutputProbabilityMap->SetOrigin(m_TrackingHandler->GetOrigin());
     m_OutputProbabilityMap->SetDirection(m_TrackingHandler->GetDirection());
     m_OutputProbabilityMap->SetRegions(m_TrackingHandler->GetLargestPossibleRegion());
     m_OutputProbabilityMap->Allocate();
     m_OutputProbabilityMap->FillBuffer(0);
   }
 
+  m_MaskInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
+  m_StopInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
+  m_SeedInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
+  m_TargetInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
+
   if (m_StoppingRegions.IsNull())
   {
-    m_StoppingRegions = ItkUcharImgType::New();
+    m_StoppingRegions = ItkFloatImgType::New();
     m_StoppingRegions->SetSpacing( imageSpacing );
     m_StoppingRegions->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_StoppingRegions->SetDirection( m_TrackingHandler->GetDirection() );
     m_StoppingRegions->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_StoppingRegions->Allocate();
     m_StoppingRegions->FillBuffer(0);
   }
   else
     std::cout << "StreamlineTracking - Using stopping region image" << std::endl;
+  m_StopInterpolator->SetInputImage(m_StoppingRegions);
 
   if (m_TargetRegions.IsNull())
   {
-    m_TargetRegions = ItkUintImgType::New();
+    m_TargetImageSet = false;
+    m_TargetRegions = ItkFloatImgType::New();
     m_TargetRegions->SetSpacing( imageSpacing );
     m_TargetRegions->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_TargetRegions->SetDirection( m_TrackingHandler->GetDirection() );
     m_TargetRegions->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_TargetRegions->Allocate();
     m_TargetRegions->FillBuffer(1);
   }
   else
+  {
+    m_TargetImageSet = true;
+    m_TargetInterpolator->SetInputImage(m_TargetRegions);
     std::cout << "StreamlineTracking - Using target region image" << std::endl;
+  }
 
   if (m_SeedImage.IsNull())
   {
-    m_SeedImage = ItkUcharImgType::New();
+    m_SeedImageSet = false;
+    m_SeedImage = ItkFloatImgType::New();
     m_SeedImage->SetSpacing( imageSpacing );
     m_SeedImage->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_SeedImage->SetDirection( m_TrackingHandler->GetDirection() );
     m_SeedImage->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_SeedImage->Allocate();
     m_SeedImage->FillBuffer(1);
   }
   else
+  {
+    m_SeedImageSet = true;
     std::cout << "StreamlineTracking - Using seed image" << std::endl;
+  }
+  m_SeedInterpolator->SetInputImage(m_SeedImage);
 
   if (m_MaskImage.IsNull())
   {
     // initialize mask image
-    m_MaskImage = ItkUcharImgType::New();
+    m_MaskImage = ItkFloatImgType::New();
     m_MaskImage->SetSpacing( imageSpacing );
     m_MaskImage->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_MaskImage->SetDirection( m_TrackingHandler->GetDirection() );
     m_MaskImage->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_MaskImage->Allocate();
     m_MaskImage->FillBuffer(1);
   }
   else
     std::cout << "StreamlineTracking - Using mask image" << std::endl;
+  m_MaskInterpolator->SetInputImage(m_MaskImage);
 
   if (m_SeedPoints.empty())
     GetSeedPointsFromSeedImage();
-  else
-    m_SeedOnlyGm = false;
-
-  if (m_TissueImage.IsNull())
-  {
-    if (m_SeedOnlyGm)
-    {
-      MITK_WARN << "StreamlineTracking - Cannot seed in gray matter. No tissue type image set.";
-      m_SeedOnlyGm = false;
-    }
-
-    if (m_ControlGmEndings)
-    {
-      MITK_WARN << "StreamlineTracking - Cannot control gray matter endings. No tissue type image set.";
-      m_ControlGmEndings = false;
-    }
-  }
-  else
-  {
-    if (m_ControlGmEndings)
-      m_SeedOnlyGm = true;
-    if (m_ControlGmEndings || m_SeedOnlyGm)
-      std::cout << "StreamlineTracking - Using tissue image" << std::endl;
-    else
-      MITK_WARN << "StreamlineTracking - Tissue image set but no gray matter seeding or fiber endpoint-control enabled" << std::endl;
-  }
 
   m_BuildFibersReady = 0;
   m_BuildFibersFinished = false;
   m_Tractogram.clear();
   m_SamplingPointset = mitk::PointSet::New();
   m_AlternativePointset = mitk::PointSet::New();
   m_StopVotePointset = mitk::PointSet::New();
   m_StartTime = std::chrono::system_clock::now();
 
-  if (m_SeedOnlyGm && m_ControlGmEndings)
-    InitGrayMatterEndings();
-
   if (m_DemoMode)
     omp_set_num_threads(1);
 
   if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::MODE::DETERMINISTIC)
     std::cout << "StreamlineTracking - Mode: deterministic" << std::endl;
   else if(m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::MODE::PROBABILISTIC)
     std::cout << "StreamlineTracking - Mode: probabilistic" << std::endl;
   else
     std::cout << "StreamlineTracking - Mode: ???" << std::endl;
 
   std::cout << "StreamlineTracking - Angular threshold: " << m_AngularThreshold << " (" << 180*std::acos( m_AngularThreshold )/M_PI << "°)" << std::endl;
   std::cout << "StreamlineTracking - Stepsize: " << m_StepSize << "mm (" << m_StepSize/minSpacing << "*vox)" << std::endl;
   std::cout << "StreamlineTracking - Seeds per voxel: " << m_SeedsPerVoxel << std::endl;
   std::cout << "StreamlineTracking - Max. tract length: " << m_MaxTractLength << "mm" << std::endl;
   std::cout << "StreamlineTracking - Min. tract length: " << m_MinTractLength << "mm" << std::endl;
   std::cout << "StreamlineTracking - Max. num. tracts: " << m_MaxNumTracts << std::endl;
 
   std::cout << "StreamlineTracking - Num. neighborhood samples: " << m_NumberOfSamples << std::endl;
   std::cout << "StreamlineTracking - Max. sampling distance: " << m_SamplingDistance << "mm (" << m_SamplingDistance/minSpacing << "*vox)" << std::endl;
   std::cout << "StreamlineTracking - Deflection modifier: " << m_DeflectionMod << std::endl;
 
   std::cout << "StreamlineTracking - Use stop votes: " << m_UseStopVotes << std::endl;
   std::cout << "StreamlineTracking - Only frontal samples: " << m_OnlyForwardSamples << std::endl;
 
   if (m_DemoMode)
   {
     std::cout << "StreamlineTracking - Running in demo mode";
     std::cout << "StreamlineTracking - Starting streamline tracking using 1 thread" << std::endl;
   }
   else
     std::cout << "StreamlineTracking - Starting streamline tracking using " << omp_get_max_threads() << " threads" << std::endl;
 }
 
-
-void StreamlineTrackingFilter::InitGrayMatterEndings()
-{
-  m_TrackingHandler->SetAngularThreshold(0);
-  m_GmStubs.clear();
-  if (m_TissueImage.IsNotNull())
-  {
-    std::cout << "StreamlineTracking - initializing GM endings" << std::endl;
-    ImageRegionConstIterator< ItkUcharImgType > it(m_TissueImage, m_TissueImage->GetLargestPossibleRegion() );
-    it.GoToBegin();
-
-    vnl_vector_fixed<float,3> d1; d1.fill(0.0);
-    std::deque< vnl_vector_fixed<float,3> > olddirs;
-    while (olddirs.size()<m_NumPreviousDirections)
-      olddirs.push_back(d1);
-
-    while( !it.IsAtEnd() )
-    {
-      if (it.Value()==m_GmLabel)
-      {
-        ItkUcharImgType::IndexType s_idx = it.GetIndex();
-        itk::ContinuousIndex<float, 3> start;
-        m_TissueImage->TransformIndexToPhysicalPoint(s_idx, start);
-        itk::Point<float, 3> wm_p;
-        float max = -1;
-        FiberType fib;
-
-        for (int x : {-1,0,1})
-          for (int y : {-1,0,1})
-            for (int z : {-1,0,1})
-            {
-              if (x==y && y==z)
-                continue;
-
-              ItkUcharImgType::IndexType e_idx;
-              e_idx[0] = s_idx[0] + x;
-              e_idx[1] = s_idx[1] + y;
-              e_idx[2] = s_idx[2] + z;
-
-              if ( !m_TissueImage->GetLargestPossibleRegion().IsInside(e_idx) || m_TissueImage->GetPixel(e_idx)!=m_WmLabel )
-                continue;
-
-              itk::ContinuousIndex<float, 3> end;
-              m_TissueImage->TransformIndexToPhysicalPoint(e_idx, end);
-
-              d1 = m_TrackingHandler->ProposeDirection(end, olddirs, s_idx);
-              if (d1.magnitude()<0.0001)
-                continue;
-              d1.normalize();
-
-              vnl_vector_fixed< float, 3 > d2;
-              d2[0] = end[0] - start[0];
-              d2[1] = end[1] - start[1];
-              d2[2] = end[2] - start[2];
-              d2.normalize();
-              float a = fabs(dot_product(d1,d2));
-              if (a>max)
-              {
-                max = a;
-                wm_p = end;
-              }
-            }
-
-        if (max>=0)
-        {
-          fib.push_back(start);
-          fib.push_back(wm_p);
-          m_GmStubs.push_back(fib);
-        }
-      }
-      ++it;
-    }
-  }
-  m_TrackingHandler->SetAngularThreshold(m_AngularThreshold);
-}
-
-
 void StreamlineTrackingFilter::CalculateNewPosition(itk::Point<float, 3>& pos, vnl_vector_fixed<float, 3>& dir)
 {
   pos[0] += dir[0]*m_StepSize;
   pos[1] += dir[1]*m_StepSize;
   pos[2] += dir[2]*m_StepSize;
 }
 
-
-bool StreamlineTrackingFilter
-::IsInsideMask(const itk::Point<float, 3> &pos, ItkUcharImgType::Pointer mask)
-{
-  return m_TrackingHandler->IsInsideMask(pos, mask, m_InterpolateMask);
-}
-
-bool StreamlineTrackingFilter
-::IsInGm(const itk::Point<float, 3> &pos)
-{
-  if (m_TissueImage.IsNull())
-    return true;
-
-  ItkUcharImgType::IndexType idx;
-  m_TissueImage->TransformPhysicalPointToIndex(pos, idx);
-  if (m_TissueImage->GetLargestPossibleRegion().IsInside(idx) && m_TissueImage->GetPixel(idx) == m_GmLabel)
-    return true;
-
-  return false;
-}
-
 std::vector< vnl_vector_fixed<float,3> > StreamlineTrackingFilter::CreateDirections(int NPoints)
 {
   std::vector< vnl_vector_fixed<float,3> > pointshell;
 
   if (NPoints<2)
     return pointshell;
 
   std::vector< float > theta; theta.resize(NPoints);
 
   std::vector< float > phi; phi.resize(NPoints);
 
   float C = sqrt(4*M_PI);
 
   phi[0] = 0.0;
   phi[NPoints-1] = 0.0;
 
   for(int i=0; i<NPoints; i++)
   {
     theta[i] = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
     if( i>0 && i<NPoints-1)
     {
       phi[i] = (phi[i-1] + C / sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
       // % (2*DIST_POINTSHELL_PI);
     }
   }
 
 
   for(int i=0; i<NPoints; i++)
   {
     vnl_vector_fixed<float,3> d;
     d[0] = cos(theta[i]) * cos(phi[i]);
     d[1] = cos(theta[i]) * sin(phi[i]);
     d[2] = sin(theta[i]);
     pointshell.push_back(d);
   }
 
   return pointshell;
 }
 
 
 vnl_vector_fixed<float,3> StreamlineTrackingFilter::GetNewDirection(itk::Point<float, 3> &pos, std::deque<vnl_vector_fixed<float, 3> >& olddirs, itk::Index<3> &oldIndex)
 {
   if (m_DemoMode)
   {
     m_SamplingPointset->Clear();
     m_AlternativePointset->Clear();
     m_StopVotePointset->Clear();
   }
   vnl_vector_fixed<float,3> direction; direction.fill(0);
 
-  if (IsInsideMask(pos, m_MaskImage) && !IsInsideMask(pos, m_StoppingRegions))
+  if (mitk::imv::IsInsideMask<float>(pos, m_InterpolateMask, m_MaskInterpolator) && !mitk::imv::IsInsideMask<float>(pos, m_InterpolateMask, m_StopInterpolator))
     direction = m_TrackingHandler->ProposeDirection(pos, olddirs, oldIndex); // get direction proposal at current streamline position
   else
     return direction;
 
   vnl_vector_fixed<float,3> olddir = olddirs.back();
   std::vector< vnl_vector_fixed<float,3> > probeVecs = CreateDirections(m_NumberOfSamples);
   itk::Point<float, 3> sample_pos;
   int alternatives = 1;
   int stop_votes = 0;
   int possible_stop_votes = 0;
   for (unsigned int i=0; i<probeVecs.size(); i++)
   {
     vnl_vector_fixed<float,3> d;
     bool is_stop_voter = false;
     if (m_Random && m_RandomSampling)
     {
       d[0] = m_TrackingHandler->GetRandDouble(-0.5, 0.5);
       d[1] = m_TrackingHandler->GetRandDouble(-0.5, 0.5);
       d[2] = m_TrackingHandler->GetRandDouble(-0.5, 0.5);
       d.normalize();
       d *= m_TrackingHandler->GetRandDouble(0,m_SamplingDistance);
     }
     else
     {
       d = probeVecs.at(i);
       float dot = dot_product(d, olddir);
       if (m_UseStopVotes && dot>0.7)
       {
         is_stop_voter = true;
         possible_stop_votes++;
       }
       else if (m_OnlyForwardSamples && dot<0)
         continue;
       d *= m_SamplingDistance;
     }
 
     sample_pos[0] = pos[0] + d[0];
     sample_pos[1] = pos[1] + d[1];
     sample_pos[2] = pos[2] + d[2];
 
     vnl_vector_fixed<float,3> tempDir; tempDir.fill(0.0);
-    if (IsInsideMask(sample_pos, m_MaskImage))
+    if (mitk::imv::IsInsideMask<float>(sample_pos, m_InterpolateMask, m_MaskInterpolator))
       tempDir = m_TrackingHandler->ProposeDirection(sample_pos, olddirs, oldIndex); // sample neighborhood
     if (tempDir.magnitude()>mitk::eps)
     {
       direction += tempDir;
 
       if(m_DemoMode)
         m_SamplingPointset->InsertPoint(i, sample_pos);
     }
     else if (m_AvoidStop && olddir.magnitude()>0.5) // out of white matter
     {
       if (is_stop_voter)
         stop_votes++;
       if (m_DemoMode)
         m_StopVotePointset->InsertPoint(i, sample_pos);
 
       float dot = dot_product(d, olddir);
       if (dot >= 0.0) // in front of plane defined by pos and olddir
         d = -d + 2*dot*olddir; // reflect
       else
         d = -d; // invert
 
       // look a bit further into the other direction
       sample_pos[0] = pos[0] + d[0];
       sample_pos[1] = pos[1] + d[1];
       sample_pos[2] = pos[2] + d[2];
       alternatives++;
       vnl_vector_fixed<float,3> tempDir; tempDir.fill(0.0);
-      if (IsInsideMask(sample_pos, m_MaskImage))
+      if (mitk::imv::IsInsideMask<float>(sample_pos, m_InterpolateMask, m_MaskInterpolator))
         tempDir = m_TrackingHandler->ProposeDirection(sample_pos, olddirs, oldIndex); // sample neighborhood
 
       if (tempDir.magnitude()>mitk::eps)  // are we back in the white matter?
       {
         direction += d * m_DeflectionMod;         // go into the direction of the white matter
         direction += tempDir;  // go into the direction of the white matter direction at this location
 
         if(m_DemoMode)
           m_AlternativePointset->InsertPoint(alternatives, sample_pos);
       }
       else
       {
         if (m_DemoMode)
           m_StopVotePointset->InsertPoint(i, sample_pos);
       }
     }
     else
     {
       if (m_DemoMode)
         m_StopVotePointset->InsertPoint(i, sample_pos);
 
       if (is_stop_voter)
         stop_votes++;
     }
   }
 
   if (direction.magnitude()>0.001 && (possible_stop_votes==0 || (float)stop_votes/possible_stop_votes<0.5) )
     direction.normalize();
   else
     direction.fill(0);
 
   return direction;
 }
 
 
 float StreamlineTrackingFilter::FollowStreamline(itk::Point<float, 3> pos, vnl_vector_fixed<float,3> dir, FiberType* fib, float tractLength, bool front)
 {
   vnl_vector_fixed<float,3> zero_dir; zero_dir.fill(0.0);
   std::deque< vnl_vector_fixed<float,3> > last_dirs;
   for (unsigned int i=0; i<m_NumPreviousDirections-1; i++)
     last_dirs.push_back(zero_dir);
 
   for (int step=0; step< m_MaxLength/2; step++)
   {
     itk::Index<3> oldIndex;
     m_TrackingHandler->WorldToIndex(pos, oldIndex);
 
     // get new position
     CalculateNewPosition(pos, dir);
 
     // is new position inside of image and mask
     if (m_AbortTracking)   // if not end streamline
     {
       return tractLength;
     }
     else    // if yes, add new point to streamline
     {
       tractLength +=  m_StepSize;
       if (front)
         fib->push_front(pos);
       else
         fib->push_back(pos);
 
       if (m_AposterioriCurvCheck)
       {
         int curv = CheckCurvature(fib, front);
         if (curv>0)
         {
           tractLength -= m_StepSize*curv;
           while (curv>0)
           {
             if (front)
               fib->pop_front();
             else
               fib->pop_back();
             curv--;
           }
           return tractLength;
         }
       }
 
       if (tractLength>m_MaxTractLength)
         return tractLength;
     }
 
     if (m_DemoMode && !m_UseOutputProbabilityMap) // CHECK: warum sind die samplingpunkte der streamline in der visualisierung immer einen schritt voras?
     {
 #pragma omp critical
       {
         m_BuildFibersReady++;
         m_Tractogram.push_back(*fib);
         BuildFibers(true);
         m_Stop = true;
 
         while (m_Stop){
         }
       }
     }
 
     dir.normalize();
     last_dirs.push_back(dir);
     if (last_dirs.size()>m_NumPreviousDirections)
       last_dirs.pop_front();
     dir = GetNewDirection(pos, last_dirs, oldIndex);
 
     while (m_PauseTracking){}
 
     if (dir.magnitude()<0.0001)
       return tractLength;
   }
   return tractLength;
 }
 
 
 int StreamlineTrackingFilter::CheckCurvature(FiberType* fib, bool front)
 {
   float m_Distance = 5;
   if (fib->size()<3)
     return 0;
 
   float dist = 0;
   std::vector< vnl_vector_fixed< float, 3 > > vectors;
   vnl_vector_fixed< float, 3 > meanV; meanV.fill(0);
   float dev = 0;
 
   if (front)
   {
     int c=0;
     while(dist<m_Distance && c<(int)fib->size()-1)
     {
       itk::Point<float> p1 = fib->at(c);
       itk::Point<float> p2 = fib->at(c+1);
 
       vnl_vector_fixed< float, 3 > v;
       v[0] = p2[0]-p1[0];
       v[1] = p2[1]-p1[1];
       v[2] = p2[2]-p1[2];
       dist += v.magnitude();
       v.normalize();
       vectors.push_back(v);
       if (c==0)
         meanV += v;
       c++;
     }
   }
   else
   {
     int c=fib->size()-1;
     while(dist<m_Distance && c>0)
     {
       itk::Point<float> p1 = fib->at(c);
       itk::Point<float> p2 = fib->at(c-1);
 
       vnl_vector_fixed< float, 3 > v;
       v[0] = p2[0]-p1[0];
       v[1] = p2[1]-p1[1];
       v[2] = p2[2]-p1[2];
       dist += v.magnitude();
       v.normalize();
       vectors.push_back(v);
       if (c==(int)fib->size()-1)
         meanV += v;
       c--;
     }
   }
   meanV.normalize();
 
   for (unsigned int c=0; c<vectors.size(); c++)
   {
     float angle = dot_product(meanV, vectors.at(c));
     if (angle>1.0)
       angle = 1.0;
     if (angle<-1.0)
       angle = -1.0;
     dev += acos(angle)*180/M_PI;
   }
   if (vectors.size()>0)
     dev /= vectors.size();
 
   if (dev<30)
     return 0;
   else
     return vectors.size();
 }
 
 void StreamlineTrackingFilter::GetSeedPointsFromSeedImage()
 {
   MITK_INFO << "StreamlineTracking - Calculating seed points.";
   m_SeedPoints.clear();
 
-  if (!m_ControlGmEndings)
-  {
-    typedef ImageRegionConstIterator< ItkUcharImgType >     MaskIteratorType;
-    MaskIteratorType    sit(m_SeedImage, m_SeedImage->GetLargestPossibleRegion());
-    sit.GoToBegin();
+  typedef ImageRegionConstIterator< ItkFloatImgType >     MaskIteratorType;
+  MaskIteratorType    sit(m_SeedImage, m_SeedImage->GetLargestPossibleRegion());
+  sit.GoToBegin();
 
-    while (!sit.IsAtEnd())
+  while (!sit.IsAtEnd())
+  {
+    if (sit.Value()>0)
     {
-      if (sit.Value()>0)
+      ItkFloatImgType::IndexType index = sit.GetIndex();
+      itk::ContinuousIndex<float, 3> start;
+      start[0] = index[0];
+      start[1] = index[1];
+      start[2] = index[2];
+      itk::Point<float> worldPos;
+      m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
+
+      if ( mitk::imv::IsInsideMask<float>(worldPos, m_InterpolateMask, m_MaskInterpolator) )
       {
-        ItkUcharImgType::IndexType index = sit.GetIndex();
-        itk::ContinuousIndex<float, 3> start;
-        start[0] = index[0];
-        start[1] = index[1];
-        start[2] = index[2];
-        itk::Point<float> worldPos;
-        m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
-
-        if (IsInsideMask(worldPos, m_MaskImage) && (!m_SeedOnlyGm || IsInGm(worldPos)))
+        m_SeedPoints.push_back(worldPos);
+        for (int s = 1; s < m_SeedsPerVoxel; s++)
         {
-          m_SeedPoints.push_back(worldPos);
-          for (int s = 1; s < m_SeedsPerVoxel; s++)
-          {
-            start[0] = index[0] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
-            start[1] = index[1] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
-            start[2] = index[2] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
+          start[0] = index[0] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
+          start[1] = index[1] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
+          start[2] = index[2] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
 
-            itk::Point<float> worldPos;
-            m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
-            m_SeedPoints.push_back(worldPos);
-          }
+          itk::Point<float> worldPos;
+          m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
+          m_SeedPoints.push_back(worldPos);
         }
       }
-      ++sit;
     }
-  }
-  else
-  {
-    for (auto s : m_GmStubs)
-      m_SeedPoints.push_back(s[1]);
+    ++sit;
   }
 }
 
 void StreamlineTrackingFilter::GenerateData()
 {
   this->BeforeTracking();
   if (m_Random)
     std::random_shuffle(m_SeedPoints.begin(), m_SeedPoints.end());
 
   m_CurrentTracts = 0;
   int num_seeds = m_SeedPoints.size();
   itk::Index<3> zeroIndex; zeroIndex.Fill(0);
   m_Progress = 0;
   int i = 0;
   int print_interval = num_seeds/100;
   if (print_interval<100)
     m_Verbose=false;
 
 #pragma omp parallel
   while (i<num_seeds && !m_StopTracking)
   {
 
 
     int temp_i = 0;
 #pragma omp critical
     {
       temp_i = i;
       i++;
     }
 
     if (temp_i>=num_seeds || m_StopTracking)
       continue;
     else if (m_Verbose && i%print_interval==0)
 #pragma omp critical
     {
       m_Progress += print_interval;
       std::cout << "                                                                                                     \r";
       if (m_MaxNumTracts>0)
         std::cout << "Tried: " << m_Progress << "/" << num_seeds << " | Accepted: " << m_CurrentTracts << "/" << m_MaxNumTracts << '\r';
       else
         std::cout << "Tried: " << m_Progress << "/" << num_seeds << " | Accepted: " << m_CurrentTracts << '\r';
       cout.flush();
     }
 
     const itk::Point<float> worldPos = m_SeedPoints.at(temp_i);
     FiberType fib;
     float tractLength = 0;
     unsigned int counter = 0;
 
     // get starting direction
     vnl_vector_fixed<float,3> dir; dir.fill(0.0);
     std::deque< vnl_vector_fixed<float,3> > olddirs;
     while (olddirs.size()<m_NumPreviousDirections)
       olddirs.push_back(dir); // start without old directions (only zero directions)
 
-    vnl_vector_fixed< float, 3 > gm_start_dir;
-    if (m_ControlGmEndings)
-    {
-      gm_start_dir[0] = m_GmStubs[temp_i][1][0] - m_GmStubs[temp_i][0][0];
-      gm_start_dir[1] = m_GmStubs[temp_i][1][1] - m_GmStubs[temp_i][0][1];
-      gm_start_dir[2] = m_GmStubs[temp_i][1][2] - m_GmStubs[temp_i][0][2];
-      gm_start_dir.normalize();
-      olddirs.pop_back();
-      olddirs.push_back(gm_start_dir);
-    }
-
-    if (IsInsideMask(worldPos, m_MaskImage))
+    /// START DIR
+    //    vnl_vector_fixed< float, 3 > gm_start_dir;
+    //    if (m_ControlGmEndings)
+    //    {
+    //      gm_start_dir[0] = m_GmStubs[temp_i][1][0] - m_GmStubs[temp_i][0][0];
+    //      gm_start_dir[1] = m_GmStubs[temp_i][1][1] - m_GmStubs[temp_i][0][1];
+    //      gm_start_dir[2] = m_GmStubs[temp_i][1][2] - m_GmStubs[temp_i][0][2];
+    //      gm_start_dir.normalize();
+    //      olddirs.pop_back();
+    //      olddirs.push_back(gm_start_dir);
+    //    }
+
+    if (mitk::imv::IsInsideMask<float>(worldPos, m_InterpolateMask, m_MaskInterpolator))
       dir = m_TrackingHandler->ProposeDirection(worldPos, olddirs, zeroIndex);
 
     if (dir.magnitude()>0.0001)
     {
-      if (m_ControlGmEndings)
-      {
-        float a = dot_product(gm_start_dir, dir);
-        if (a<0)
-          dir = -dir;
-      }
+      /// START DIR
+      //      if (m_ControlGmEndings)
+      //      {
+      //        float a = dot_product(gm_start_dir, dir);
+      //        if (a<0)
+      //          dir = -dir;
+      //      }
 
       // forward tracking
       tractLength = FollowStreamline(worldPos, dir, &fib, 0, false);
       fib.push_front(worldPos);
 
-      if (m_ControlGmEndings)
-      {
-        fib.push_front(m_GmStubs[temp_i][0]);
-        CheckFiberForGmEnding(&fib);
-      }
-      else
-      {
-        // backward tracking (only if we don't explicitely start in the GM)
-        tractLength = FollowStreamline(worldPos, -dir, &fib, tractLength, true);
-        if (m_ControlGmEndings)
-        {
-          CheckFiberForGmEnding(&fib);
-          std::reverse(fib.begin(),fib.end());
-          CheckFiberForGmEnding(&fib);
-        }
-      }
+      // backward tracking (only if we don't explicitely start in the GM)
+      tractLength = FollowStreamline(worldPos, -dir, &fib, tractLength, true);
+
       counter = fib.size();
 
       if (tractLength>=m_MinTractLength && counter>=2)
       {
-        ItkUintImgType::IndexType idx_begin, idx_end;
-        m_TargetRegions->TransformPhysicalPointToIndex(fib.front(), idx_begin);
-        m_TargetRegions->TransformPhysicalPointToIndex(fib.back(), idx_end);
 #pragma omp critical
-        if ( !m_TargetRegions->GetLargestPossibleRegion().IsInside(idx_end) ||
-             !m_TargetRegions->GetLargestPossibleRegion().IsInside(idx_begin) ||
-             (m_TargetRegions->GetPixel(idx_begin)>0 && m_TargetRegions->GetPixel(idx_end)==m_TargetRegions->GetPixel(idx_begin)) )
+        if ( IsValidFiber(&fib) )
         {
           if (!m_StopTracking)
           {
             if (!m_UseOutputProbabilityMap)
               m_Tractogram.push_back(fib);
             else
               FiberToProbmap(&fib);
             m_CurrentTracts++;
           }
           if (m_MaxNumTracts > 0 && m_CurrentTracts>=static_cast<unsigned int>(m_MaxNumTracts))
           {
             if (!m_StopTracking)
             {
               std::cout << "                                                                                                     \r";
               MITK_INFO << "Reconstructed maximum number of tracts (" << m_CurrentTracts << "). Stopping tractography.";
             }
             m_StopTracking = true;
           }
         }
       }
 
     }
   }
 
   this->AfterTracking();
 }
 
-void StreamlineTrackingFilter::CheckFiberForGmEnding(FiberType* fib)
+bool StreamlineTrackingFilter::IsValidFiber(FiberType* fib)
 {
-  if (m_TissueImage.IsNull())
-    return;
-
-  // first check if the current fibe rendpoint is located inside of the white matter
-  // if not, remove last fiber point and repeat
-  bool in_wm = false;
-  while (!in_wm && fib->size()>2)
+  if (m_TargetImageSet && m_SeedImageSet)
   {
-    ItkUcharImgType::IndexType idx;
-    m_TissueImage->TransformPhysicalPointToIndex(fib->back(), idx);
-    if (m_TissueImage->GetPixel(idx)==m_WmLabel)
-      in_wm = true;
-    else
-      fib->pop_back();
+    if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMask, m_SeedInterpolator)
+         && mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMask, m_TargetInterpolator) )
+      return true;
+    if ( mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMask, m_SeedInterpolator)
+         && mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMask, m_TargetInterpolator) )
+      return true;
+    return false;
   }
-  if (fib->size()<3 || !in_wm)
+  else if (m_TargetImageSet)
   {
-    fib->clear();
-    return;
+    if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMask, m_TargetInterpolator)
+         && mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMask, m_TargetInterpolator) )
+      return true;
+    return false;
   }
-
-  // get fiber direction at end point
-  vnl_vector_fixed< float, 3 > d1;
-  d1[0] = fib->back()[0] - fib->at(fib->size()-2)[0];
-  d1[1] = fib->back()[1] - fib->at(fib->size()-2)[1];
-  d1[2] = fib->back()[2] - fib->at(fib->size()-2)[2];
-  d1.normalize();
-
-  // find closest gray matter voxel
-  ItkUcharImgType::IndexType s_idx;
-  m_TissueImage->TransformPhysicalPointToIndex(fib->back(), s_idx);
-  itk::Point<float> gm_endp;
-  float max = -1;
-
-  for (int x : {-1,0,1})
-    for (int y : {-1,0,1})
-      for (int z : {-1,0,1})
-      {
-        if (x==y && y==z)
-          continue;
-
-        ItkUcharImgType::IndexType e_idx;
-        e_idx[0] = s_idx[0] + x;
-        e_idx[1] = s_idx[1] + y;
-        e_idx[2] = s_idx[2] + z;
-
-        if ( !m_TissueImage->GetLargestPossibleRegion().IsInside(e_idx) || m_TissueImage->GetPixel(e_idx)!=m_GmLabel )
-          continue;
-
-        itk::ContinuousIndex<float, 3> end;
-        m_TissueImage->TransformIndexToPhysicalPoint(e_idx, end);
-        vnl_vector_fixed< float, 3 > d2;
-        d2[0] = end[0] - fib->back()[0];
-        d2[1] = end[1] - fib->back()[1];
-        d2[2] = end[2] - fib->back()[2];
-        d2.normalize();
-        float a = dot_product(d1,d2);
-        if (a>max)
-        {
-          max = a;
-          gm_endp = end;
-        }
-      }
-
-  if (max>=0)
-    fib->push_back(gm_endp);
-  else  // no gray matter enpoint found -> delete fiber
-    fib->clear();
+  return true;
 }
 
 void StreamlineTrackingFilter::FiberToProbmap(FiberType* fib)
 {
   ItkDoubleImgType::IndexType last_idx; last_idx.Fill(0);
   for (auto p : *fib)
   {
     ItkDoubleImgType::IndexType idx;
     m_OutputProbabilityMap->TransformPhysicalPointToIndex(p, idx);
 
     if (idx != last_idx)
     {
       if (m_OutputProbabilityMap->GetLargestPossibleRegion().IsInside(idx))
         m_OutputProbabilityMap->SetPixel(idx, m_OutputProbabilityMap->GetPixel(idx)+1);
       last_idx = idx;
     }
   }
 }
 
 void StreamlineTrackingFilter::BuildFibers(bool check)
 {
   if (m_BuildFibersReady<omp_get_num_threads() && check)
     return;
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   for (unsigned int i=0; i<m_Tractogram.size(); i++)
   {
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     FiberType fib = m_Tractogram.at(i);
     for (FiberType::iterator it = fib.begin(); it!=fib.end(); ++it)
     {
       vtkIdType id = vNewPoints->InsertNextPoint((*it).GetDataPointer());
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
 
   if (check)
     for (int i=0; i<m_BuildFibersReady; i++)
       m_Tractogram.pop_back();
   m_BuildFibersReady = 0;
 
   m_FiberPolyData->SetPoints(vNewPoints);
   m_FiberPolyData->SetLines(vNewLines);
   m_BuildFibersFinished = true;
 }
 
 void StreamlineTrackingFilter::AfterTracking()
 {
   if (m_Verbose)
     std::cout << "                                                                                                     \r";
   if (!m_UseOutputProbabilityMap)
   {
     MITK_INFO << "Reconstructed " << m_Tractogram.size() << " fibers.";
     MITK_INFO << "Generating polydata ";
     BuildFibers(false);
   }
   else
   {
     itk::RescaleIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer filter = itk::RescaleIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
     filter->SetInput(m_OutputProbabilityMap);
     filter->SetOutputMaximum(1.0);
     filter->SetOutputMinimum(0.0);
     filter->Update();
     m_OutputProbabilityMap = filter->GetOutput();
   }
   MITK_INFO << "done";
 
   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);
   std::chrono::seconds ss = std::chrono::duration_cast<std::chrono::seconds>(m_EndTime - m_StartTime);
   mm %= 60;
   ss %= 60;
   MITK_INFO << "Tracking took " << hh.count() << "h, " << mm.count() << "m and " << ss.count() << "s";
 
   m_SeedPoints.clear();
 }
 
 void StreamlineTrackingFilter::SetDicomProperties(mitk::FiberBundle::Pointer fib)
 {
   std::string model_code_value = "-";
   std::string model_code_meaning = "-";
   std::string algo_code_value = "-";
   std::string algo_code_meaning = "-";
 
   if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::DETERMINISTIC && dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) && !m_TrackingHandler->GetInterpolate())
   {
     algo_code_value = "sup181_ee04";
     algo_code_meaning = "FACT";
   }
   else if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::DETERMINISTIC)
   {
     algo_code_value = "sup181_ee01";
     algo_code_meaning = "Deterministic";
   }
   else if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::PROBABILISTIC)
   {
     algo_code_value = "sup181_ee02";
     algo_code_meaning = "Probabilistic";
   }
 
   if (dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) || (dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler) && dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->GetIsOdfFromTensor() ) )
   {
     if ( dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) && dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->GetNumTensorImages()>1 )
     {
       model_code_value = "sup181_bb02";
       model_code_meaning = "Multi Tensor";
     }
     else
     {
       model_code_value = "sup181_bb01";
       model_code_meaning = "Single Tensor";
     }
   }
   else if (dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler) || dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler))
   {
     model_code_value = "sup181_bb03";
     model_code_meaning = "Model Free";
   }
   else if (dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler))
   {
     model_code_value = "-";
     model_code_meaning = "ODF";
   }
   else if (dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler))
   {
     model_code_value = "-";
     model_code_meaning = "Peaks";
   }
 
   fib->SetProperty("DICOM.anatomy.value", mitk::StringProperty::New("T-A0095"));
   fib->SetProperty("DICOM.anatomy.meaning", mitk::StringProperty::New("White matter of brain and spinal cord"));
 
   fib->SetProperty("DICOM.algo_code.value", mitk::StringProperty::New(algo_code_value));
   fib->SetProperty("DICOM.algo_code.meaning", mitk::StringProperty::New(algo_code_meaning));
 
   fib->SetProperty("DICOM.model_code.value", mitk::StringProperty::New(model_code_value));
   fib->SetProperty("DICOM.model_code.meaning", mitk::StringProperty::New(model_code_meaning));
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h
index 197240a833..8fc5b836a2 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.h
@@ -1,229 +1,224 @@
 /*===================================================================
 
 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 __itkMLBSTrackingFilter_h_
 #define __itkMLBSTrackingFilter_h_
 
 #include <itkImageToImageFilter.h>
 #include <itkVectorContainer.h>
 #include <itkVectorImage.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <vtkCleanPolyData.h>
 #include <itkOrientationDistributionFunction.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 #include <itkSimpleFastMutexLock.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkPointSet.h>
 #include <chrono>
 #include <TrackingHandlers/mitkTrackingDataHandler.h>
 #include <MitkFiberTrackingExports.h>
 #include <mitkFiberBundle.h>
 
 namespace itk{
 
 /**
 * \brief Performs streamline tracking on the input image. Depending on the tracking handler this can be a tensor, peak or machine learning based tracking. */
 
 class MITKFIBERTRACKING_EXPORT StreamlineTrackingFilter : public ProcessObject
 {
 
 public:
 
   typedef StreamlineTrackingFilter Self;
   typedef SmartPointer<Self>                      Pointer;
   typedef SmartPointer<const Self>                ConstPointer;
   typedef ProcessObject Superclass;
 
   /** Method for creation through the object factory. */
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   /** Runtime information support. */
   itkTypeMacro(MLBSTrackingFilter, ImageToImageFilter)
 
   typedef itk::Image<unsigned char, 3>                ItkUcharImgType;
   typedef itk::Image<unsigned int, 3>                 ItkUintImgType;
   typedef itk::Image<double, 3>                       ItkDoubleImgType;
   typedef itk::Image<float, 3>                        ItkFloatImgType;
   typedef vtkSmartPointer< vtkPolyData >              PolyDataType;
 
   typedef std::deque< itk::Point<float> > FiberType;
   typedef std::vector< FiberType > BundleType;
 
   volatile bool    m_PauseTracking;
   bool    m_AbortTracking;
   bool    m_BuildFibersFinished;
   int     m_BuildFibersReady;
   volatile bool m_Stop;
   mitk::PointSet::Pointer             m_SamplingPointset;
   mitk::PointSet::Pointer             m_StopVotePointset;
   mitk::PointSet::Pointer             m_AlternativePointset;
 
   void SetStepSize(float v)           ///< Integration step size in voxels, default is 0.5 * voxel
   { m_StepSizeVox = v; }
   void SetAngularThreshold(float v)   ///< Angular threshold per step (in degree), default is 90deg x stepsize
   { m_AngularThresholdDeg = v; }
   void SetSamplingDistance(float v)   ///< Maximum distance of sampling points in voxels, default is 0.25 * voxel
   { m_SamplingDistanceVox = v; }
 
   void SetDicomProperties(mitk::FiberBundle::Pointer fib);
 
   itkGetMacro( OutputProbabilityMap, ItkDoubleImgType::Pointer)    ///< Output probability map
   itkGetMacro( FiberPolyData, PolyDataType )          ///< Output fibers
   itkGetMacro( UseOutputProbabilityMap, bool)
 
-  itkSetMacro( SeedImage, ItkUcharImgType::Pointer)   ///< Seeds are only placed inside of this mask.
-  itkSetMacro( MaskImage, ItkUcharImgType::Pointer)   ///< Tracking is only performed inside of this mask image.
-  itkSetMacro( TissueImage, ItkUcharImgType::Pointer) ///<
+  itkSetMacro( SeedImage, ItkFloatImgType::Pointer)   ///< Seeds are only placed inside of this mask.
+  itkSetMacro( MaskImage, ItkFloatImgType::Pointer)   ///< Tracking is only performed inside of this mask image.
   itkSetMacro( SeedsPerVoxel, int)                    ///< One seed placed in the center of each voxel or multiple seeds randomly placed inside each voxel.
   itkSetMacro( MinTractLength, float )                ///< Shorter tracts are discarded.
   itkSetMacro( MaxTractLength, float )                ///< Streamline progression stops if tract is longer than specified.
 
   itkSetMacro( UseStopVotes, bool )                   ///< Frontal sampling points can vote for stopping the streamline even if the remaining sampling points keep pushing
   itkSetMacro( OnlyForwardSamples, bool )             ///< Don't use sampling points behind the current position in progression direction
   itkSetMacro( DeflectionMod, float )                 ///< Deflection distance modifier
-  itkSetMacro( StoppingRegions, ItkUcharImgType::Pointer) ///< Streamlines entering a stopping region will stop immediately
-  itkSetMacro( TargetRegions, ItkUintImgType::Pointer)    ///< Only streamline starting and ending in this mask are retained
+  itkSetMacro( StoppingRegions, ItkFloatImgType::Pointer) ///< Streamlines entering a stopping region will stop immediately
+  itkSetMacro( TargetRegions, ItkFloatImgType::Pointer)    ///< Only streamline starting and ending in this mask are retained
   itkSetMacro( DemoMode, bool )
-  itkSetMacro( SeedOnlyGm, bool )                     ///< place seed points only in the gray matter
-  itkSetMacro( ControlGmEndings, bool )               ///<
   itkSetMacro( NumberOfSamples, unsigned int )        ///< Number of neighborhood sampling points
   itkSetMacro( AposterioriCurvCheck, bool )           ///< Checks fiber curvature (angular deviation across 5mm) is larger than 30°. If yes, the streamline progression is stopped.
   itkSetMacro( AvoidStop, bool )                      ///< Use additional sampling points to avoid premature streamline termination
   itkSetMacro( RandomSampling, bool )                 ///< If true, the sampling points are distributed randomly around the current position, not sphericall in the specified sampling distance.
   itkSetMacro( NumPreviousDirections, unsigned int )  ///< How many "old" steps do we want to consider in our decision where to go next?
   itkSetMacro( MaxNumTracts, int )                    ///< Tracking is stopped if the maximum number of tracts is exceeded
   itkSetMacro( Random, bool )                         ///< If true, seedpoints are shuffled randomly before tracking
   itkSetMacro( Verbose, bool )                        ///< If true, output tracking progress (might be slower)
   itkSetMacro( UseOutputProbabilityMap, bool)         ///< If true, no tractogram but a probability map is created as output.
   itkSetMacro( StopTracking, bool )
   itkSetMacro( InterpolateMask, bool )
 
   ///< Use manually defined points in physical space as seed points instead of seed image
   void SetSeedPoints( const std::vector< itk::Point<float> >& sP) {
     m_SeedPoints = sP;
   }
 
   void SetTrackingHandler( mitk::TrackingDataHandler* h )   ///<
   {
     m_TrackingHandler = h;
   }
 
   virtual void Update() override{
     this->GenerateData();
   }
 
   std::string GetStatusText();
 
 protected:
 
   void GenerateData() override;
 
   StreamlineTrackingFilter();
   ~StreamlineTrackingFilter() {}
 
-  void InitGrayMatterEndings();
-  void CheckFiberForGmEnding(FiberType* fib);
+  bool IsValidFiber(FiberType* fib);  ///< Check endpoints
   void FiberToProbmap(FiberType* fib);
-
   void GetSeedPointsFromSeedImage();
   void CalculateNewPosition(itk::Point<float, 3>& pos, vnl_vector_fixed<float,3>& dir);    ///< Calculate next integration step.
   float FollowStreamline(itk::Point<float, 3> start_pos, vnl_vector_fixed<float,3> dir, FiberType* fib, float tractLength, bool front);       ///< Start streamline in one direction.
-  bool IsInsideMask(const itk::Point<float, 3>& pos, ItkUcharImgType::Pointer mask);   ///< Are we outside of the mask image?
-  bool IsInGm(const itk::Point<float, 3> &pos);
   vnl_vector_fixed<float,3> GetNewDirection(itk::Point<float, 3>& pos, std::deque< vnl_vector_fixed<float,3> >& olddirs, itk::Index<3>& oldIndex); ///< Determine new direction by sample voting at the current position taking the last progression direction into account.
 
   std::vector< vnl_vector_fixed<float,3> > CreateDirections(int NPoints);
 
   void BeforeTracking();
   void AfterTracking();
 
   PolyDataType                        m_FiberPolyData;
   vtkSmartPointer<vtkPoints>          m_Points;
   vtkSmartPointer<vtkCellArray>       m_Cells;
   BundleType                          m_Tractogram;
   BundleType                          m_GmStubs;
 
-  ItkUcharImgType::Pointer            m_StoppingRegions;
-  ItkUintImgType::Pointer             m_TargetRegions;
-  ItkUcharImgType::Pointer            m_SeedImage;
-  ItkUcharImgType::Pointer            m_MaskImage;
-  ItkUcharImgType::Pointer            m_TissueImage;
+  ItkFloatImgType::Pointer            m_StoppingRegions;
+  ItkFloatImgType::Pointer            m_TargetRegions;
+  ItkFloatImgType::Pointer            m_SeedImage;
+  ItkFloatImgType::Pointer            m_MaskImage;
   ItkDoubleImgType::Pointer           m_OutputProbabilityMap;
 
   float                               m_AngularThresholdDeg;
   float                               m_StepSizeVox;
   float                               m_SamplingDistanceVox;
   float                               m_AngularThreshold;
   float                               m_StepSize;
   int                                 m_MaxLength;
   float                               m_MinTractLength;
   float                               m_MaxTractLength;
   int                                 m_SeedsPerVoxel;
 
   bool                                m_AvoidStop;
   bool                                m_RandomSampling;
   float                               m_SamplingDistance;
   float                               m_DeflectionMod;
   bool                                m_OnlyForwardSamples;
   bool                                m_UseStopVotes;
   unsigned int                        m_NumberOfSamples;
 
   unsigned int                        m_NumPreviousDirections;
-  int                                 m_WmLabel;
-  int                                 m_GmLabel;
-  bool                                m_SeedOnlyGm;
-  bool                                m_ControlGmEndings;
   int                                 m_MaxNumTracts;
 
   bool                                m_Verbose;
   bool                                m_AposterioriCurvCheck;
   bool                                m_DemoMode;
   bool                                m_Random;
   bool                                m_UseOutputProbabilityMap;
   std::vector< itk::Point<float> >    m_SeedPoints;
   unsigned int                        m_CurrentTracts;
   unsigned int                        m_Progress;
   bool                                m_StopTracking;
   bool                                m_InterpolateMask;
 
   void BuildFibers(bool check);
   int CheckCurvature(FiberType* fib, bool front);
 
   // decision forest
   mitk::TrackingDataHandler*          m_TrackingHandler;
   std::vector< PolyDataType >         m_PolyDataContainer;
 
   std::chrono::time_point<std::chrono::system_clock> m_StartTime;
   std::chrono::time_point<std::chrono::system_clock> m_EndTime;
 
+  itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::Pointer   m_MaskInterpolator;
+  itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::Pointer   m_StopInterpolator;
+  itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::Pointer   m_TargetInterpolator;
+  itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::Pointer   m_SeedInterpolator;
+  bool                                                                     m_SeedImageSet;
+  bool                                                                     m_TargetImageSet;
+
 private:
 
 };
 
 }
 
 //#ifndef ITK_MANUAL_INSTANTIATION
 //#include "itkMLBSTrackingFilter.cpp"
 //#endif
 
 #endif //__itkMLBSTrackingFilter_h_
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp
index fbade99dae..d85f434205 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.cpp
@@ -1,497 +1,504 @@
 /*===================================================================
 
 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 "itkTractClusteringFilter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 #include <vnl/vnl_sparse_matrix.h>
 
 namespace itk{
 
 TractClusteringFilter::TractClusteringFilter()
   : m_NumPoints(12)
   , m_InCentroids(nullptr)
   , m_MinClusterSize(1)
   , m_MaxClusters(0)
   , m_MergeDuplicateThreshold(-1)
   , m_DoResampling(true)
   , m_FilterMask(nullptr)
   , m_OverlapThreshold(0.0)
 {
 
 }
 
 TractClusteringFilter::~TractClusteringFilter()
 {
   for (auto m : m_Metrics)
     delete m;
 }
 
+std::vector<std::vector<long> > TractClusteringFilter::GetOutFiberIndices() const
+{
+  return m_OutFiberIndices;
+}
+
 void TractClusteringFilter::SetMetrics(const std::vector<mitk::ClusteringMetric *> &Metrics)
 {
   m_Metrics = Metrics;
 }
 
 std::vector<TractClusteringFilter::Cluster> TractClusteringFilter::GetOutClusters() const
 {
   return m_OutClusters;
 }
 
 std::vector<mitk::FiberBundle::Pointer> TractClusteringFilter::GetOutCentroids() const
 {
   return m_OutCentroids;
 }
 
 std::vector<mitk::FiberBundle::Pointer> TractClusteringFilter::GetOutTractograms() const
 {
   return m_OutTractograms;
 }
 
 void TractClusteringFilter::SetDistances(const std::vector<float> &Distances)
 {
   m_Distances = Distances;
 }
 
 float TractClusteringFilter::CalcOverlap(vnl_matrix<float>& t)
 {
   float overlap = 0;
   if (m_FilterMask.IsNotNull())
   {
 
     for (unsigned int i=0; i<m_NumPoints; ++i)
     {
       vnl_vector<float> p = t.get_column(i);
       itk::Point<float,3> point;
       point[0] = p[0];
       point[1] = p[1];
       point[2] = p[2];
       itk::Index<3> idx;
       m_FilterMask->TransformPhysicalPointToIndex(point, idx);
       if (m_FilterMask->GetLargestPossibleRegion().IsInside(idx) && m_FilterMask->GetPixel(idx)>0)
         overlap += 1;
     }
     overlap /= m_NumPoints;
   }
   else
     return 1.0;
 
   return overlap;
 }
 
 std::vector<vnl_matrix<float> > TractClusteringFilter::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
   if (m_DoResampling)
     temp_fib->ResampleToNumPoints(m_NumPoints);
 
   std::vector< vnl_matrix<float> > out_fib;
 
   for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
     vtkCell* cell = temp_fib->GetFiberPolyData()->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vnl_matrix<float> streamline;
     streamline.set_size(3, m_NumPoints);
     streamline.fill(0.0);
 
     for (int j=0; j<numPoints; j++)
     {
       double cand[3];
       points->GetPoint(j, cand);
 
       vnl_vector_fixed< float, 3 > candV;
       candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
       streamline.set_column(j, candV);
     }
 
     out_fib.push_back(streamline);
   }
 
   return out_fib;
 }
 
 std::vector< TractClusteringFilter::Cluster > TractClusteringFilter::ClusterStep(std::vector< long > f_indices, std::vector<float> distances)
 {
   float dist_thres = distances.back();
   distances.pop_back();
   std::vector< Cluster > C;
 
   int N = f_indices.size();
 
   Cluster c1;
   c1.I.push_back(f_indices.at(0));
   c1.h = T[f_indices.at(0)];
   c1.n = 1;
   C.push_back(c1);
   if (f_indices.size()==1)
     return C;
 
   for (int i=1; i<N; ++i)
   {
     vnl_matrix<float> t = T.at(f_indices.at(i));
 
     int min_cluster_index = -1;
     float min_cluster_distance = 99999;
     bool flip = false;
 
     for (unsigned int k=0; k<C.size(); ++k)
     {
       vnl_matrix<float> v = C.at(k).h / C.at(k).n;
       bool f = false;
       float d = 0;
       for (auto m : m_Metrics)
         d += m->CalculateDistance(t, v, f);
       d /= m_Metrics.size();
 
       if (d<min_cluster_distance)
       {
         min_cluster_distance = d;
         min_cluster_index = k;
         flip = f;
       }
     }
 
     if (min_cluster_index>=0 && min_cluster_distance<dist_thres)
     {
       C[min_cluster_index].I.push_back(f_indices.at(i));
       if (!flip)
         C[min_cluster_index].h += t;
       else
         C[min_cluster_index].h += t.fliplr();
       C[min_cluster_index].n += 1;
     }
     else
     {
       Cluster c;
       c.I.push_back(f_indices.at(i));
       c.h = t;
       c.n = 1;
       C.push_back(c);
     }
   }
 
   if (!distances.empty())
   {
     std::vector< Cluster > outC;
 #pragma omp parallel for
     for (int c=0; c<(int)C.size(); c++)
     {
 
       std::vector< Cluster > tempC = ClusterStep(C.at(c).I, distances);
       AppendCluster(outC, tempC);
     }
     return outC;
   }
   else
     return C;
 }
 
 void TractClusteringFilter::AppendCluster(std::vector< Cluster >& a, std::vector< Cluster >&b)
 {
   for (auto c : b)
     a.push_back(c);
 }
 
 void TractClusteringFilter::MergeDuplicateClusters(std::vector< TractClusteringFilter::Cluster >& clusters)
 {
   if (m_MergeDuplicateThreshold<0)
     m_MergeDuplicateThreshold = m_Distances.at(0)/2;
   bool found = true;
 
   MITK_INFO << "Merging duplicate clusters with distance threshold " << m_MergeDuplicateThreshold;
   int start = 0;
   while (found && m_MergeDuplicateThreshold>mitk::eps)
   {
     std::cout << "                                                                                                     \r";
     std::cout << "Number of clusters: " << clusters.size() << '\r';
     cout.flush();
 
     found = false;
     for (int k1=start; k1<(int)clusters.size(); ++k1)
     {
       Cluster c1 = clusters.at(k1);
       vnl_matrix<float> t = c1.h / c1.n;
 
       std::vector< int > merge_indices;
       std::vector< bool > flip_indices;
 
 #pragma omp parallel for
       for (int k2=0; k2<(int)clusters.size(); ++k2)
       {
         if (k1!=k2)
         {
           Cluster c2 = clusters.at(k2);
           vnl_matrix<float> v = c2.h / c2.n;
           bool f = false;
 
 //          d = m_Metric->CalculateDistance(t, v, f);  // alwayse use MDF?
           float d = 0;
           for (auto m : m_Metrics)
             d += m->CalculateDistance(t, v, f);
           d /= m_Metrics.size();
 
 #pragma omp critical
           if (d<m_MergeDuplicateThreshold)
           {
             merge_indices.push_back(k2);
             flip_indices.push_back(f);
           }
         }
       }
 
       for (unsigned int i=0; i<merge_indices.size(); ++i)
       {
         Cluster c2 = clusters.at(merge_indices.at(i));
         for (int i=0; i<c2.n; ++i)
         {
           clusters[k1].I.push_back(c2.I.at(i));
           clusters[k1].n += 1;
         }
         if (!flip_indices.at(i))
           clusters[k1].h += c2.h;
         else
           clusters[k1].h += c2.h.fliplr();
       }
 
       std::sort(merge_indices.begin(), merge_indices.end());
       for (unsigned int i=0; i<merge_indices.size(); ++i)
       {
         clusters.erase (clusters.begin()+merge_indices.at(i)-i);
         found = true;
       }
       if (found)
         break;
     }
     ++start;
   }
   MITK_INFO << "\nNumber of clusters after merging duplicates: " << clusters.size();
 }
 
 std::vector<TractClusteringFilter::Cluster> TractClusteringFilter::AddToKnownClusters(std::vector< long > f_indices, std::vector<vnl_matrix<float> >& centroids)
 {
   float dist_thres = m_Distances.at(0);
   int N = f_indices.size();
 
   std::vector< Cluster > C;
   vnl_matrix<float> zero_h; zero_h.set_size(T.at(0).rows(), T.at(0).cols()); zero_h.fill(0.0);
   Cluster no_fit;
   no_fit.h = zero_h;
 
   for (unsigned int i=0; i<centroids.size(); ++i)
   {
     Cluster c;
     c.h.set_size(T.at(0).rows(), T.at(0).cols()); c.h.fill(0.0);
     c.f_id = i;
     C.push_back(c);
   }
 
 #pragma omp parallel for
   for (int i=0; i<N; ++i)
   {
     vnl_matrix<float> t = T.at(f_indices.at(i));
 
     int min_cluster_index = -1;
     float min_cluster_distance = 99999;
     bool flip = false;
 
     if (CalcOverlap(t)>=m_OverlapThreshold)
     {
       int c_idx = 0;
       for (vnl_matrix<float> centroid : centroids)
       {
         bool f = false;
         float d = 0;
         for (auto m : m_Metrics)
           d += m->CalculateDistance(t, centroid, f);
         d /= m_Metrics.size();
 
         if (d<min_cluster_distance)
         {
           min_cluster_distance = d;
           min_cluster_index = c_idx;
           flip = f;
         }
         ++c_idx;
       }
     }
 
     if (min_cluster_index>=0 && min_cluster_distance<dist_thres)
     {
 #pragma omp critical
       {
         C[min_cluster_index].I.push_back(f_indices.at(i));
         if (!flip)
           C[min_cluster_index].h += t;
         else
           C[min_cluster_index].h += t.fliplr();
         C[min_cluster_index].n += 1;
       }
     }
     else
     {
 #pragma omp critical
       {
         no_fit.I.push_back(f_indices.at(i));
         no_fit.n++;
       }
     }
   }
   C.push_back(no_fit);
   return C;
 }
 
 
 
 void TractClusteringFilter::GenerateData()
 {
   m_OutTractograms.clear();
   m_OutCentroids.clear();
   m_OutClusters.clear();
 
   if (m_Metrics.empty())
   {
     mitkThrow() << "No metric selected!";
     return;
   }
 
   T = ResampleFibers(m_Tractogram);
   if (T.empty())
   {
     MITK_INFO << "No fibers in tractogram!";
     return;
   }
 
   std::vector< long > f_indices;
   for (unsigned int i=0; i<T.size(); ++i)
     f_indices.push_back(i);
   //  std::random_shuffle(f_indices.begin(), f_indices.end());
 
   Cluster no_match;
   std::vector< Cluster > clusters;
   if (m_InCentroids.IsNull())
   {
     MITK_INFO << "Clustering fibers";
     clusters = ClusterStep(f_indices, m_Distances);
-    while (clusters.size()>5000)
-    {
-      MITK_INFO << "Number of clusters: " << clusters.size();
-      MITK_INFO << "Increasing cluster size";
-      for (unsigned int i=0; i<m_Distances.size(); ++i)
-      {
-        m_Distances[i] *= 1.1;
-        MITK_INFO << m_Distances[i];
-      }
-      clusters = ClusterStep(f_indices, m_Distances);
-    }
+//    while (clusters.size()>5000)
+//    {
+//      MITK_INFO << "Number of clusters: " << clusters.size();
+//      MITK_INFO << "Increasing cluster size";
+//      for (unsigned int i=0; i<m_Distances.size(); ++i)
+//      {
+//        m_Distances[i] *= 1.1;
+//        MITK_INFO << m_Distances[i];
+//      }
+//      clusters = ClusterStep(f_indices, m_Distances);
+//    }
     MITK_INFO << "Number of clusters: " << clusters.size();
     MergeDuplicateClusters(clusters);
     std::sort(clusters.begin(),clusters.end());
   }
   else
   {
     std::vector<vnl_matrix<float> > centroids = ResampleFibers(m_InCentroids);
     if (centroids.empty())
     {
       MITK_INFO << "No fibers in centroid tractogram!";
       return;
     }
     MITK_INFO << "Clustering with input centroids";
     clusters = AddToKnownClusters(f_indices, centroids);
     no_match = clusters.back();
     clusters.pop_back();
     MITK_INFO << "Number of clusters: " << clusters.size();
     MergeDuplicateClusters(clusters);
   }
 
   MITK_INFO << "Clustering finished";
   int max = clusters.size()-1;
   if (m_MaxClusters>0 && clusters.size()-1>m_MaxClusters)
     max = m_MaxClusters;
   for (int i=clusters.size()-1; i>=0; --i)
   {
     Cluster c = clusters.at(i);
     if ( c.n>=(int)m_MinClusterSize && !(m_MaxClusters>0 && clusters.size()-i>m_MaxClusters) )
     {
       m_OutClusters.push_back(c);
 
       vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
       vtkSmartPointer<vtkPolyData> pTmp = m_Tractogram->GeneratePolyDataByIds(c.I, weights);
       mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
       if (max>0)
         fib->SetFiberWeights((float)i/max);
       m_OutTractograms.push_back(fib);
+      m_OutFiberIndices.push_back(c.I);
 
       // create centroid
       vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
       vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       vnl_matrix<float> centroid_points = c.h / c.n;
       for (unsigned int j=0; j<centroid_points.cols(); j++)
       {
         double p[3];
         p[0] = centroid_points.get(0,j);
         p[1] = centroid_points.get(1,j);
         p[2] = centroid_points.get(2,j);
 
         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       vtkNewCells->InsertNextCell(container);
       polyData->SetPoints(vtkNewPoints);
       polyData->SetLines(vtkNewCells);
       mitk::FiberBundle::Pointer centroid = mitk::FiberBundle::New(polyData);
       centroid->SetFiberColors(255, 255, 255);
       m_OutCentroids.push_back(centroid);
     }
   }
   MITK_INFO << "Final number of clusters: " << m_OutTractograms.size();
 
   int w = 0;
   for (auto fib : m_OutTractograms)
   {
     if (m_OutTractograms.size()>1)
     {
       fib->SetFiberWeights((float)w/(m_OutTractograms.size()-1));
       m_OutCentroids.at(w)->SetFiberWeights((float)w/(m_OutTractograms.size()-1));
     }
     else
     {
       fib->SetFiberWeights(1);
       m_OutCentroids.at(w)->SetFiberWeights(1);
     }
     fib->ColorFibersByFiberWeights(false, false);
     ++w;
   }
 
   if (no_match.n>0)
   {
     vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
     vtkSmartPointer<vtkPolyData> pTmp = m_Tractogram->GeneratePolyDataByIds(no_match.I, weights);
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
     fib->SetFiberColors(0, 0, 0);
+    m_OutFiberIndices.push_back(no_match.I);
     m_OutTractograms.push_back(fib);
   }
 }
 
 }
 
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.h
index dd4bb041ed..bf03459e68 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractClusteringFilter.h
@@ -1,136 +1,139 @@
 /*===================================================================
 
 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 itkTractClusteringFilter_h
 #define itkTractClusteringFilter_h
 
 // MITK
 #include <mitkPlanarEllipse.h>
 #include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkClusteringMetric.h>
 
 // ITK
 #include <itkProcessObject.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 namespace itk{
 
 /**
 * \brief    */
 
 class TractClusteringFilter : public ProcessObject
 {
 public:
 
   struct Cluster
   {
     Cluster() : n(0), f_id(-1) {}
 
     vnl_matrix<float> h;
     std::vector< long > I;
     int n;
     int f_id;
 
     bool operator <(Cluster const& b) const
     {
       return this->n < b.n;
     }
   };
 
   typedef TractClusteringFilter Self;
   typedef ProcessObject                                       Superclass;
   typedef SmartPointer< Self >                                Pointer;
   typedef SmartPointer< const Self >                          ConstPointer;
   typedef itk::Image< float, 3 >                              FloatImageType;
   typedef itk::Image< unsigned char, 3 >                      UcharImageType;
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( TractClusteringFilter, ProcessObject )
 
   itkSetMacro(NumPoints, unsigned int)  ///< Fibers are resampled to the specified number of points. If scalar maps are used, a larger number of points is recommended.
   itkGetMacro(NumPoints, unsigned int)  ///< Fibers are resampled to the specified number of points. If scalar maps are used, a larger number of points is recommended.
   itkSetMacro(MinClusterSize, unsigned int) ///< Clusters with too few fibers are discarded
   itkGetMacro(MinClusterSize, unsigned int) ///< Clusters with too few fibers are discarded
   itkSetMacro(MaxClusters, unsigned int) ///< Only the N largest clusters are kept
   itkGetMacro(MaxClusters, unsigned int) ///< Only the N largest clusters are kept
   itkSetMacro(MergeDuplicateThreshold, float) ///< Clusters with centroids very close to each other are merged. Set to 0 to avoid merging and to -1 to use the original cluster size.
   itkGetMacro(MergeDuplicateThreshold, float) ///< Clusters with centroids very close to each other are merged. Set to 0 to avoid merging and to -1 to use the original cluster size.
   itkSetMacro(DoResampling, bool) ///< Resample fibers to equal number of points. This is mandatory, but can be performed outside of the filter if desired.
   itkGetMacro(DoResampling, bool) ///< Resample fibers to equal number of points. This is mandatory, but can be performed outside of the filter if desired.
   itkSetMacro(OverlapThreshold, float)  ///< Overlap threshold used in conjunction with the filter mask when clustering around known centroids.
   itkGetMacro(OverlapThreshold, float)  ///< Overlap threshold used in conjunction with the filter mask when clustering around known centroids.
 
   itkSetMacro(Tractogram, mitk::FiberBundle::Pointer)   ///< The streamlines to be clustered
   itkSetMacro(InCentroids, mitk::FiberBundle::Pointer)  ///< If a tractogram containing known tract centroids is set, the input fibers are assigned to the closest centroid. If no centroid is found within the specified smallest clustering distance, the fiber is assigned to the no-fit cluster.
   itkSetMacro(FilterMask, UcharImageType::Pointer)  ///< If fibers are clustered around the nearest input centroids (see SetInCentroids), the complete input tractogram can additionally be pre-filtered with this binary mask and a given overlap threshold (see SetOverlapThreshold).
 
   virtual void Update() override{
     this->GenerateData();
   }
 
   void SetDistances(const std::vector<float> &Distances); ///< Set clustering distances that are traversed recoursively. The distances have to be sorted in an ascending manner. The actual cluster size is determined by the smallest entry in the distance-list (index 0).
 
   std::vector<mitk::FiberBundle::Pointer> GetOutTractograms() const;
   std::vector<mitk::FiberBundle::Pointer> GetOutCentroids() const;
   std::vector<Cluster> GetOutClusters() const;
 
   void SetMetrics(const std::vector<mitk::ClusteringMetric *> &Metrics);
 
+  std::vector<std::vector<long> > GetOutFiberIndices() const;
+
 protected:
 
   void GenerateData() override;
   std::vector< vnl_matrix<float> > ResampleFibers(FiberBundle::Pointer tractogram);
   float CalcOverlap(vnl_matrix<float>& t);
 
   std::vector< Cluster > ClusterStep(std::vector< long > f_indices, std::vector< float > distances);
 
   void MergeDuplicateClusters(std::vector< TractClusteringFilter::Cluster >& clusters);
   std::vector< Cluster > AddToKnownClusters(std::vector< long > f_indices, std::vector<vnl_matrix<float> > &centroids);
   void AppendCluster(std::vector< Cluster >& a, std::vector< Cluster >&b);
 
   TractClusteringFilter();
   virtual ~TractClusteringFilter();
 
   unsigned int                                m_NumPoints;
   std::vector< float >                        m_Distances;
   mitk::FiberBundle::Pointer                  m_Tractogram;
   mitk::FiberBundle::Pointer                  m_InCentroids;
   std::vector< mitk::FiberBundle::Pointer >   m_OutTractograms;
   std::vector< mitk::FiberBundle::Pointer >   m_OutCentroids;
   std::vector<vnl_matrix<float> >             T;
   unsigned int                                m_MinClusterSize;
   unsigned int                                m_MaxClusters;
   float                                       m_MergeDuplicateThreshold;
   std::vector< Cluster >                      m_OutClusters;
   bool                                        m_DoResampling;
   UcharImageType::Pointer                     m_FilterMask;
   float                                       m_OverlapThreshold;
   std::vector< mitk::ClusteringMetric* >      m_Metrics;
+  std::vector< std::vector< long > >          m_OutFiberIndices;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractClusteringFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp
index af80a906d3..0d3e5f36e9 100644
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp
@@ -1,468 +1,397 @@
 /*===================================================================
 
 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 __itkKspaceImageFilter_txx
 #define __itkKspaceImageFilter_txx
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkKspaceImageFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageFileWriter.h>
 #include <mitkSingleShotEpi.h>
 #include <mitkCartesianReadout.h>
+#include <mitkDiffusionFunctionCollection.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
   template< class TPixelType >
   KspaceImageFilter< TPixelType >
   ::KspaceImageFilter()
     : m_Z(0)
     , m_UseConstantRandSeed(false)
     , m_SpikesPerSlice(0)
     , m_IsBaseline(true)
   {
     m_DiffusionGradientDirection.Fill(0.0);
-
     m_CoilPosition.Fill(0.0);
+    m_FmapInterpolator = itk::LinearInterpolateImageFunction< itk::Image< double, 3 >, float >::New();
   }
 
   template< class TPixelType >
   void KspaceImageFilter< TPixelType >
   ::BeforeThreadedGenerateData()
   {
     m_Spike = vcl_complex<double>(0,0);
     m_SpikeLog = "";
 
     typename OutputImageType::Pointer outputImage = OutputImageType::New();
     itk::ImageRegion<2> region;
     region.SetSize(0, m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(0));
     region.SetSize(1, m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(1));
     outputImage->SetLargestPossibleRegion( region );
     outputImage->SetBufferedRegion( region );
     outputImage->SetRequestedRegion( region );
     outputImage->Allocate();
     outputImage->FillBuffer(m_Spike);
 
     m_KSpaceImage = InputImageType::New();
     m_KSpaceImage->SetLargestPossibleRegion( region );
     m_KSpaceImage->SetBufferedRegion( region );
     m_KSpaceImage->SetRequestedRegion( region );
     m_KSpaceImage->Allocate();
     m_KSpaceImage->FillBuffer(0.0);
 
     m_Gamma = 42576000;    // Gyromagnetic ratio in Hz/T (1.5T)
     if ( m_Parameters->m_SignalGen.m_EddyStrength>0 && m_DiffusionGradientDirection.GetNorm()>0.001)
     {
       m_DiffusionGradientDirection.Normalize();
       m_DiffusionGradientDirection = m_DiffusionGradientDirection *  m_Parameters->m_SignalGen.m_EddyStrength/1000 *  m_Gamma;
       m_IsBaseline = false;
     }
 
     this->SetNthOutput(0, outputImage);
 
     m_Transform =  m_Parameters->m_SignalGen.m_ImageDirection;
     for (int i=0; i<3; i++)
     {
       for (int j=0; j<3; j++)
       {
         m_Transform[i][j] *=  m_Parameters->m_SignalGen.m_ImageSpacing[j];
       }
     }
     double a = m_Parameters->m_SignalGen.m_ImageRegion.GetSize(0)*m_Parameters->m_SignalGen.m_ImageSpacing[0];
     double b = m_Parameters->m_SignalGen.m_ImageRegion.GetSize(1)*m_Parameters->m_SignalGen.m_ImageSpacing[1];
     double diagonal = sqrt(a*a+b*b)/1000;   // image diagonal in m
 
     switch (m_Parameters->m_SignalGen.m_CoilSensitivityProfile)
     {
       case SignalGenerationParameters::COIL_CONSTANT:
       {
         m_CoilSensitivityFactor = 1;                    // same signal everywhere
         break;
       }
       case SignalGenerationParameters::COIL_LINEAR:
       {
         m_CoilSensitivityFactor = -1/diagonal;          // about 50% of the signal in the image center remaining
         break;
       }
       case SignalGenerationParameters::COIL_EXPONENTIAL:
       {
         m_CoilSensitivityFactor = -log(0.1)/diagonal;   // about 32% of the signal in the image center remaining
         break;
       }
     }
 
     switch (m_Parameters->m_SignalGen.m_AcquisitionType)
     {
       case SignalGenerationParameters::SingleShotEpi:
         m_ReadoutScheme = new mitk::SingleShotEpi(m_Parameters);
       break;
       case SignalGenerationParameters::SpinEcho:
         m_ReadoutScheme = new mitk::CartesianReadout(m_Parameters);
       break;
       default:
         m_ReadoutScheme = new mitk::SingleShotEpi(m_Parameters);
     }
 
     m_ReadoutScheme->AdjustEchoTime();
+
+    m_FmapInterpolator->SetInputImage(m_Parameters->m_SignalGen.m_FrequencyMap);
   }
 
   template< class TPixelType >
   double KspaceImageFilter< TPixelType >::CoilSensitivity(DoubleVectorType& pos)
   {
     // *************************************************************************
     // Coil ring is moving with excited slice (FIX THIS SOMETIME)
     m_CoilPosition[2] = pos[2];
     // *************************************************************************
 
     switch (m_Parameters->m_SignalGen.m_CoilSensitivityProfile)
     {
       case SignalGenerationParameters::COIL_CONSTANT:
       return 1;
       case SignalGenerationParameters::COIL_LINEAR:
       {
         DoubleVectorType diff = pos-m_CoilPosition;
         double sens = diff.GetNorm()*m_CoilSensitivityFactor + 1;
         if (sens<0)
           sens = 0;
         return sens;
       }
       case SignalGenerationParameters::COIL_EXPONENTIAL:
       {
         DoubleVectorType diff = pos-m_CoilPosition;
         double dist = diff.GetNorm();
         return exp(-dist*m_CoilSensitivityFactor);
       }
       default:
       return 1;
     }
   }
 
   template< class TPixelType >
   void KspaceImageFilter< TPixelType >
   ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType)
   {
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
     randGen->SetSeed();
     if (m_UseConstantRandSeed)  // always generate the same random numbers?
     {
       randGen->SetSeed(0);
     }
     else
     {
       randGen->SetSeed();
     }
 
     typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
 
     ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
 
     typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
 
     double kxMax = m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(0);
     double kyMax = m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(1);
     double xMax = m_CompartmentImages.at(0)->GetLargestPossibleRegion().GetSize(0); // scanner coverage in x-direction
     double yMax = m_CompartmentImages.at(0)->GetLargestPossibleRegion().GetSize(1); // scanner coverage in y-direction
     double yMaxFov = yMax*m_Parameters->m_SignalGen.m_CroppingFactor;               // actual FOV in y-direction (in x-direction FOV=xMax)
 
     double numPix = kxMax*kyMax;
     // Adjust noise variance since it is the intended variance in physical space and not in k-space:
     double noiseVar = m_Parameters->m_SignalGen.m_PartialFourier*m_Parameters->m_SignalGen.m_NoiseVariance/(kyMax*kxMax);
 
     while( !oit.IsAtEnd() )
     {
       // time from maximum echo
       double t= m_ReadoutScheme->GetTimeFromMaxEcho(oit.GetIndex());
 
       // time passed since k-space readout started
       double tRead = m_ReadoutScheme->GetRedoutTime(oit.GetIndex());
 
       // time passes since application of the RF pulse
       double tRf = m_Parameters->m_SignalGen.m_tEcho+t;
 
       // calculate eddy current decay factor
       // (TODO: vielleicht umbauen dass hier die zeit vom letzten diffusionsgradienten an genommen wird. doku dann auch entsprechend anpassen.)
       double eddyDecay = 0;
       if ( m_Parameters->m_Misc.m_CheckAddEddyCurrentsBox && m_Parameters->m_SignalGen.m_EddyStrength>0)
       {
         eddyDecay = exp(-tRead/m_Parameters->m_SignalGen.m_Tau );
       }
 
       // calcualte signal relaxation factors
       std::vector< double > relaxFactor;
       if ( m_Parameters->m_SignalGen.m_DoSimulateRelaxation)
       {
         for (unsigned int i=0; i<m_CompartmentImages.size(); i++)
         {
           relaxFactor.push_back( exp(-tRf/m_T2.at(i) -fabs(t)/ m_Parameters->m_SignalGen.m_tInhom)
                                  * (1.0-exp(-(m_Parameters->m_SignalGen.m_tRep + tRf)/m_T1.at(i))) );
         }
       }
       // get current k-space index (depends on the chosen k-space readout scheme)
       itk::Index< 2 > kIdx = m_ReadoutScheme->GetActualKspaceIndex(oit.GetIndex());
 
       // partial fourier
       bool pf = false;
       if (kIdx[1]>kyMax*m_Parameters->m_SignalGen.m_PartialFourier)
       {
         pf = true;
       }
 
       if (!pf)
       {
         // shift k for DFT: (0 -- N) --> (-N/2 -- N/2)
         double kx = kIdx[0];
         double ky = kIdx[1];
         if ((int)kxMax%2==1){ kx -= (kxMax-1)/2; }
         else{ kx -= kxMax/2; }
 
         if ((int)kyMax%2==1){ ky -= (kyMax-1)/2; }
         else{ ky -= kyMax/2; }
 
         // add ghosting
         if (oit.GetIndex()[1]%2 == 1)
         {
           kx -= m_Parameters->m_SignalGen.m_KspaceLineOffset;    // add gradient delay induced offset
         }
         else
         {
           kx += m_Parameters->m_SignalGen.m_KspaceLineOffset;    // add gradient delay induced offset
         }
 
         vcl_complex<double> s(0,0);
         InputIteratorType it(m_CompartmentImages.at(0), m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
         while( !it.IsAtEnd() )
         {
           double x = it.GetIndex()[0];
           double y = it.GetIndex()[1];
           if ((int)xMax%2==1){ x -= (xMax-1)/2; }
           else{ x -= xMax/2; }
           if ((int)yMax%2==1){ y -= (yMax-1)/2; }
           else{ y -= yMax/2; }
 
           DoubleVectorType pos; pos[0] = x; pos[1] = y; pos[2] = m_Z;
           pos = m_Transform*pos/1000;   // vector from image center to current position (in meter)
 
           vcl_complex<double> f(0, 0);
 
           // sum compartment signals and simulate relaxation
           for (unsigned int i=0; i<m_CompartmentImages.size(); i++)
             if ( m_Parameters->m_SignalGen.m_DoSimulateRelaxation)
               f += std::complex<double>( m_CompartmentImages.at(i)->GetPixel(it.GetIndex()) * relaxFactor.at(i) *  m_Parameters->m_SignalGen.m_SignalScale, 0);
             else
               f += std::complex<double>( m_CompartmentImages.at(i)->GetPixel(it.GetIndex()) *  m_Parameters->m_SignalGen.m_SignalScale );
 
           if (m_Parameters->m_SignalGen.m_CoilSensitivityProfile!=SignalGenerationParameters::COIL_CONSTANT)
             f *= CoilSensitivity(pos);
 
           // simulate eddy currents and other distortions
           double omega = 0;   // frequency offset
           if (  m_Parameters->m_SignalGen.m_EddyStrength>0 && m_Parameters->m_Misc.m_CheckAddEddyCurrentsBox && !m_IsBaseline)
           {
             omega += (m_DiffusionGradientDirection[0]*pos[0]+m_DiffusionGradientDirection[1]*pos[1]+m_DiffusionGradientDirection[2]*pos[2]) * eddyDecay;
           }
 
           if (m_Parameters->m_SignalGen.m_FrequencyMap.IsNotNull()) // simulate distortions
           {
             itk::Point<double, 3> point3D;
             ItkDoubleImgType::IndexType index; index[0] = it.GetIndex()[0]; index[1] = it.GetIndex()[1]; index[2] = m_Zidx;
             if (m_Parameters->m_SignalGen.m_DoAddMotion)    // we have to account for the head motion since this also moves our frequency map
             {
               m_Parameters->m_SignalGen.m_FrequencyMap->TransformIndexToPhysicalPoint(index, point3D);
               point3D = m_FiberBundle->TransformPoint( point3D.GetVnlVector(),
                                                        -m_Rotation[0], -m_Rotation[1], -m_Rotation[2],
                                                        -m_Translation[0], -m_Translation[1], -m_Translation[2] );
-              omega += InterpolateFmapValue(point3D);
+              omega += mitk::imv::GetImageValue<double>(point3D, true, m_FmapInterpolator);
             }
             else
             {
               omega += m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(index);
 
             }
           }
 
           // if signal comes from outside FOV, mirror it back (wrap-around artifact - aliasing)
           if (y<-yMaxFov/2){ y += yMaxFov; }
           else if (y>=yMaxFov/2) { y -= yMaxFov; }
 
           // actual DFT term
           s += f * exp( std::complex<double>(0, 2 * M_PI * (kx*x/xMax + ky*y/yMaxFov + omega*t/1000 )) );
 
           ++it;
         }
         s /= numPix;
 
         if (m_SpikesPerSlice>0 && sqrt(s.imag()*s.imag()+s.real()*s.real()) > sqrt(m_Spike.imag()*m_Spike.imag()+m_Spike.real()*m_Spike.real()) )
         {
           m_Spike = s;
 
         }
 
         if (m_Parameters->m_SignalGen.m_NoiseVariance>0 && m_Parameters->m_Misc.m_CheckAddNoiseBox)
         {
           s = vcl_complex<double>(s.real()+randGen->GetNormalVariate(0,noiseVar), s.imag()+randGen->GetNormalVariate(0,noiseVar));
         }
 
         outputImage->SetPixel(kIdx, s);
         m_KSpaceImage->SetPixel(kIdx, sqrt(s.imag()*s.imag()+s.real()*s.real()) );
       }
 
       ++oit;
     }
   }
 
   template< class TPixelType >
   void KspaceImageFilter< TPixelType >
   ::AfterThreadedGenerateData()
   {
     delete m_ReadoutScheme;
 
     typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
     double kxMax = outputImage->GetLargestPossibleRegion().GetSize(0);  // k-space size in x-direction
     double kyMax = outputImage->GetLargestPossibleRegion().GetSize(1);  // k-space size in y-direction
 
     ImageRegionIterator< OutputImageType > oit(outputImage, outputImage->GetLargestPossibleRegion());
     while( !oit.IsAtEnd() ) // use hermitian k-space symmetry to fill empty k-space parts resulting from partial fourier acquisition
     {
       itk::Index< 2 > kIdx;
       kIdx[0] = oit.GetIndex()[0];
       kIdx[1] = oit.GetIndex()[1];
 
       // reverse phase
       if (!m_Parameters->m_SignalGen.m_ReversePhase)
         kIdx[1] = kyMax-1-kIdx[1];
 
       if (kIdx[1]>kyMax*m_Parameters->m_SignalGen.m_PartialFourier)
       {
         // reverse readout direction
         if (oit.GetIndex()[1]%2 == 1)
           kIdx[0] = kxMax-kIdx[0]-1;
 
         // calculate symmetric index
         itk::Index< 2 > kIdx2;
         kIdx2[0] = (int)(kxMax-kIdx[0]-(int)kxMax%2)%(int)kxMax;
         kIdx2[1] = (int)(kyMax-kIdx[1]-(int)kyMax%2)%(int)kyMax;
 
         // use complex conjugate of symmetric index value at current index
         vcl_complex<double> s = outputImage->GetPixel(kIdx2);
         s = vcl_complex<double>(s.real(), -s.imag());
         outputImage->SetPixel(kIdx, s);
 
         m_KSpaceImage->SetPixel(kIdx, sqrt(s.imag()*s.imag()+s.real()*s.real()) );
       }
       ++oit;
     }
 
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
     randGen->SetSeed();
     if (m_UseConstantRandSeed)  // always generate the same random numbers?
       randGen->SetSeed(0);
     else
       randGen->SetSeed();
 
     m_Spike *=  m_Parameters->m_SignalGen.m_SpikeAmplitude;
     itk::Index< 2 > spikeIdx;
     for (unsigned int i=0; i<m_SpikesPerSlice; i++)
     {
       spikeIdx[0] = randGen->GetIntegerVariate()%(int)kxMax;
       spikeIdx[1] = randGen->GetIntegerVariate()%(int)kyMax;
       outputImage->SetPixel(spikeIdx, m_Spike);
       m_SpikeLog += "[" + boost::lexical_cast<std::string>(spikeIdx[0]) + "," + boost::lexical_cast<std::string>(spikeIdx[1]) + "," + boost::lexical_cast<std::string>(m_Zidx) + "] Magnitude: " + boost::lexical_cast<std::string>(m_Spike.real()) + "+" + boost::lexical_cast<std::string>(m_Spike.imag()) + "i\n";
     }
   }
-
-
-
-  template< class TPixelType >
-  double KspaceImageFilter< TPixelType >::InterpolateFmapValue(itk::Point<float, 3> itkP)
-  {
-    itk::Index<3> idx;
-    itk::ContinuousIndex< double, 3> cIdx;
-    m_Parameters->m_SignalGen.m_FrequencyMap->TransformPhysicalPointToIndex(itkP, idx);
-    m_Parameters->m_SignalGen.m_FrequencyMap->TransformPhysicalPointToContinuousIndex(itkP, cIdx);
-
-    double pix = 0;
-    if ( m_Parameters->m_SignalGen.m_FrequencyMap->GetLargestPossibleRegion().IsInside(idx) )
-      pix = m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(idx);
-    else
-      return pix;
-
-    double frac_x = cIdx[0] - idx[0];
-    double frac_y = cIdx[1] - idx[1];
-    double 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>(m_Parameters->m_SignalGen.m_FrequencyMap->GetLargestPossibleRegion().GetSize(0) - 1) &&
-        idx[1] >= 0 && idx[1] < static_cast<itk::IndexValueType>(m_Parameters->m_SignalGen.m_FrequencyMap->GetLargestPossibleRegion().GetSize(1) - 1) &&
-        idx[2] >= 0 && idx[2] < static_cast<itk::IndexValueType>(m_Parameters->m_SignalGen.m_FrequencyMap->GetLargestPossibleRegion().GetSize(2) - 1))
-    {
-      vnl_vector_fixed<double, 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 = m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(idx) * interpWeights[0];
-      ItkDoubleImgType::IndexType tmpIdx = idx; tmpIdx[0]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[1];
-      tmpIdx = idx; tmpIdx[1]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[2];
-      tmpIdx = idx; tmpIdx[2]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[3];
-      tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[4];
-      tmpIdx = idx; tmpIdx[1]++; tmpIdx[2]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[5];
-      tmpIdx = idx; tmpIdx[2]++; tmpIdx[0]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[6];
-      tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
-      pix +=  m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(tmpIdx) * interpWeights[7];
-    }
-
-    return pix;
-  }
-
 }
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.h
index f358baea34..9034b49a25 100644
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.h
@@ -1,143 +1,144 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __itkKspaceImageFilter_h_
 #define __itkKspaceImageFilter_h_
 
 #include <MitkFiberTrackingExports.h>
 #include <itkImageSource.h>
 #include <vcl_complex.h>
 #include <vector>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkFiberBundle.h>
 #include <mitkAcquisitionType.h>
 
 namespace itk{
 
 /**
 * \brief Simulates k-space acquisition of one slice with a single shot EPI sequence. Enables the simulation of various effects occuring during real MR acquisitions:
 * - T2 signal relaxation
 * - Spikes
 * - N/2 Ghosts
 * - Aliasing (wrap around)
 * - Image distortions (off-frequency effects)
 * - Gibbs ringing
 * - Eddy current effects
 * Based on a discrete fourier transformation.
 * See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 */
 
   template< class TPixelType >
   class KspaceImageFilter :
       public ImageSource< Image< vcl_complex< TPixelType >, 2 > >
   {
 
   public:
 
     typedef KspaceImageFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageSource< Image< vcl_complex< TPixelType >, 2 > > Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(KspaceImageFilter, ImageToImageFilter)
 
     typedef typename itk::Image< double, 2 >                InputImageType;
     typedef typename InputImageType::Pointer                InputImagePointerType;
     typedef typename Superclass::OutputImageType            OutputImageType;
     typedef typename Superclass::OutputImageRegionType      OutputImageRegionType;
     typedef itk::Matrix<double, 3, 3>                       MatrixType;
     typedef itk::Point<double,2>                            Point2D;
     typedef itk::Vector< double,3>                          DoubleVectorType;
     typedef itk::Image<double, 3>                           ItkDoubleImgType;
 
     itkSetMacro( SpikesPerSlice, unsigned int )     ///< Number of spikes per slice. Corresponding parameter in fiberfox parameter object specifies the number of spikes for the whole image and can thus not be used here.
     itkSetMacro( Z, double )                        ///< Slice position, necessary for eddy current simulation.
     itkSetMacro( UseConstantRandSeed, bool )        ///< Use constant seed for random generator for reproducible results. ONLY USE FOR TESTING PURPOSES!
     itkSetMacro( Rotation, DoubleVectorType )
     itkSetMacro( Translation, DoubleVectorType )
     itkSetMacro( Zidx, int )
     itkSetMacro( FiberBundle, FiberBundle::Pointer )
     itkSetMacro( CoilPosition, DoubleVectorType )
     itkGetMacro( KSpaceImage, typename InputImageType::Pointer )    ///< k-space magnitude image
     itkGetMacro( SpikeLog, std::string )
 
     void SetParameters( FiberfoxParameters<double>* param ){ m_Parameters = param; }
 
     void SetCompartmentImages( std::vector< InputImagePointerType > cImgs ) { m_CompartmentImages=cImgs; }  ///< One signal image per compartment.
     void SetT2( std::vector< double > t2Vector ) { m_T2=t2Vector; } ///< One T2 relaxation constant per compartment image.
     void SetT1( std::vector< double > t1Vector ) { m_T1=t1Vector; } ///< One T1 relaxation constant per compartment image.
     void SetDiffusionGradientDirection(itk::Vector<double,3> g) { m_DiffusionGradientDirection=g; } ///< Gradient direction is needed for eddy current simulation.
 
   protected:
     KspaceImageFilter();
     ~KspaceImageFilter() {}
 
     double CoilSensitivity(DoubleVectorType& pos);
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadID);
     void AfterThreadedGenerateData();
-    double InterpolateFmapValue(itk::Point<float, 3> itkP);
 
     DoubleVectorType                        m_CoilPosition;
     FiberfoxParameters<double>*             m_Parameters;
     std::vector< double >                   m_T2;
     std::vector< double >                   m_T1;
     std::vector< InputImagePointerType >    m_CompartmentImages;
     itk::Vector<double,3>                   m_DiffusionGradientDirection;
     double                                  m_Z;
     int                                     m_Zidx;
     bool                                    m_UseConstantRandSeed;
     unsigned int                            m_SpikesPerSlice;
     FiberBundle::Pointer                    m_FiberBundle;
     double                                  m_Gamma;
     DoubleVectorType                        m_Rotation;     ///< used to find correct point in frequency map (head motion)
     DoubleVectorType                        m_Translation;  ///< used to find correct point in frequency map (head motion)
 
     bool                                    m_IsBaseline;
     vcl_complex<double>                     m_Spike;
     MatrixType                              m_Transform;
     std::string                             m_SpikeLog;
 
     double                                  m_CoilSensitivityFactor;
     typename InputImageType::Pointer        m_KSpaceImage;
     typename InputImageType::Pointer        m_TimeFromEchoImage;
     typename InputImageType::Pointer        m_ReadoutTimeImage;
     AcquisitionType*                        m_ReadoutScheme;
 
+    itk::LinearInterpolateImageFunction< itk::Image< double, 3 >, float >::Pointer   m_FmapInterpolator;
+
   private:
 
   };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkKspaceImageFilter.cpp"
 #endif
 
 #endif //__itkKspaceImageFilter_h_
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
index 94a7e06a08..b86e42f2c7 100755
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
@@ -1,1735 +1,1668 @@
 /*===================================================================
 
 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 "itkTractsToDWIImageFilter.h"
 #include <boost/progress.hpp>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkKspaceImageFilter.h>
 #include <itkDftImageFilter.h>
 #include <itkAddImageFilter.h>
 #include <itkConstantPadImageFilter.h>
 #include <itkCropImageFilter.h>
 #include <mitkAstroStickModel.h>
 #include <vtkTransform.h>
 #include <iostream>
 #include <fstream>
 #include <exception>
 #include <itkImageDuplicator.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkTractDensityImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <itkTractsToVectorImageFilter.h>
 #include <itkInvertIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 #include <itkExtractImageFilter.h>
 #include <itkResampleDwiImageFilter.h>
 #include <boost/algorithm/string/replace.hpp>
 
 namespace itk
 {
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::TractsToDWIImageFilter()
     : m_FiberBundle(nullptr)
     , m_StatusText("")
     , m_UseConstantRandSeed(false)
     , m_RandGen(itk::Statistics::MersenneTwisterRandomVariateGenerator::New())
   {
     m_RandGen->SetSeed();
+    m_DoubleInterpolator = itk::LinearInterpolateImageFunction< ItkDoubleImgType, float >::New();
   }
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::~TractsToDWIImageFilter()
   {
 
   }
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::DoubleDwiType::Pointer TractsToDWIImageFilter< PixelType >::
   SimulateKspaceAcquisition( std::vector< DoubleDwiType::Pointer >& images )
   {
     unsigned int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     // create slice object
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, m_WorkingImageRegion.GetSize()[0]);
     sliceRegion.SetSize(1, m_WorkingImageRegion.GetSize()[1]);
     Vector< double, 2 > sliceSpacing;
     sliceSpacing[0] = m_WorkingSpacing[0];
     sliceSpacing[1] = m_WorkingSpacing[1];
 
     DoubleDwiType::PixelType nullPix; nullPix.SetSize(images.at(0)->GetVectorLength()); nullPix.Fill(0.0);
     auto magnitudeDwiImage = DoubleDwiType::New();
     magnitudeDwiImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     magnitudeDwiImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     magnitudeDwiImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     magnitudeDwiImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     magnitudeDwiImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     magnitudeDwiImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     magnitudeDwiImage->SetVectorLength( images.at(0)->GetVectorLength() );
     magnitudeDwiImage->Allocate();
     magnitudeDwiImage->FillBuffer(nullPix);
 
     m_PhaseImage = DoubleDwiType::New();
     m_PhaseImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     m_PhaseImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     m_PhaseImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_PhaseImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_PhaseImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_PhaseImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_PhaseImage->SetVectorLength( images.at(0)->GetVectorLength() );
     m_PhaseImage->Allocate();
     m_PhaseImage->FillBuffer(nullPix);
 
     m_KspaceImage = DoubleDwiType::New();
     m_KspaceImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     m_KspaceImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     m_KspaceImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_KspaceImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_KspaceImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_KspaceImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_KspaceImage->SetVectorLength( m_Parameters.m_SignalGen.m_NumberOfCoils );
     m_KspaceImage->Allocate();
     m_KspaceImage->FillBuffer(nullPix);
 
     std::vector< unsigned int > spikeVolume;
     for (unsigned int i=0; i<m_Parameters.m_SignalGen.m_Spikes; i++)
       spikeVolume.push_back(m_RandGen->GetIntegerVariate()%(images.at(0)->GetVectorLength()));
     std::sort (spikeVolume.begin(), spikeVolume.end());
     std::reverse (spikeVolume.begin(), spikeVolume.end());
 
     // calculate coil positions
     double a = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0)*m_Parameters.m_SignalGen.m_ImageSpacing[0];
     double b = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)*m_Parameters.m_SignalGen.m_ImageSpacing[1];
     double c = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(2)*m_Parameters.m_SignalGen.m_ImageSpacing[2];
     double diagonal = sqrt(a*a+b*b)/1000;   // image diagonal in m
 
     m_CoilPointset = mitk::PointSet::New();
     std::vector< itk::Vector<double, 3> > coilPositions;
     itk::Vector<double, 3> pos; pos.Fill(0.0); pos[1] = -diagonal/2;
     itk::Vector<double, 3> center;
     center[0] = a/2-m_Parameters.m_SignalGen.m_ImageSpacing[0]/2;
     center[1] = b/2-m_Parameters.m_SignalGen.m_ImageSpacing[2]/2;
     center[2] = c/2-m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
     for (int c=0; c<m_Parameters.m_SignalGen.m_NumberOfCoils; c++)
     {
       coilPositions.push_back(pos);
       m_CoilPointset->InsertPoint(c, pos*1000 + m_Parameters.m_SignalGen.m_ImageOrigin.GetVectorFromOrigin() + center );
 
       double rz = 360.0/m_Parameters.m_SignalGen.m_NumberOfCoils * M_PI/180;
       vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
       rotZ[0][0] = cos(rz);
       rotZ[1][1] = rotZ[0][0];
       rotZ[0][1] = -sin(rz);
       rotZ[1][0] = -rotZ[0][1];
 
       pos.SetVnlVector(rotZ*pos.GetVnlVector());
     }
 
     PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
     PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
     unsigned long lastTick = 0;
 
     boost::progress_display disp(images.at(0)->GetVectorLength()*images.at(0)->GetLargestPossibleRegion().GetSize(2));
     for (unsigned int g=0; g<images.at(0)->GetVectorLength(); g++)
     {
       std::vector< unsigned int > spikeSlice;
       while (!spikeVolume.empty() && spikeVolume.back()==g)
       {
         spikeSlice.push_back(m_RandGen->GetIntegerVariate()%images.at(0)->GetLargestPossibleRegion().GetSize(2));
         spikeVolume.pop_back();
       }
       std::sort (spikeSlice.begin(), spikeSlice.end());
       std::reverse (spikeSlice.begin(), spikeSlice.end());
 
       for (unsigned int z=0; z<images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
       {
         std::vector< SliceType::Pointer > compartmentSlices;
         std::vector< double > t2Vector;
         std::vector< double > t1Vector;
 
         for (unsigned int i=0; i<images.size(); i++)
         {
           DiffusionSignalModel<double>* signalModel;
           if (i<numFiberCompartments)
             signalModel = m_Parameters.m_FiberModelList.at(i);
           else
             signalModel = m_Parameters.m_NonFiberModelList.at(i-numFiberCompartments);
 
           auto slice = SliceType::New();
           slice->SetLargestPossibleRegion( sliceRegion );
           slice->SetBufferedRegion( sliceRegion );
           slice->SetRequestedRegion( sliceRegion );
           slice->SetSpacing(sliceSpacing);
           slice->Allocate();
           slice->FillBuffer(0.0);
 
           // extract slice from channel g
           for (unsigned int y=0; y<images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
             for (unsigned int x=0; x<images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
             {
               SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
               DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
               slice->SetPixel(index2D, images.at(i)->GetPixel(index3D)[g]);
             }
 
           compartmentSlices.push_back(slice);
           t2Vector.push_back(signalModel->GetT2());
           t1Vector.push_back(signalModel->GetT1());
         }
 
         int numSpikes = 0;
         while (!spikeSlice.empty() && spikeSlice.back()==z)
         {
           numSpikes++;
           spikeSlice.pop_back();
         }
         int spikeCoil = m_RandGen->GetIntegerVariate()%m_Parameters.m_SignalGen.m_NumberOfCoils;
 
         if (this->GetAbortGenerateData())
           return nullptr;
 
 #pragma omp parallel for
         for (int c=0; c<m_Parameters.m_SignalGen.m_NumberOfCoils; c++)
         {
           // create k-sapce (inverse fourier transform slices)
           auto idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
           idft->SetCompartmentImages(compartmentSlices);
           idft->SetT2(t2Vector);
           idft->SetT1(t1Vector);
           idft->SetUseConstantRandSeed(m_UseConstantRandSeed);
           idft->SetParameters(&m_Parameters);
           idft->SetZ((double)z-(double)( images.at(0)->GetLargestPossibleRegion().GetSize(2)
                                         -images.at(0)->GetLargestPossibleRegion().GetSize(2)%2 ) / 2.0);
           idft->SetZidx(z);
           idft->SetCoilPosition(coilPositions.at(c));
           idft->SetFiberBundle(m_FiberBundleWorkingCopy);
           idft->SetTranslation(m_Translations.at(g));
           idft->SetRotation(m_Rotations.at(g));
           idft->SetDiffusionGradientDirection(m_Parameters.m_SignalGen.GetGradientDirection(g));
           if (c==spikeCoil)
             idft->SetSpikesPerSlice(numSpikes);
           idft->Update();
 
 #pragma omp critical
           if (c==spikeCoil && numSpikes>0)
           {
             m_SpikeLog += "Volume " + boost::lexical_cast<std::string>(g) + " Coil " + boost::lexical_cast<std::string>(c) + "\n";
             m_SpikeLog += idft->GetSpikeLog();
           }
 
           ComplexSliceType::Pointer fSlice;
           fSlice = idft->GetOutput();
 
           // fourier transform slice
           ComplexSliceType::Pointer newSlice;
           auto dft = itk::DftImageFilter< SliceType::PixelType >::New();
           dft->SetInput(fSlice);
           dft->SetParameters(m_Parameters);
           dft->Update();
           newSlice = dft->GetOutput();
 
           // put slice back into channel g
           for (unsigned int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
             for (unsigned int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
             {
               DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
               ComplexSliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
               ComplexSliceType::PixelType cPix = newSlice->GetPixel(index2D);
               double magn = sqrt(cPix.real()*cPix.real()+cPix.imag()*cPix.imag());
               double phase = 0;
               if (cPix.real()!=0)
                 phase = atan( cPix.imag()/cPix.real() );
 
 
               DoubleDwiType::PixelType dwiPix = magnitudeDwiImage->GetPixel(index3D);
               DoubleDwiType::PixelType phasePix = m_PhaseImage->GetPixel(index3D);
 
               if (m_Parameters.m_SignalGen.m_NumberOfCoils>1)
               {
                 dwiPix[g] += magn*magn;
                 phasePix[g] += phase*phase;
               }
               else
               {
                 dwiPix[g] = magn;
                 phasePix[g] = phase;
               }
 
 #pragma omp critical
               {
                 magnitudeDwiImage->SetPixel(index3D, dwiPix);
                 m_PhaseImage->SetPixel(index3D, phasePix);
 
                 // k-space image
                 if (g==0)
                 {
                   DoubleDwiType::PixelType kspacePix = m_KspaceImage->GetPixel(index3D);
                   kspacePix[c] = idft->GetKSpaceImage()->GetPixel(index2D);
                   m_KspaceImage->SetPixel(index3D, kspacePix);
                 }
               }
             }
         }
 
         if (m_Parameters.m_SignalGen.m_NumberOfCoils>1)
         {
 #ifdef WIN32
 #pragma omp parallel for
 #else
 #pragma omp parallel for collapse(2)
 #endif
           for (int y=0; y<static_cast<int>(magnitudeDwiImage->GetLargestPossibleRegion().GetSize(1)); y++)
             for (int x=0; x<static_cast<int>(magnitudeDwiImage->GetLargestPossibleRegion().GetSize(0)); x++)
             {
               DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
               DoubleDwiType::PixelType magPix = magnitudeDwiImage->GetPixel(index3D);
               magPix[g] = sqrt(magPix[g]/m_Parameters.m_SignalGen.m_NumberOfCoils);
 
               DoubleDwiType::PixelType phasePix = m_PhaseImage->GetPixel(index3D);
               phasePix[g] = sqrt(phasePix[g]/m_Parameters.m_SignalGen.m_NumberOfCoils);
 
 #pragma omp critical
               {
                 magnitudeDwiImage->SetPixel(index3D, magPix);
                 m_PhaseImage->SetPixel(index3D, phasePix);
               }
             }
         }
 
         ++disp;
         unsigned long newTick = 50*disp.count()/disp.expected_count();
         for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
           PrintToLog("*", false, false, false);
         lastTick = newTick;
       }
     }
     PrintToLog("\n", false);
     return magnitudeDwiImage;
   }
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::ItkDoubleImgType::Pointer TractsToDWIImageFilter< PixelType >::
   NormalizeInsideMask(ItkDoubleImgType::Pointer image)
   {
     double max = itk::NumericTraits< double >::min();
     double min = itk::NumericTraits< double >::max();
 
     itk::ImageRegionIterator< ItkDoubleImgType > it(image, image->GetLargestPossibleRegion());
     while(!it.IsAtEnd())
     {
       if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull() && m_Parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
       {
         it.Set(0.0);
         ++it;
         continue;
       }
       //        if (it.Get()>900)
       //            it.Set(900);
 
       if (it.Get()>max)
         max = it.Get();
       if (it.Get()<min)
         min = it.Get();
       ++it;
     }
     auto scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
     scaler->SetInput(image);
     scaler->SetShift(-min);
     scaler->SetScale(1.0/(max-min));
     scaler->Update();
     return scaler->GetOutput();
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::CheckVolumeFractionImages()
   {
     m_UseRelativeNonFiberVolumeFractions = false;
 
     // check for fiber volume fraction maps
     unsigned int fibVolImages = 0;
     for (std::size_t i=0; i<m_Parameters.m_FiberModelList.size(); i++)
     {
       if (m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage().IsNotNull())
       {
         PrintToLog("Using volume fraction map for fiber compartment " + boost::lexical_cast<std::string>(i+1));
         fibVolImages++;
       }
     }
 
     // check for non-fiber volume fraction maps
     unsigned int nonfibVolImages = 0;
     for (std::size_t i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
     {
       if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNotNull())
       {
         PrintToLog("Using volume fraction map for non-fiber compartment " + boost::lexical_cast<std::string>(i+1));
         nonfibVolImages++;
       }
     }
 
     // not all fiber compartments are using volume fraction maps
     // --> non-fiber volume fractions are assumed to be relative to the
     // non-fiber volume and not absolute voxel-volume fractions.
     // this means if two non-fiber compartments are used but only one of them
     // has an associated volume fraction map, the repesctive other volume fraction map
     // can be determined as inverse (1-val) of the present volume fraction map-
     if ( fibVolImages<m_Parameters.m_FiberModelList.size() && nonfibVolImages==1 && m_Parameters.m_NonFiberModelList.size()==2)
     {
       PrintToLog("Calculating missing non-fiber volume fraction image by inverting the other.\n"
                  "Assuming non-fiber volume fraction images to contain values relative to the"
                  " remaining non-fiber volume, not absolute values.");
 
       auto inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
       inverter->SetMaximum(1.0);
       if ( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage().IsNull()
            && m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage().IsNotNull() )
       {
         // m_Parameters.m_NonFiberModelList[1]->SetVolumeFractionImage(
         // NormalizeInsideMask( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage() ) );
         inverter->SetInput( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage() );
         inverter->Update();
         m_Parameters.m_NonFiberModelList[0]->SetVolumeFractionImage(inverter->GetOutput());
       }
       else if ( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage().IsNull()
                 && m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage().IsNotNull() )
       {
         // m_Parameters.m_NonFiberModelList[0]->SetVolumeFractionImage(
         // NormalizeInsideMask( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage() ) );
         inverter->SetInput( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage() );
         inverter->Update();
         m_Parameters.m_NonFiberModelList[1]->SetVolumeFractionImage(inverter->GetOutput());
       }
       else
       {
         itkExceptionMacro("Something went wrong in automatically calculating the missing non-fiber volume fraction image!"
                           " Did you use two non fiber compartments but only one volume fraction image?"
                           " Then it should work and this error is really strange.");
       }
       m_UseRelativeNonFiberVolumeFractions = true;
 
       nonfibVolImages++;
     }
 
     // Up to two fiber compartments are allowed without volume fraction maps since the volume fractions can then be determined automatically
     if (m_Parameters.m_FiberModelList.size()>2
         && fibVolImages!=m_Parameters.m_FiberModelList.size())
       itkExceptionMacro("More than two fiber compartment selected but no corresponding volume fraction maps set!");
 
     // One non-fiber compartment is allowed without volume fraction map since the volume fraction can then be determined automatically
     if (m_Parameters.m_NonFiberModelList.size()>1
         && nonfibVolImages!=m_Parameters.m_NonFiberModelList.size())
       itkExceptionMacro("More than one non-fiber compartment selected but no volume fraction maps set!");
 
     if (fibVolImages<m_Parameters.m_FiberModelList.size() && nonfibVolImages>0)
     {
       PrintToLog("Not all fiber compartments are using an associated volume fraction image.\n"
                  "Assuming non-fiber volume fraction images to contain values relative to the"
                  " remaining non-fiber volume, not absolute values.");
       m_UseRelativeNonFiberVolumeFractions = true;
 
       //        itk::ImageFileWriter<ItkDoubleImgType>::Pointer wr = itk::ImageFileWriter<ItkDoubleImgType>::New();
       //        wr->SetInput(m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage());
       //        wr->SetFileName("/local/volumefraction.nrrd");
       //        wr->Update();
     }
 
     // initialize the images that store the output volume fraction of each compartment
     m_VolumeFractions.clear();
     for (std::size_t i=0; i<m_Parameters.m_FiberModelList.size()+m_Parameters.m_NonFiberModelList.size(); i++)
     {
       auto doubleImg = ItkDoubleImgType::New();
       doubleImg->SetSpacing( m_WorkingSpacing );
       doubleImg->SetOrigin( m_WorkingOrigin );
       doubleImg->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       doubleImg->SetLargestPossibleRegion( m_WorkingImageRegion );
       doubleImg->SetBufferedRegion( m_WorkingImageRegion );
       doubleImg->SetRequestedRegion( m_WorkingImageRegion );
       doubleImg->Allocate();
       doubleImg->FillBuffer(0);
       m_VolumeFractions.push_back(doubleImg);
     }
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::InitializeData()
   {
     m_Rotations.clear();
     m_Translations.clear();
     m_MotionLog = "";
     m_SpikeLog = "";
 
     // initialize output dwi image
     m_Parameters.m_SignalGen.m_CroppedRegion = m_Parameters.m_SignalGen.m_ImageRegion;
     m_Parameters.m_SignalGen.m_CroppedRegion.SetSize( 1, m_Parameters.m_SignalGen.m_CroppedRegion.GetSize(1)
                                                       *m_Parameters.m_SignalGen.m_CroppingFactor);
 
     itk::Point<double,3> shiftedOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
     shiftedOrigin[1] += (m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)
                          -m_Parameters.m_SignalGen.m_CroppedRegion.GetSize(1))*m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
 
     m_OutputImage = OutputImageType::New();
     m_OutputImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     m_OutputImage->SetOrigin( shiftedOrigin );
     m_OutputImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_OutputImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_OutputImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_OutputImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_OutputImage->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     m_OutputImage->Allocate();
     typename OutputImageType::PixelType temp;
     temp.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     temp.Fill(0.0);
     m_OutputImage->FillBuffer(temp);
 
     // Apply in-plane upsampling for Gibbs ringing artifact
     double upsampling = 1;
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
       upsampling = 2;
     m_WorkingSpacing = m_Parameters.m_SignalGen.m_ImageSpacing;
     m_WorkingSpacing[0] /= upsampling;
     m_WorkingSpacing[1] /= upsampling;
     m_WorkingImageRegion = m_Parameters.m_SignalGen.m_ImageRegion;
     m_WorkingImageRegion.SetSize(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[0]*upsampling);
     m_WorkingImageRegion.SetSize(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[1]*upsampling);
     m_WorkingOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
     m_WorkingOrigin[0] -= m_Parameters.m_SignalGen.m_ImageSpacing[0]/2;
     m_WorkingOrigin[0] += m_WorkingSpacing[0]/2;
     m_WorkingOrigin[1] -= m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
     m_WorkingOrigin[1] += m_WorkingSpacing[1]/2;
     m_WorkingOrigin[2] -= m_Parameters.m_SignalGen.m_ImageSpacing[2]/2;
     m_WorkingOrigin[2] += m_WorkingSpacing[2]/2;
     m_VoxelVolume = m_WorkingSpacing[0]*m_WorkingSpacing[1]*m_WorkingSpacing[2];
 
     // generate double images to store the individual compartment signals
     m_CompartmentImages.clear();
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
     for (int i=0; i<numFiberCompartments+numNonFiberCompartments; i++)
     {
       auto doubleDwi = DoubleDwiType::New();
       doubleDwi->SetSpacing( m_WorkingSpacing );
       doubleDwi->SetOrigin( m_WorkingOrigin );
       doubleDwi->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       doubleDwi->SetLargestPossibleRegion( m_WorkingImageRegion );
       doubleDwi->SetBufferedRegion( m_WorkingImageRegion );
       doubleDwi->SetRequestedRegion( m_WorkingImageRegion );
       doubleDwi->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
       doubleDwi->Allocate();
       DoubleDwiType::PixelType pix;
       pix.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
       pix.Fill(0.0);
       doubleDwi->FillBuffer(pix);
       m_CompartmentImages.push_back(doubleDwi);
     }
 
     if (m_FiberBundle.IsNull() && m_InputImage.IsNotNull())
     {
       m_CompartmentImages.clear();
 
       m_Parameters.m_SignalGen.m_DoAddMotion = false;
       m_Parameters.m_SignalGen.m_DoSimulateRelaxation = false;
 
       PrintToLog("Simulating acquisition for input diffusion-weighted image.", false);
       auto caster = itk::CastImageFilter< OutputImageType, DoubleDwiType >::New();
       caster->SetInput(m_InputImage);
       caster->Update();
 
       if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
       {
         PrintToLog("Upsampling input diffusion-weighted image for Gibbs ringing simulation.", false);
 
         auto resampler = itk::ResampleDwiImageFilter< double >::New();
         resampler->SetInput(caster->GetOutput());
         itk::Vector< double, 3 > samplingFactor;
         samplingFactor[0] = upsampling;
         samplingFactor[1] = upsampling;
         samplingFactor[2] = 1;
         resampler->SetSamplingFactor(samplingFactor);
         resampler->SetInterpolation(itk::ResampleDwiImageFilter< double >::Interpolate_WindowedSinc);
         resampler->Update();
         m_CompartmentImages.push_back(resampler->GetOutput());
       }
       else
         m_CompartmentImages.push_back(caster->GetOutput());
 
       for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
       {
         m_Rotation.Fill(0.0);
         m_Translation.Fill(0.0);
         m_Rotations.push_back(m_Rotation);
         m_Translations.push_back(m_Translation);
       }
     }
 
     // resample mask image and frequency map to fit upsampled geometry
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
     {
       if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull())
       {
         // rescale mask image (otherwise there are problems with the resampling)
         auto rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
         rescaler->SetInput(0,m_Parameters.m_SignalGen.m_MaskImage);
         rescaler->SetOutputMaximum(100);
         rescaler->SetOutputMinimum(0);
         rescaler->Update();
 
         // resample mask image
         auto resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
         resampler->SetInput(rescaler->GetOutput());
         resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
         resampler->SetSize(m_WorkingImageRegion.GetSize());
         resampler->SetOutputSpacing(m_WorkingSpacing);
         resampler->SetOutputOrigin(m_WorkingOrigin);
         auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
         resampler->SetInterpolator(nn_interpolator);
         resampler->Update();
         m_Parameters.m_SignalGen.m_MaskImage = resampler->GetOutput();
       }
       // resample frequency map
       if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
       {
         auto resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
         resampler->SetInput(m_Parameters.m_SignalGen.m_FrequencyMap);
         resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_FrequencyMap);
         resampler->SetSize(m_WorkingImageRegion.GetSize());
         resampler->SetOutputSpacing(m_WorkingSpacing);
         resampler->SetOutputOrigin(m_WorkingOrigin);
         auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkDoubleImgType, double>::New();
         resampler->SetInterpolator(nn_interpolator);
         resampler->Update();
         m_Parameters.m_SignalGen.m_FrequencyMap = resampler->GetOutput();
       }
     }
 
     m_MaskImageSet = true;
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNull())
     {
       // no input tissue mask is set -> create default
       PrintToLog("No tissue mask set", false);
       m_Parameters.m_SignalGen.m_MaskImage = ItkUcharImgType::New();
       m_Parameters.m_SignalGen.m_MaskImage->SetSpacing( m_WorkingSpacing );
       m_Parameters.m_SignalGen.m_MaskImage->SetOrigin( m_WorkingOrigin );
       m_Parameters.m_SignalGen.m_MaskImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       m_Parameters.m_SignalGen.m_MaskImage->SetLargestPossibleRegion( m_WorkingImageRegion );
       m_Parameters.m_SignalGen.m_MaskImage->SetBufferedRegion( m_WorkingImageRegion );
       m_Parameters.m_SignalGen.m_MaskImage->SetRequestedRegion( m_WorkingImageRegion );
       m_Parameters.m_SignalGen.m_MaskImage->Allocate();
       m_Parameters.m_SignalGen.m_MaskImage->FillBuffer(100);
       m_MaskImageSet = false;
     }
     else
     {
       if (m_Parameters.m_SignalGen.m_MaskImage->GetLargestPossibleRegion()!=m_WorkingImageRegion)
       {
         itkExceptionMacro("Mask image and specified DWI geometry are not matching!");
       }
       PrintToLog("Using tissue mask", false);
     }
 
     if (m_Parameters.m_SignalGen.m_DoAddMotion)
     {
       if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
       {
         PrintToLog("Random motion artifacts:", false);
         PrintToLog("Maximum rotation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°", false);
         PrintToLog("Maximum translation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm", false);
       }
       else
       {
         PrintToLog("Linear motion artifacts:", false);
         PrintToLog("Maximum rotation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°", false);
         PrintToLog("Maximum translation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm", false);
       }
     }
     if ( m_Parameters.m_SignalGen.m_MotionVolumes.empty() )
     {
       // no motion in first volume
       m_Parameters.m_SignalGen.m_MotionVolumes.push_back(false);
 
       // motion in all other volumes
       while ( m_Parameters.m_SignalGen.m_MotionVolumes.size() < m_Parameters.m_SignalGen.GetNumVolumes() )
       {
         m_Parameters.m_SignalGen.m_MotionVolumes.push_back(true);
       }
     }
     // we need to know for every volume if there is motion. if this information is missing, then set corresponding fal to false
     while ( m_Parameters.m_SignalGen.m_MotionVolumes.size()<m_Parameters.m_SignalGen.GetNumVolumes() )
     {
       m_Parameters.m_SignalGen.m_MotionVolumes.push_back(false);
     }
 
     m_NumMotionVolumes = 0;
     for (unsigned int i=0; i<m_Parameters.m_SignalGen.GetNumVolumes(); ++i)
     {
       if (m_Parameters.m_SignalGen.m_MotionVolumes[i])
         ++m_NumMotionVolumes;
     }
     m_MotionCounter = 0;
 
     // creat image to hold transformed mask (motion artifact)
     m_TransformedMaskImage = ItkUcharImgType::New();
     auto duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
     duplicator->SetInputImage(m_Parameters.m_SignalGen.m_MaskImage);
     duplicator->Update();
     m_TransformedMaskImage = duplicator->GetOutput();
 
     // second upsampling needed for motion artifacts
     ImageRegion<3>      upsampledImageRegion = m_WorkingImageRegion;
     DoubleVectorType    upsampledSpacing = m_WorkingSpacing;
     upsampledSpacing[0] /= 4;
     upsampledSpacing[1] /= 4;
     upsampledSpacing[2] /= 4;
     upsampledImageRegion.SetSize(0, m_WorkingImageRegion.GetSize()[0]*4);
     upsampledImageRegion.SetSize(1, m_WorkingImageRegion.GetSize()[1]*4);
     upsampledImageRegion.SetSize(2, m_WorkingImageRegion.GetSize()[2]*4);
     itk::Point<double,3> upsampledOrigin = m_WorkingOrigin;
     upsampledOrigin[0] -= m_WorkingSpacing[0]/2;
     upsampledOrigin[0] += upsampledSpacing[0]/2;
     upsampledOrigin[1] -= m_WorkingSpacing[1]/2;
     upsampledOrigin[1] += upsampledSpacing[1]/2;
     upsampledOrigin[2] -= m_WorkingSpacing[2]/2;
     upsampledOrigin[2] += upsampledSpacing[2]/2;
 
     m_UpsampledMaskImage = ItkUcharImgType::New();
     auto upsampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
     upsampler->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
     upsampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
     upsampler->SetSize(upsampledImageRegion.GetSize());
     upsampler->SetOutputSpacing(upsampledSpacing);
     upsampler->SetOutputOrigin(upsampledOrigin);
 
     auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
     upsampler->SetInterpolator(nn_interpolator);
     upsampler->Update();
     m_UpsampledMaskImage = upsampler->GetOutput();
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::InitializeFiberData()
   {
     // resample fiber bundle for sufficient voxel coverage
     PrintToLog("Resampling fibers ...");
     m_SegmentVolume = 0.0001;
     float minSpacing = 1;
     if( m_WorkingSpacing[0]<m_WorkingSpacing[1]
         && m_WorkingSpacing[0]<m_WorkingSpacing[2])
     {
       minSpacing = m_WorkingSpacing[0];
     }
     else if (m_WorkingSpacing[1] < m_WorkingSpacing[2])
     {
       minSpacing = m_WorkingSpacing[1];
     }
     else
     {
       minSpacing = m_WorkingSpacing[2];
     }
 
     // working copy is needed because we need to resample the fibers but do not want to change the original bundle
     m_FiberBundleWorkingCopy = m_FiberBundle->GetDeepCopy();
     double volumeAccuracy = 10;
     m_FiberBundleWorkingCopy->ResampleLinear(minSpacing/volumeAccuracy);
     m_mmRadius = m_Parameters.m_SignalGen.m_AxonRadius/1000;
 
     auto caster = itk::CastImageFilter< itk::Image<unsigned char, 3>, itk::Image<float, 3> >::New();
     caster->SetInput(m_TransformedMaskImage);
     caster->Update();
 
     auto density_calculator = itk::TractDensityImageFilter< itk::Image<float, 3> >::New();
     density_calculator->SetFiberBundle(m_FiberBundleWorkingCopy);
     density_calculator->SetInputImage(caster->GetOutput());
     density_calculator->SetBinaryOutput(false);
     density_calculator->SetUseImageGeometry(true);
     density_calculator->SetDoFiberResampling(false);
     density_calculator->SetOutputAbsoluteValues(true);
     density_calculator->SetWorkOnFiberCopy(false);
     density_calculator->Update();
     float max_density = density_calculator->GetMaxDensity();
 
     if (m_mmRadius>0)
     {
       m_SegmentVolume = M_PI*m_mmRadius*m_mmRadius*minSpacing/volumeAccuracy;
       std::stringstream stream;
       stream << std::fixed << setprecision(2) << max_density * m_SegmentVolume;
       std::string s = stream.str();
       PrintToLog("\nMax. fiber volume: " + s + "mm².", false, true, true);
     }
     else
     {
       std::stringstream stream;
       stream << std::fixed << setprecision(2) << max_density * m_SegmentVolume;
       std::string s = stream.str();
       PrintToLog("\nMax. fiber volume: " + s + "mm² (before rescaling to voxel volume).", false, true, true);
     }
     float voxel_volume = m_WorkingSpacing[0]*m_WorkingSpacing[1]*m_WorkingSpacing[2];
     float new_seg_vol = voxel_volume/max_density;
     float new_fib_radius = 1000*std::sqrt(new_seg_vol*volumeAccuracy/(minSpacing*M_PI));
     std::stringstream stream;
     stream << std::fixed << setprecision(2) << new_fib_radius;
     std::string s = stream.str();
     PrintToLog("\nA full fiber voxel corresponds to a fiber radius of ~" + s + "µm, given the current fiber configuration.", false, true, true);
 
     // a second fiber bundle is needed to store the transformed version of the m_FiberBundleWorkingCopy
     m_FiberBundleTransformed = m_FiberBundleWorkingCopy;
   }
 
 
   template< class PixelType >
   bool TractsToDWIImageFilter< PixelType >::PrepareLogFile()
   {
     assert( ! m_Logfile.is_open() );
 
     std::string filePath;
     std::string fileName;
 
     // Get directory name:
     if (m_Parameters.m_Misc.m_OutputPath.size() > 0)
     {
       filePath = m_Parameters.m_Misc.m_OutputPath;
       if( *(--(filePath.cend())) != '/')
       {
         filePath.push_back('/');
       }
     }
     else
     {
       filePath = mitk::IOUtil::GetTempPath() + '/';
     }
     // check if directory exists, else use /tmp/:
     if( itksys::SystemTools::FileIsDirectory( filePath ) )
     {
       while( *(--(filePath.cend())) == '/')
       {
         filePath.pop_back();
       }
       filePath = filePath + '/';
     }
     else
     {
       filePath = mitk::IOUtil::GetTempPath() + '/';
     }
 
     // Get file name:
     if( ! m_Parameters.m_Misc.m_ResultNode->GetName().empty() )
     {
       fileName = m_Parameters.m_Misc.m_ResultNode->GetName();
     }
     else
     {
       fileName = "";
     }
 
     if( ! m_Parameters.m_Misc.m_OutputPrefix.empty() )
     {
       fileName = m_Parameters.m_Misc.m_OutputPrefix + fileName;
     }
     else
     {
       fileName = "fiberfox";
     }
 
     // check if file already exists and DO NOT overwrite existing files:
     std::string NameTest = fileName;
     int c = 0;
     while( itksys::SystemTools::FileExists( filePath + '/' + fileName + ".log" )
            && c <= std::numeric_limits<int>::max() )
     {
       fileName = NameTest + "_" + boost::lexical_cast<std::string>(c);
       ++c;
     }
 
     try
     {
       m_Logfile.open( ( filePath + '/' + fileName + ".log" ).c_str() );
     }
     catch (const std::ios_base::failure &fail)
     {
       MITK_ERROR << "itkTractsToDWIImageFilter.cpp: Exception " << fail.what()
                  << " while trying to open file" << filePath << '/' << fileName << ".log";
       return false;
     }
 
     if ( m_Logfile.is_open() )
     {
       PrintToLog( "Logfile: " + filePath + '/' + fileName + ".log", false );
       return true;
     }
     else
     {
       m_StatusText += "Logfile could not be opened!\n";
       MITK_ERROR << "itkTractsToDWIImageFilter.cpp: Logfile could not be opened!";
       return false;
     }
   }
 
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::GenerateData()
   {
     // prepare logfile
     if ( ! PrepareLogFile() )
     {
       this->SetAbortGenerateData( true );
       return;
     }
 
     m_TimeProbe.Start();
 
     // check input data
     if (m_FiberBundle.IsNull() && m_InputImage.IsNull())
       itkExceptionMacro("Input fiber bundle and input diffusion-weighted image is nullptr!");
 
     if (m_Parameters.m_FiberModelList.empty() && m_InputImage.IsNull())
       itkExceptionMacro("No diffusion model for fiber compartments defined and input diffusion-weighted"
                         " image is nullptr! At least one fiber compartment is necessary to simulate diffusion.");
 
     if (m_Parameters.m_NonFiberModelList.empty() && m_InputImage.IsNull())
       itkExceptionMacro("No diffusion model for non-fiber compartments defined and input diffusion-weighted"
                         " image is nullptr! At least one non-fiber compartment is necessary to simulate diffusion.");
 
     int baselineIndex = m_Parameters.m_SignalGen.GetFirstBaselineIndex();
     if (baselineIndex<0) { itkExceptionMacro("No baseline index found!"); }
 
     if (!m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition)  // No upsampling of input image needed if no k-space simulation is performed
     {
       m_Parameters.m_SignalGen.m_DoAddGibbsRinging = false;
     }
 
     if (m_UseConstantRandSeed)  // always generate the same random numbers?
     { m_RandGen->SetSeed(0); }
     else { m_RandGen->SetSeed(); }
 
     InitializeData();
     if ( m_FiberBundle.IsNotNull() )    // if no fiber bundle is found, we directly proceed to the k-space acquisition simulation
     {
       CheckVolumeFractionImages();
       InitializeFiberData();
 
       int numFiberCompartments = m_Parameters.m_FiberModelList.size();
       int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
       double maxVolume = 0;
       unsigned long lastTick = 0;
       int signalModelSeed = m_RandGen->GetIntegerVariate();
 
       PrintToLog("\n", false, false);
       PrintToLog("Generating " + boost::lexical_cast<std::string>(numFiberCompartments+numNonFiberCompartments)
                  + "-compartment diffusion-weighted signal.");
 
       std::vector< int > bVals = m_Parameters.m_SignalGen.GetBvalues();
       PrintToLog("b-values: ", false, false, true);
       for (auto v : bVals)
         PrintToLog(boost::lexical_cast<std::string>(v) + " ", false, false, true);
       PrintToLog("\n", false, false, true);
       PrintToLog("\n", false, false, true);
 
       int numFibers = m_FiberBundleWorkingCopy->GetNumFibers();
       boost::progress_display disp(numFibers*m_Parameters.m_SignalGen.GetNumVolumes());
 
       PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
       PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
 
       for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
       {
         // move fibers
         SimulateMotion(g);
 
         // Set signal model random generator seeds to get same configuration in each voxel
         for (std::size_t i=0; i<m_Parameters.m_FiberModelList.size(); i++)
           m_Parameters.m_FiberModelList.at(i)->SetSeed(signalModelSeed);
         for (std::size_t i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
           m_Parameters.m_NonFiberModelList.at(i)->SetSeed(signalModelSeed);
 
         // storing voxel-wise intra-axonal volume in mm³
         auto intraAxonalVolumeImage = ItkDoubleImgType::New();
         intraAxonalVolumeImage->SetSpacing( m_WorkingSpacing );
         intraAxonalVolumeImage->SetOrigin( m_WorkingOrigin );
         intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         intraAxonalVolumeImage->SetLargestPossibleRegion( m_WorkingImageRegion );
         intraAxonalVolumeImage->SetBufferedRegion( m_WorkingImageRegion );
         intraAxonalVolumeImage->SetRequestedRegion( m_WorkingImageRegion );
         intraAxonalVolumeImage->Allocate();
         intraAxonalVolumeImage->FillBuffer(0);
         maxVolume = 0;
 
         vtkPolyData* fiberPolyData = m_FiberBundleTransformed->GetFiberPolyData();
         // generate fiber signal (if there are any fiber models present)
         if (!m_Parameters.m_FiberModelList.empty())
           for( int i=0; i<numFibers; i++ )
           {
             float fiberWeight = m_FiberBundleTransformed->GetFiberWeight(i);
             vtkCell* cell = fiberPolyData->GetCell(i);
             int numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             if (numPoints<2)
               continue;
 
             for( int j=0; j<numPoints; j++)
             {
               if (this->GetAbortGenerateData())
               {
                 PrintToLog("\n", false, false);
                 PrintToLog("Simulation aborted");
                 return;
               }
 
               double* temp = points->GetPoint(j);
               itk::Point<float, 3> vertex = GetItkPoint(temp);
               itk::Vector<double> v = GetItkVector(temp);
 
               itk::Vector<double, 3> dir(3);
               if (j<numPoints-1) { dir = GetItkVector(points->GetPoint(j+1))-v; }
               else { dir = v-GetItkVector(points->GetPoint(j-1)); }
 
               if ( dir.GetSquaredNorm()<0.0001 || dir[0]!=dir[0] || dir[1]!=dir[1] || dir[2]!=dir[2] )
               {
                 continue;
               }
 
               itk::Index<3> idx;
               itk::ContinuousIndex<float, 3> contIndex;
               m_TransformedMaskImage->TransformPhysicalPointToIndex(vertex, idx);
               m_TransformedMaskImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
               if (!m_TransformedMaskImage->GetLargestPossibleRegion().IsInside(idx) || m_TransformedMaskImage->GetPixel(idx)<=0)
               {
                 continue;
               }
 
               // generate signal for each fiber compartment
               for (int k=0; k<numFiberCompartments; k++)
               {
                 m_Parameters.m_FiberModelList[k]->SetFiberDirection(dir);
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(k)->GetPixel(idx);
                 pix[g] += fiberWeight*m_SegmentVolume*m_Parameters.m_FiberModelList[k]->SimulateMeasurement(g);
                 m_CompartmentImages.at(k)->SetPixel(idx, pix);
               }
 
               // update fiber volume image
               double vol = intraAxonalVolumeImage->GetPixel(idx) + m_SegmentVolume*fiberWeight;
               intraAxonalVolumeImage->SetPixel(idx, vol);
 
               // we assume that the first volume is always unweighted!
               if (vol>maxVolume) { maxVolume = vol; }
             }
 
             // progress report
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
             {
               PrintToLog("*", false, false, false);
             }
             lastTick = newTick;
           }
 
         // generate non-fiber signal
         ImageRegionIterator<ItkUcharImgType> it3(m_TransformedMaskImage, m_TransformedMaskImage->GetLargestPossibleRegion());
         double fact = 1;    // density correction factor in mm³
         if (m_Parameters.m_SignalGen.m_AxonRadius<0.0001 || maxVolume>m_VoxelVolume)    // the fullest voxel is always completely full
           fact = m_VoxelVolume/maxVolume;
 
         while(!it3.IsAtEnd())
         {
           if (it3.Get()>0)
           {
             DoubleDwiType::IndexType index = it3.GetIndex();
             itk::Point<double, 3> point;
             m_TransformedMaskImage->TransformIndexToPhysicalPoint(index, point);
             if ( m_Parameters.m_SignalGen.m_DoAddMotion && g>=0 && m_Parameters.m_SignalGen.m_MotionVolumes[g] )
             {
               if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
               {
                 point = m_FiberBundleWorkingCopy->TransformPoint( point.GetVnlVector(), -m_Rotation[0], -m_Rotation[1], -m_Rotation[2],
                                                                   -m_Translation[0], -m_Translation[1], -m_Translation[2] );
               }
               else
               {
                 point = m_FiberBundleWorkingCopy->TransformPoint( point.GetVnlVector(),
                     -m_Rotation[0]*m_MotionCounter, -m_Rotation[1]*m_MotionCounter, -m_Rotation[2]*m_MotionCounter,
                     -m_Translation[0]*m_MotionCounter, -m_Translation[1]*m_MotionCounter, -m_Translation[2]*m_MotionCounter );
               }
             }
 
             double iAxVolume = intraAxonalVolumeImage->GetPixel(index);
 
             // if volume fraction image is set use it, otherwise use scaling factor to obtain one full fiber voxel
             double fact2 = fact;
             if ( m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage()!=nullptr && iAxVolume>0.0001 )
             {
-              double val = InterpolateValue(point, m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage());
+              m_DoubleInterpolator->SetInputImage(m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage());
+              double val = mitk::imv::GetImageValue<double>(point, true, m_DoubleInterpolator);
               if (val<0)
                 mitkThrow() << "Volume fraction image (index 1) contains negative values (intra-axonal compartment)!";
               fact2 = m_VoxelVolume*val/iAxVolume;
             }
 
             // adjust intra-axonal image value
             for (int i=0; i<numFiberCompartments; i++)
             {
               DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
               pix[g] *= fact2;
               m_CompartmentImages.at(i)->SetPixel(index, pix);
             }
 
             // simulate other compartments
             SimulateExtraAxonalSignal(index, iAxVolume*fact2, g);
           }
           ++it3;
         }
       }
 
       PrintToLog("\n", false);
       if (this->GetAbortGenerateData())
       {
         PrintToLog("\n", false, false);
         PrintToLog("Simulation aborted");
         return;
       }
     }
 
     DoubleDwiType::Pointer doubleOutImage;
     double signalScale = m_Parameters.m_SignalGen.m_SignalScale;
     if ( m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition ) // do k-space stuff
     {
       PrintToLog("\n", false, false);
       PrintToLog("Simulating k-space acquisition using "
                  +boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_NumberOfCoils)
                  +" coil(s)");
 
       switch (m_Parameters.m_SignalGen.m_AcquisitionType)
       {
         case SignalGenerationParameters::SingleShotEpi:
         {
           PrintToLog("Acquisition type: single shot EPI", false);
           break;
         }
         case SignalGenerationParameters::SpinEcho:
         {
           PrintToLog("Acquisition type: classic spin echo with cartesian k-space trajectory", false);
           break;
         }
         default:
         {
           PrintToLog("Acquisition type: single shot EPI", false);
           break;
         }
       }
 
       if (m_Parameters.m_SignalGen.m_NoiseVariance>0)
         PrintToLog("Simulating complex Gaussian noise", false);
       if (m_Parameters.m_SignalGen.m_DoSimulateRelaxation)
         PrintToLog("Simulating signal relaxation", false);
       if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
         PrintToLog("Simulating distortions", false);
       if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
         PrintToLog("Simulating ringing artifacts", false);
       if (m_Parameters.m_SignalGen.m_EddyStrength>0)
         PrintToLog("Simulating eddy currents", false);
       if (m_Parameters.m_SignalGen.m_Spikes>0)
         PrintToLog("Simulating spikes", false);
       if (m_Parameters.m_SignalGen.m_CroppingFactor<1.0)
         PrintToLog("Simulating aliasing artifacts", false);
       if (m_Parameters.m_SignalGen.m_KspaceLineOffset>0)
         PrintToLog("Simulating ghosts", false);
 
       doubleOutImage = SimulateKspaceAcquisition(m_CompartmentImages);
       signalScale = 1; // already scaled in SimulateKspaceAcquisition()
     }
     else    // don't do k-space stuff, just sum compartments
     {
       PrintToLog("Summing compartments");
       doubleOutImage = m_CompartmentImages.at(0);
 
       for (unsigned int i=1; i<m_CompartmentImages.size(); i++)
       {
         auto adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
         adder->SetInput1(doubleOutImage);
         adder->SetInput2(m_CompartmentImages.at(i));
         adder->Update();
         doubleOutImage = adder->GetOutput();
       }
     }
     if (this->GetAbortGenerateData())
     {
       PrintToLog("\n", false, false);
       PrintToLog("Simulation aborted");
       return;
     }
 
     PrintToLog("Finalizing image");
     if (signalScale>1)
       PrintToLog(" Scaling signal", false);
     if (m_Parameters.m_NoiseModel)
       PrintToLog(" Adding noise", false);
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<OutputImageType> it4 (m_OutputImage, m_OutputImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     boost::progress_display disp2(m_OutputImage->GetLargestPossibleRegion().GetNumberOfPixels());
 
     PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
     PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
     int lastTick = 0;
 
     while(!it4.IsAtEnd())
     {
       if (this->GetAbortGenerateData())
       {
         PrintToLog("\n", false, false);
         PrintToLog("Simulation aborted");
         return;
       }
 
       ++disp2;
       unsigned long newTick = 50*disp2.count()/disp2.expected_count();
       for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
         PrintToLog("*", false, false, false);
       lastTick = newTick;
 
       typename OutputImageType::IndexType index = it4.GetIndex();
       signal = doubleOutImage->GetPixel(index)*signalScale;
 
       if (m_Parameters.m_NoiseModel)
         m_Parameters.m_NoiseModel->AddNoise(signal);
 
       for (unsigned int i=0; i<signal.Size(); i++)
       {
         if (signal[i]>0)
           signal[i] = floor(signal[i]+0.5);
         else
           signal[i] = ceil(signal[i]-0.5);
 
         if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]>window)
           window = signal[i];
         if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]<min)
           min = signal[i];
       }
       it4.Set(signal);
       ++it4;
     }
     window -= min;
     unsigned int level = window/2 + min;
     m_LevelWindow.SetLevelWindow(level, window);
     this->SetNthOutput(0, m_OutputImage);
 
     PrintToLog("\n", false);
     PrintToLog("Finished simulation");
     m_TimeProbe.Stop();
 
     if (m_Parameters.m_SignalGen.m_DoAddMotion)
     {
       PrintToLog("\nHead motion log:", false);
       PrintToLog(m_MotionLog, false, false);
     }
 
     if (m_Parameters.m_SignalGen.m_Spikes>0)
     {
       PrintToLog("\nSpike log:", false);
       PrintToLog(m_SpikeLog, false, false);
     }
 
     if (m_Logfile.is_open()) m_Logfile.close();
   }
 
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::PrintToLog(std::string m, bool addTime, bool linebreak, bool stdOut)
   {
     // timestamp
     if (addTime)
     {
       m_Logfile << this->GetTime() << " > ";
       m_StatusText += this->GetTime() + " > ";
       if (stdOut)
         std::cout << this->GetTime() << " > ";
     }
 
     // message
     if (m_Logfile.is_open())
       m_Logfile << m;
     m_StatusText += m;
     if (stdOut)
       std::cout << m;
 
     // new line
     if (linebreak)
     {
       if (m_Logfile.is_open())
         m_Logfile << "\n";
       m_StatusText += "\n";
       if (stdOut)
         std::cout << "\n";
     }
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::SimulateMotion(int g)
   {
     // is motion artifact enabled?
     // is the current volume g affected by motion?
     if ( m_Parameters.m_SignalGen.m_DoAddMotion
          && m_Parameters.m_SignalGen.m_MotionVolumes[g]
          && g<static_cast<int>(m_Parameters.m_SignalGen.GetNumVolumes()) )
     {
       if ( m_Parameters.m_SignalGen.m_DoRandomizeMotion )
       {
         // either undo last transform or work on fresh copy of untransformed fibers
         m_FiberBundleTransformed = m_FiberBundleWorkingCopy->GetDeepCopy();
 
         m_Rotation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[0]*2)
                         -m_Parameters.m_SignalGen.m_Rotation[0];
         m_Rotation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[1]*2)
                         -m_Parameters.m_SignalGen.m_Rotation[1];
         m_Rotation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[2]*2)
                         -m_Parameters.m_SignalGen.m_Rotation[2];
 
         m_Translation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[0]*2)
                            -m_Parameters.m_SignalGen.m_Translation[0];
         m_Translation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[1]*2)
                            -m_Parameters.m_SignalGen.m_Translation[1];
         m_Translation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[2]*2)
                            -m_Parameters.m_SignalGen.m_Translation[2];
       }
       else
       {
         m_Rotation = m_Parameters.m_SignalGen.m_Rotation / m_NumMotionVolumes;
         m_Translation = m_Parameters.m_SignalGen.m_Translation / m_NumMotionVolumes;
         m_MotionCounter++;
       }
 
       // move mask image
       if (m_MaskImageSet)
       {
         ImageRegionIterator<ItkUcharImgType> maskIt(m_UpsampledMaskImage, m_UpsampledMaskImage->GetLargestPossibleRegion());
         m_TransformedMaskImage->FillBuffer(0);
 
         while(!maskIt.IsAtEnd())
         {
           if (maskIt.Get()<=0)
           {
             ++maskIt;
             continue;
           }
 
           DoubleDwiType::IndexType index = maskIt.GetIndex();
           itk::Point<double, 3> point;
           m_UpsampledMaskImage->TransformIndexToPhysicalPoint(index, point);
           if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
           {
             point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
                 m_Rotation[0],m_Rotation[1],m_Rotation[2],
                 m_Translation[0],m_Translation[1],m_Translation[2]);
           }
           else
           {
             point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
                 m_Rotation[0]*m_MotionCounter,m_Rotation[1]*m_MotionCounter,m_Rotation[2]*m_MotionCounter,
                 m_Translation[0]*m_MotionCounter,m_Translation[1]*m_MotionCounter,m_Translation[2]*m_MotionCounter);
           }
 
           m_TransformedMaskImage->TransformPhysicalPointToIndex(point, index);
 
           if (m_TransformedMaskImage->GetLargestPossibleRegion().IsInside(index))
           { m_TransformedMaskImage->SetPixel(index,100); }
           ++maskIt;
         }
       }
 
       if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
       {
         m_Rotations.push_back(m_Rotation);
         m_Translations.push_back(m_Translation);
 
         m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0])
             + "," + boost::lexical_cast<std::string>(m_Rotation[1])
             + "," + boost::lexical_cast<std::string>(m_Rotation[2]) + ";";
 
         m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0])
             + "," + boost::lexical_cast<std::string>(m_Translation[1])
             + "," + boost::lexical_cast<std::string>(m_Translation[2]) + "\n";
       }
       else
       {
         m_Rotations.push_back(m_Rotation*m_MotionCounter);
         m_Translations.push_back(m_Translation*m_MotionCounter);
 
         m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Rotation[1]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Rotation[2]*m_MotionCounter) + ";";
 
         m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Translation[1]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Translation[2]*m_MotionCounter) + "\n";
       }
 
       m_FiberBundleTransformed->TransformFibers(m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
     }
     else
     {
       m_Rotation.Fill(0.0);
       m_Translation.Fill(0.0);
       m_Rotations.push_back(m_Rotation);
       m_Translations.push_back(m_Translation);
 
       m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0])
           + "," + boost::lexical_cast<std::string>(m_Rotation[1])
           + "," + boost::lexical_cast<std::string>(m_Rotation[2]) + ";";
 
       m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0])
           + "," + boost::lexical_cast<std::string>(m_Translation[1])
           + "," + boost::lexical_cast<std::string>(m_Translation[2]) + "\n";
     }
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::
   SimulateExtraAxonalSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g)
   {
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
     if (intraAxonalVolume>0.0001 && m_Parameters.m_SignalGen.m_DoDisablePartialVolume)  // only fiber in voxel
     {
       DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(index);
       if (g>=0)
         pix[g] *= m_VoxelVolume/intraAxonalVolume;
       else
         pix *= m_VoxelVolume/intraAxonalVolume;
       m_CompartmentImages.at(0)->SetPixel(index, pix);
       if (g==0)
         m_VolumeFractions.at(0)->SetPixel(index, 1);
       for (int i=1; i<numFiberCompartments; i++)
       {
         DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
         if (g>=0)
           pix[g] = 0.0;
         else
           pix.Fill(0.0);
         m_CompartmentImages.at(i)->SetPixel(index, pix);
       }
     }
     else
     {
       if (g==0)
       {
         m_VolumeFractions.at(0)->SetPixel(index, intraAxonalVolume/m_VoxelVolume);
       }
 
       // get non-transformed point (remove headmotion tranformation)
       // this point can then be transformed to each of the original images, regardless of their geometry
       itk::Point<double, 3> point;
       m_TransformedMaskImage->TransformIndexToPhysicalPoint(index, point);
 
       if ( m_Parameters.m_SignalGen.m_DoAddMotion && g>=0
            && m_Parameters.m_SignalGen.m_MotionVolumes[g] )
       {
         if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
         {
           point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
               -m_Rotation[0],-m_Rotation[1],-m_Rotation[2],
               -m_Translation[0],-m_Translation[1],-m_Translation[2]);
         }
         else
         {
           point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
               -m_Rotation[0]*m_MotionCounter,-m_Rotation[1]*m_MotionCounter,-m_Rotation[2]*m_MotionCounter,
               -m_Translation[0]*m_MotionCounter,-m_Translation[1]*m_MotionCounter,-m_Translation[2]*m_MotionCounter);
         }
       }
 
       if (m_Parameters.m_SignalGen.m_DoDisablePartialVolume)
       {
         int maxVolumeIndex = 0;
         double maxWeight = 0;
         for (int i=0; i<numNonFiberCompartments; i++)
         {
           double weight = 0;
           if (numNonFiberCompartments>1)
           {
-            double val = InterpolateValue(point, m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
+            m_DoubleInterpolator->SetInputImage(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
+            double val = mitk::imv::GetImageValue<double>(point, true, m_DoubleInterpolator);
             if (val<0)
                 mitkThrow() << "Volume fraction image (index " << i << ") contains values less than zero!";
             else
               weight = val;
           }
 
           if (weight>maxWeight)
           {
             maxWeight = weight;
             maxVolumeIndex = i;
           }
         }
 
         DoubleDwiType::Pointer doubleDwi = m_CompartmentImages.at(maxVolumeIndex+numFiberCompartments);
         DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
 
         if (g>=0)
           pix[g] += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement(g)*m_VoxelVolume;
         else
           pix += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement()*m_VoxelVolume;
         doubleDwi->SetPixel(index, pix);
         if (g==0)
           m_VolumeFractions.at(maxVolumeIndex+numFiberCompartments)->SetPixel(index, 1);
       }
       else
       {
         double extraAxonalVolume = m_VoxelVolume-intraAxonalVolume;    // non-fiber volume
         if (extraAxonalVolume<0)
         {
           if (extraAxonalVolume<-0.001)
             MITK_ERROR << "Corrupted intra-axonal signal voxel detected. Fiber volume larger voxel volume! " << m_VoxelVolume << "<" << intraAxonalVolume;
           extraAxonalVolume = 0;
         }
         double interAxonalVolume = 0;
         if (numFiberCompartments>1)
           interAxonalVolume = extraAxonalVolume * intraAxonalVolume/m_VoxelVolume;   // inter-axonal fraction of non fiber compartment
         double other = extraAxonalVolume - interAxonalVolume;        // rest of compartment
         if (other<0)
         {
           if (other<-0.001)
             MITK_ERROR << "Corrupted signal voxel detected. Fiber volume larger voxel volume!";
           other = 0;
           interAxonalVolume = extraAxonalVolume;
         }
 
         double compartmentSum = intraAxonalVolume;
 
         // adjust non-fiber and intra-axonal signal
         for (int i=1; i<numFiberCompartments; i++)
         {
           double weight = interAxonalVolume;
           DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
           if (intraAxonalVolume>0)    // remove scaling by intra-axonal volume from inter-axonal compartment
           {
             if (g>=0)
               pix[g] /= intraAxonalVolume;
             else
               pix /= intraAxonalVolume;
           }
           else
           {
             if (g>=0)
               pix[g] = 0;
             else
               pix *= 0;
           }
 
           if (m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage()!=nullptr)
           {
-            double val = InterpolateValue(point, m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage());
+            m_DoubleInterpolator->SetInputImage(m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage());
+            double val = mitk::imv::GetImageValue<double>(point, true, m_DoubleInterpolator);
             if (val<0)
               mitkThrow() << "Volume fraction image (index " << i+1 << ") contains negative values!";
             else
               weight = val*m_VoxelVolume;
           }
 
           compartmentSum += weight;
           if (g>=0)
             pix[g] *= weight;
           else
             pix *= weight;
           m_CompartmentImages.at(i)->SetPixel(index, pix);
           if (g==0)
             m_VolumeFractions.at(i)->SetPixel(index, weight/m_VoxelVolume);
         }
 
         for (int i=0; i<numNonFiberCompartments; i++)
         {
           double weight = other;
           DoubleDwiType::PixelType pix = m_CompartmentImages.at(i+numFiberCompartments)->GetPixel(index);
           if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()!=nullptr)
           {
-            double val = InterpolateValue(point, m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
+            m_DoubleInterpolator->SetInputImage(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
+            double val = mitk::imv::GetImageValue<double>(point, true, m_DoubleInterpolator);
             if (val<0)
               mitkThrow() << "Volume fraction image (index " << numFiberCompartments+i+1 << ") contains negative values (non-fiber compartment)!";
             else
               weight = val*m_VoxelVolume;
 
             if (m_UseRelativeNonFiberVolumeFractions)
               weight *= other/m_VoxelVolume;
           }
 
           compartmentSum += weight;
           if (g>=0)
             pix[g] += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement(g)*weight;
           else
             pix += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement()*weight;
           m_CompartmentImages.at(i+numFiberCompartments)->SetPixel(index, pix);
           if (g==0)
             m_VolumeFractions.at(i+numFiberCompartments)->SetPixel(index, weight/m_VoxelVolume);
         }
 
         if (compartmentSum/m_VoxelVolume>1.05)
           MITK_ERROR << "Compartments do not sum to 1 in voxel " << index << " (" << compartmentSum/m_VoxelVolume << ")";
       }
     }
   }
 
-  template< class PixelType >
-  double TractsToDWIImageFilter< PixelType >::
-  InterpolateValue(itk::Point<float, 3> itkP, ItkDoubleImgType::Pointer img)
-  {
-    itk::Index<3> idx;
-    itk::ContinuousIndex< double, 3> cIdx;
-    img->TransformPhysicalPointToIndex(itkP, idx);
-    img->TransformPhysicalPointToContinuousIndex(itkP, cIdx);
-
-    double pix = 0;
-    if ( img->GetLargestPossibleRegion().IsInside(idx) )
-      pix = img->GetPixel(idx);
-    else
-      return pix;
-
-    double frac_x = cIdx[0] - idx[0];
-    double frac_y = cIdx[1] - idx[1];
-    double 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>(img->GetLargestPossibleRegion().GetSize(0) - 1) &&
-        idx[1] >= 0 && idx[1] < static_cast<itk::IndexValueType>(img->GetLargestPossibleRegion().GetSize(1) - 1) &&
-        idx[2] >= 0 && idx[2] < static_cast<itk::IndexValueType>(img->GetLargestPossibleRegion().GetSize(2) - 1))
-    {
-      vnl_vector_fixed<double, 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 = img->GetPixel(idx) * interpWeights[0];
-      ItkDoubleImgType::IndexType tmpIdx = idx; tmpIdx[0]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[1];
-      tmpIdx = idx; tmpIdx[1]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[2];
-      tmpIdx = idx; tmpIdx[2]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[3];
-      tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[4];
-      tmpIdx = idx; tmpIdx[1]++; tmpIdx[2]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[5];
-      tmpIdx = idx; tmpIdx[2]++; tmpIdx[0]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[6];
-      tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
-      pix +=  img->GetPixel(tmpIdx) * interpWeights[7];
-    }
-
-    return pix;
-  }
-
   template< class PixelType >
   itk::Point<float, 3> TractsToDWIImageFilter< PixelType >::GetItkPoint(double point[3])
   {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
   }
 
   template< class PixelType >
   itk::Vector<double, 3> TractsToDWIImageFilter< PixelType >::GetItkVector(double point[3])
   {
     itk::Vector<double, 3> itkVector;
     itkVector[0] = point[0];
     itkVector[1] = point[1];
     itkVector[2] = point[2];
     return itkVector;
   }
 
   template< class PixelType >
   vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(double point[3])
   {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
   }
 
   template< class PixelType >
   vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(Vector<float,3>& vector)
   {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = vector[0];
     vnlVector[1] = vector[1];
     vnlVector[2] = vector[2];
     return vnlVector;
   }
 
   template< class PixelType >
   double TractsToDWIImageFilter< PixelType >::RoundToNearest(double num) {
     return (num > 0.0) ? floor(num + 0.5) : ceil(num - 0.5);
   }
 
   template< class PixelType >
   std::string TractsToDWIImageFilter< PixelType >::GetTime()
   {
     m_TimeProbe.Stop();
     unsigned long total = RoundToNearest(m_TimeProbe.GetTotal());
     unsigned long hours = total/3600;
     unsigned long minutes = (total%3600)/60;
     unsigned long seconds = total%60;
     std::string out = "";
     out.append(boost::lexical_cast<std::string>(hours));
     out.append(":");
     out.append(boost::lexical_cast<std::string>(minutes));
     out.append(":");
     out.append(boost::lexical_cast<std::string>(seconds));
     m_TimeProbe.Start();
     return out;
   }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.h
index cb2372167d..3e631ebf57 100755
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.h
@@ -1,163 +1,164 @@
 /*===================================================================
 
 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 __itkTractsToDWIImageFilter_h__
 #define __itkTractsToDWIImageFilter_h__
 
 #include <mitkFiberBundle.h>
 #include <itkVnlForwardFFTImageFilter.h>
 #include <itkVectorImage.h>
 #include <cmath>
 #include <mitkFiberfoxParameters.h>
 #include <itkTimeProbe.h>
 #include <mitkRawShModel.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 #include <mitkPointSet.h>
+#include <itkLinearInterpolateImageFunction.h>
 
 namespace itk
 {
 
 /**
 * \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model.
 * See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 */
 
 template< class PixelType >
 class TractsToDWIImageFilter : public ImageSource< itk::VectorImage< PixelType, 3 > >
 {
 
 public:
 
     typedef TractsToDWIImageFilter                          Self;
     typedef ImageSource< itk::VectorImage< PixelType, 3 > > Superclass;
     typedef SmartPointer< Self >                            Pointer;
     typedef SmartPointer< const Self >                      ConstPointer;
 
     typedef typename Superclass::OutputImageType                        OutputImageType;
     typedef itk::Image<double, 4>                                       ItkDoubleImgType4D;
     typedef itk::Image<double, 3>                                       ItkDoubleImgType;
     typedef itk::Image<float, 3>                                        ItkFloatImgType;
     typedef itk::Image<unsigned char, 3>                                ItkUcharImgType;
     typedef mitk::FiberBundle::Pointer                                  FiberBundleType;
     typedef itk::VectorImage< double, 3 >                               DoubleDwiType;
     typedef itk::Matrix<double, 3, 3>                                   MatrixType;
     typedef itk::Image< double, 2 >                                     SliceType;
     typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType   ComplexSliceType;
     typedef itk::VectorImage< vcl_complex< double >, 3 >                ComplexDwiType;
     typedef itk::Vector< double,3>                                      DoubleVectorType;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( TractsToDWIImageFilter, ImageSource )
 
     /** Input */
     itkSetMacro( FiberBundle, FiberBundleType )             ///< Input fiber bundle
     itkSetMacro( InputImage, typename OutputImageType::Pointer )     ///< Input diffusion-weighted image. If no fiber bundle is set, then the acquisition is simulated for this image without a new diffusion simulation.
     itkSetMacro( UseConstantRandSeed, bool )                ///< Seed for random generator.
     void SetParameters( FiberfoxParameters<double> param )  ///< Simulation parameters.
     { m_Parameters = param; }
 
     /** Output */
     FiberfoxParameters<double> GetParameters(){ return m_Parameters; }
     std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions() ///< one double image for each compartment containing the corresponding volume fraction per voxel
     { return m_VolumeFractions; }
     mitk::LevelWindow GetLevelWindow()  ///< Level window is determined from the output image
     { return m_LevelWindow; }
     itkGetMacro( StatusText, std::string )
     itkGetMacro( PhaseImage, DoubleDwiType::Pointer )
     itkGetMacro( KspaceImage, DoubleDwiType::Pointer )
     itkGetMacro( CoilPointset, mitk::PointSet::Pointer )
 
     void GenerateData();
 
 protected:
 
     TractsToDWIImageFilter();
     virtual ~TractsToDWIImageFilter();
     itk::Point<float, 3> GetItkPoint(double point[3]);
     itk::Vector<double, 3> GetItkVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(Vector< float, 3 >& vector);
     double RoundToNearest(double num);
     std::string GetTime();
     bool PrepareLogFile();  /** Prepares the log file and returns true if successful or false if failed. */
     void PrintToLog(std::string m, bool addTime=true, bool linebreak=true, bool stdOut=true);
 
     /** Transform generated image compartment by compartment, channel by channel and slice by slice using DFT and add k-space artifacts/effects. */
     DoubleDwiType::Pointer SimulateKspaceAcquisition(std::vector< DoubleDwiType::Pointer >& images);
 
     /** Generate signal of non-fiber compartments. */
     void SimulateExtraAxonalSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g=-1);
 
     /** Move fibers to simulate headmotion */
     void SimulateMotion(int g=-1);
 
     void CheckVolumeFractionImages();
     ItkDoubleImgType::Pointer NormalizeInsideMask(ItkDoubleImgType::Pointer image);
     void InitializeData();
     void InitializeFiberData();
-    double InterpolateValue(itk::Point<float, 3> itkP, ItkDoubleImgType::Pointer img);
 
     // input
     mitk::FiberfoxParameters<double>            m_Parameters;
     FiberBundleType                             m_FiberBundle;
     typename OutputImageType::Pointer           m_InputImage;
 
     // output
     typename OutputImageType::Pointer           m_OutputImage;
     typename DoubleDwiType::Pointer             m_PhaseImage;
     typename DoubleDwiType::Pointer             m_KspaceImage;
     mitk::LevelWindow                           m_LevelWindow;
     std::vector< ItkDoubleImgType::Pointer >    m_VolumeFractions;
     std::string                                 m_StatusText;
 
     // MISC
     itk::TimeProbe                              m_TimeProbe;
     bool                                        m_UseConstantRandSeed;
     bool                                        m_MaskImageSet;
     ofstream                                    m_Logfile;
     std::string                                 m_MotionLog;
     std::string                                 m_SpikeLog;
 
     // signal generation
     FiberBundleType                             m_FiberBundleWorkingCopy;   ///< we work on an upsampled version of the input bundle
     FiberBundleType                             m_FiberBundleTransformed;   ///< transformed bundle simulating headmotion
     itk::Vector<double,3>                       m_WorkingSpacing;
     itk::Point<double,3>                        m_WorkingOrigin;
     ImageRegion<3>                              m_WorkingImageRegion;
     double                                      m_VoxelVolume;
     std::vector< DoubleDwiType::Pointer >       m_CompartmentImages;
     ItkUcharImgType::Pointer                    m_TransformedMaskImage;     ///< copy of mask image (changes for each motion step)
     ItkUcharImgType::Pointer                    m_UpsampledMaskImage;       ///< helper image for motion simulation
     DoubleVectorType                            m_Rotation;
     DoubleVectorType                            m_Translation;
     std::vector< DoubleVectorType >             m_Rotations;                ///<stores the individual rotation of each volume (needed for k-space simulation to obtain correct frequency map position)
     std::vector< DoubleVectorType >             m_Translations;             ///<stores the individual translation of each volume (needed for k-space simulation to obtain correct frequency map position)
     double                                      m_mmRadius;
     double                                      m_SegmentVolume;
     bool                                        m_UseRelativeNonFiberVolumeFractions;
     mitk::PointSet::Pointer                     m_CoilPointset;
     int                                         m_MotionCounter;
     int                                         m_NumMotionVolumes;
 
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
+    itk::LinearInterpolateImageFunction< ItkDoubleImgType, float >::Pointer   m_DoubleInterpolator;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToDWIImageFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
index 5343620889..a77e966134 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
@@ -1,2713 +1,2517 @@
 /*===================================================================
 
 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 "mitkFiberBundle.h"
 
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.h>
 #include "mitkImagePixelReadAccessor.h"
 #include <mitkPixelTypeMultiplex.h>
 
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkIdFilter.h>
 #include <vtkClipPolyData.h>
 #include <vtkPlane.h>
 #include <vtkDoubleArray.h>
 #include <vtkKochanekSpline.h>
 #include <vtkParametricFunctionSource.h>
 #include <vtkParametricSpline.h>
 #include <vtkPolygon.h>
 #include <vtkCleanPolyData.h>
 #include <cmath>
 #include <boost/progress.hpp>
 #include <vtkTransformPolyDataFilter.h>
 #include <mitkTransferFunction.h>
 #include <vtkLookupTable.h>
 #include <mitkLookupTable.h>
 #include <vtkCardinalSpline.h>
 #include <vtkAppendPolyData.h>
 
 const char* mitk::FiberBundle::FIBER_ID_ARRAY = "Fiber_IDs";
 
 mitk::FiberBundle::FiberBundle( vtkPolyData* fiberPolyData )
   : m_NumFibers(0)
 {
   m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   m_FiberWeights->SetName("FIBER_WEIGHTS");
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   if (fiberPolyData != nullptr)
     m_FiberPolyData = fiberPolyData;
   else
   {
     this->m_FiberPolyData->SetPoints(vtkSmartPointer<vtkPoints>::New());
     this->m_FiberPolyData->SetLines(vtkSmartPointer<vtkCellArray>::New());
   }
 
   this->UpdateFiberGeometry();
   this->GenerateFiberIds();
   this->ColorFibersByOrientation();
 }
 
 mitk::FiberBundle::~FiberBundle()
 {
 
 }
 
 mitk::FiberBundle::Pointer mitk::FiberBundle::GetDeepCopy()
 {
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(m_FiberPolyData);
   newFib->SetFiberColors(this->m_FiberColors);
   newFib->SetFiberWeights(this->m_FiberWeights);
   return newFib;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GeneratePolyDataByIds(std::vector<long> fiberIds, vtkSmartPointer<vtkFloatArray> weights)
 {
   vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
   weights->SetNumberOfValues(fiberIds.size());
 
   int counter = 0;
   auto finIt = fiberIds.begin();
   while ( finIt != fiberIds.end() )
   {
     if (*finIt < 0 || *finIt>GetNumFibers()){
       MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
       break;
     }
 
     vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
     vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
     vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
     newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
 
     for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
     {
       newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
       newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
     }
 
     weights->InsertValue(counter, this->GetFiberWeight(*finIt));
     newLineSet->InsertNextCell(newFiber);
     ++finIt;
     ++counter;
   }
 
   newFiberPolyData->SetPoints(newPointSet);
   newFiberPolyData->SetLines(newLineSet);
   return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundles(std::vector< mitk::FiberBundle::Pointer > fibs)
 {
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   // add current fiber bundle
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 
   int num_weights = this->GetNumFibers();
   for (auto fib : fibs)
     num_weights += fib->GetNumFibers();
   weights->SetNumberOfValues(num_weights);
 
   unsigned int counter = 0;
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, this->GetFiberWeight(i));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   for (auto fib : fibs)
   {
     // add new fiber bundle
     for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
     {
       vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       for (int j=0; j<numPoints; j++)
       {
         double p[3];
         points->GetPoint(j, p);
 
         vtkIdType id = vNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       weights->InsertValue(counter, fib->GetFiberWeight(i));
       vNewLines->InsertNextCell(container);
       counter++;
     }
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   newFib->SetFiberWeights(weights);
   return newFib;
 }
 
 // merge two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundle(mitk::FiberBundle* fib)
 {
   if (fib==nullptr)
     return this->GetDeepCopy();
 
   MITK_INFO << "Adding fibers";
 
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   // add current fiber bundle
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
 
   unsigned int counter = 0;
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, this->GetFiberWeight(i));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   // add new fiber bundle
   for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
     vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, fib->GetFiberWeight(i));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   newFib->SetFiberWeights(weights);
   return newFib;
 }
 
 // Only retain fibers with a weight larger than the specified threshold
 mitk::FiberBundle::Pointer mitk::FiberBundle::FilterByWeights(float weight_thr, bool invert)
 {
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   std::vector<float> weights;
 
   for (int i=0; i<this->GetNumFibers(); i++)
   {
     if ( (invert && this->GetFiberWeight(i)>weight_thr) || (!invert && this->GetFiberWeight(i)<=weight_thr))
       continue;
 
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
     weights.push_back(this->GetFiberWeight(i));
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   for (unsigned int i=0; i<weights.size(); ++i)
     newFib->SetFiberWeight(i, weights.at(i));
   return newFib;
 }
 
 // Only retain a subsample of the fibers
 mitk::FiberBundle::Pointer mitk::FiberBundle::SubsampleFibers(float factor)
 {
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   int new_num_fibs = this->GetNumFibers()*factor;
   MITK_INFO << "Subsampling fibers with factor " << factor << "(" << new_num_fibs << "/" << this->GetNumFibers() << ")";
 
   // add current fiber bundle
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   weights->SetNumberOfValues(new_num_fibs);
 
   std::vector< int > ids;
   for (int i=0; i<this->GetNumFibers(); i++)
     ids.push_back(i);
   std::random_shuffle(ids.begin(), ids.end());
 
   unsigned int counter = 0;
   for (int i=0; i<new_num_fibs; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(ids.at(i));
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, this->GetFiberWeight(ids.at(i)));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   newFib->SetFiberWeights(weights);
   return newFib;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::SubtractBundle(mitk::FiberBundle* fib)
 {
   if (fib==nullptr)
     return this->GetDeepCopy();
 
   MITK_INFO << "Subtracting fibers";
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   std::vector< std::vector< itk::Point<float, 3> > > points1;
   for( int i=0; i<m_NumFibers; i++ )
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (points==nullptr || numPoints<=0)
       continue;
 
     itk::Point<float, 3> start = GetItkPoint(points->GetPoint(0));
     itk::Point<float, 3> end = GetItkPoint(points->GetPoint(numPoints-1));
 
     points1.push_back( {start, end} );
   }
 
   std::vector< std::vector< itk::Point<float, 3> > > points2;
   for( int i=0; i<fib->GetNumFibers(); i++ )
   {
     vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (points==nullptr || numPoints<=0)
       continue;
 
     itk::Point<float, 3> start = GetItkPoint(points->GetPoint(0));
     itk::Point<float, 3> end = GetItkPoint(points->GetPoint(numPoints-1));
 
     points2.push_back( {start, end} );
   }
 
   //  int progress = 0;
   std::vector< int > ids;
 #pragma omp parallel for
   for (int i=0; i<(int)points1.size(); i++)
   {
     //#pragma omp critical
     //    {
     //      progress++;
     //      std::cout << (int)(100*(float)progress/points1.size()) << "%" << '\r';
     //      cout.flush();
     //    }
 
     bool match = false;
     for (unsigned int j=0; j<points2.size(); j++)
     {
       auto v1 = points1.at(i);
       auto v2 = points2.at(j);
 
       float dist=0;
       for (unsigned int c=0; c<v1.size(); c++)
       {
         float d = v1[c][0]-v2[c][0];
         dist += d*d;
 
         d = v1[c][1]-v2[c][1];
         dist += d*d;
 
         d = v1[c][2]-v2[c][2];
         dist += d*d;
       }
       dist /= v1.size();
 
       if (dist<mitk::eps)
       {
         match = true;
         break;
       }
 
       dist=0;
       for (unsigned int c=0; c<v1.size(); c++)
       {
         float d = v1[v1.size()-1-c][0]-v2[c][0];
         dist += d*d;
 
         d = v1[v1.size()-1-c][1]-v2[c][1];
         dist += d*d;
 
         d = v1[v1.size()-1-c][2]-v2[c][2];
         dist += d*d;
       }
       dist /= v1.size();
 
       if (dist<mitk::eps)
       {
         match = true;
         break;
       }
     }
 
 #pragma omp critical
     if (!match)
       ids.push_back(i);
   }
 
   for( int i : ids )
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (points==nullptr || numPoints<=0)
       continue;
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for( int j=0; j<numPoints; j++)
     {
       vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
   if(vNewLines->GetNumberOfCells()==0)
     return mitk::FiberBundle::New();
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   return mitk::FiberBundle::New(vNewPolyData);
 }
 
 itk::Point<float, 3> mitk::FiberBundle::GetItkPoint(double point[3])
 {
   itk::Point<float, 3> itkPoint;
   itkPoint[0] = point[0];
   itkPoint[1] = point[1];
   itkPoint[2] = point[2];
   return itkPoint;
 }
 
 /*
  * set PolyData (additional flag to recompute fiber geometry, default = true)
  */
 void mitk::FiberBundle::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
 {
   if (fiberPD == nullptr)
     this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   else
     m_FiberPolyData->DeepCopy(fiberPD);
 
   m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
   if (updateGeometry)
     UpdateFiberGeometry();
   GenerateFiberIds();
   ColorFibersByOrientation();
 }
 
 /*
  * return vtkPolyData
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GetFiberPolyData() const
 {
   return m_FiberPolyData;
 }
 
 void mitk::FiberBundle::ColorFibersByOrientation()
 {
   //===== FOR WRITING A TEST ========================
   //  colorT size == tupelComponents * tupelElements
   //  compare color results
   //  to cover this code 100% also PolyData needed, where colorarray already exists
   //  + one fiber with exactly 1 point
   //  + one fiber with 0 points
   //=================================================
 
   vtkPoints* extrPoints = nullptr;
   extrPoints = m_FiberPolyData->GetPoints();
   int numOfPoints = 0;
   if (extrPoints!=nullptr)
     numOfPoints = extrPoints->GetNumberOfPoints();
 
   //colors and alpha value for each single point, RGBA = 4 components
   unsigned char rgba[4] = {0,0,0,0};
   int componentSize = 4;
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(numOfPoints * componentSize);
   m_FiberColors->SetNumberOfComponents(componentSize);
   m_FiberColors->SetName("FIBER_COLORS");
 
   int numOfFibers = m_FiberPolyData->GetNumberOfLines();
   if (numOfFibers < 1)
     return;
 
   /* extract single fibers of fiberBundle */
   vtkCellArray* fiberList = m_FiberPolyData->GetLines();
   fiberList->InitTraversal();
   for (int fi=0; fi<numOfFibers; ++fi) {
 
     vtkIdType* idList; // contains the point id's of the line
     vtkIdType pointsPerFiber; // number of points for current line
     fiberList->GetNextCell(pointsPerFiber, idList);
 
     /* single fiber checkpoints: is number of points valid */
     if (pointsPerFiber > 1)
     {
       /* operate on points of single fiber */
       for (int i=0; i <pointsPerFiber; ++i)
       {
         /* process all points elastV[0]ept starting and endpoint for calculating color value take current point, previous point and next point */
         if (i<pointsPerFiber-1 && i > 0)
         {
           /* The color value of the current point is influenced by the previous point and next point. */
           vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
           vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
           vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
           vnl_vector_fixed< double, 3 > diff1;
           diff1 = currentPntvtk - nextPntvtk;
 
           vnl_vector_fixed< double, 3 > diff2;
           diff2 = currentPntvtk - prevPntvtk;
 
           vnl_vector_fixed< double, 3 > diff;
           diff = (diff1 - diff2) / 2.0;
           diff.normalize();
 
           rgba[0] = (unsigned char) (255.0 * std::fabs(diff[0]));
           rgba[1] = (unsigned char) (255.0 * std::fabs(diff[1]));
           rgba[2] = (unsigned char) (255.0 * std::fabs(diff[2]));
           rgba[3] = (unsigned char) (255.0);
         }
         else if (i==0)
         {
           /* First point has no previous point, therefore only diff1 is taken */
 
           vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
           vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
 
           vnl_vector_fixed< double, 3 > diff1;
           diff1 = currentPntvtk - nextPntvtk;
           diff1.normalize();
 
           rgba[0] = (unsigned char) (255.0 * std::fabs(diff1[0]));
           rgba[1] = (unsigned char) (255.0 * std::fabs(diff1[1]));
           rgba[2] = (unsigned char) (255.0 * std::fabs(diff1[2]));
           rgba[3] = (unsigned char) (255.0);
         }
         else if (i==pointsPerFiber-1)
         {
           /* Last point has no next point, therefore only diff2 is taken */
           vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
           vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
           vnl_vector_fixed< double, 3 > diff2;
           diff2 = currentPntvtk - prevPntvtk;
           diff2.normalize();
 
           rgba[0] = (unsigned char) (255.0 * std::fabs(diff2[0]));
           rgba[1] = (unsigned char) (255.0 * std::fabs(diff2[1]));
           rgba[2] = (unsigned char) (255.0 * std::fabs(diff2[2]));
           rgba[3] = (unsigned char) (255.0);
         }
         m_FiberColors->InsertTypedTuple(idList[i], rgba);
       }
     }
     else if (pointsPerFiber == 1)
     {
       /* a single point does not define a fiber (use vertex mechanisms instead */
       continue;
     }
     else
     {
       MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
       continue;
     }
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ColorFibersByCurvature(bool, bool normalize)
 {
   double window = 5;
 
   //colors and alpha value for each single point, RGBA = 4 components
   unsigned char rgba[4] = {0,0,0,0};
   int componentSize = 4;
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * componentSize);
   m_FiberColors->SetNumberOfComponents(componentSize);
   m_FiberColors->SetName("FIBER_COLORS");
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetTableRange(0.0, 0.8);
   lookupTable->Build();
   mitkLookup->SetVtkLookupTable(lookupTable);
   mitkLookup->SetType(mitk::LookupTable::JET);
 
   std::vector< double > values;
   double min = 1;
   double max = 0;
   MITK_INFO << "Coloring fibers by curvature";
   boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     // calculate curvatures
     for (int j=0; j<numPoints; j++)
     {
       double dist = 0;
       int c = j;
       std::vector< vnl_vector_fixed< float, 3 > > vectors;
       vnl_vector_fixed< float, 3 > meanV; meanV.fill(0.0);
       while(dist<window/2 && c>1)
       {
         double p1[3];
         points->GetPoint(c-1, p1);
         double p2[3];
         points->GetPoint(c, p2);
 
         vnl_vector_fixed< float, 3 > v;
         v[0] = p2[0]-p1[0];
         v[1] = p2[1]-p1[1];
         v[2] = p2[2]-p1[2];
         dist += v.magnitude();
         v.normalize();
         vectors.push_back(v);
         if (c==j)
           meanV += v;
         c--;
       }
       c = j;
       dist = 0;
       while(dist<window/2 && c<numPoints-1)
       {
         double p1[3];
         points->GetPoint(c, p1);
         double p2[3];
         points->GetPoint(c+1, p2);
 
         vnl_vector_fixed< float, 3 > v;
         v[0] = p2[0]-p1[0];
         v[1] = p2[1]-p1[1];
         v[2] = p2[2]-p1[2];
         dist += v.magnitude();
         v.normalize();
         vectors.push_back(v);
         if (c==j)
           meanV += v;
         c++;
       }
       meanV.normalize();
 
       double dev = 0;
       for (unsigned int c=0; c<vectors.size(); c++)
       {
         double angle = dot_product(meanV, vectors.at(c));
         if (angle>1.0)
           angle = 1.0;
         if (angle<-1.0)
           angle = -1.0;
         dev += acos(angle)*180/M_PI;
       }
       if (vectors.size()>0)
         dev /= vectors.size();
 
       dev = 1.0-dev/180.0;
       values.push_back(dev);
       if (dev<min)
         min = dev;
       if (dev>max)
         max = dev;
     }
   }
   unsigned int count = 0;
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     for (int j=0; j<numPoints; j++)
     {
       double color[3];
       double dev = values.at(count);
       if (normalize)
         dev = (dev-min)/(max-min);
       else if (dev>1)
         dev = 1;
       lookupTable->GetColor(dev, color);
 
       rgba[0] = (unsigned char) (255.0 * color[0]);
       rgba[1] = (unsigned char) (255.0 * color[1]);
       rgba[2] = (unsigned char) (255.0 * color[2]);
       rgba[3] = (unsigned char) (255.0);
       m_FiberColors->InsertTypedTuple(cell->GetPointId(j), rgba);
       count++;
     }
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::SetFiberOpacity(vtkDoubleArray* FAValArray)
 {
   for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
   {
     double faValue = FAValArray->GetValue(i);
     faValue = faValue * 255.0;
     m_FiberColors->SetComponent(i,3, (unsigned char) faValue );
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ResetFiberOpacity()
 {
   for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
     m_FiberColors->SetComponent(i,3, 255.0 );
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity, bool normalize)
 {
   mitkPixelTypeMultiplex3( ColorFibersByScalarMap, FAimage->GetPixelType(), FAimage, opacity, normalize );
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 template <typename TPixel>
 void mitk::FiberBundle::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity, bool normalize)
 {
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
   mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
 
   unsigned char rgba[4] = {0,0,0,0};
   vtkPoints* pointSet = m_FiberPolyData->GetPoints();
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetTableRange(0.0, 0.8);
   lookupTable->Build();
   mitkLookup->SetVtkLookupTable(lookupTable);
   mitkLookup->SetType(mitk::LookupTable::JET);
 
   double min = 9999999;
   double max = -9999999;
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
     Point3D px;
     px[0] = pointSet->GetPoint(i)[0];
     px[1] = pointSet->GetPoint(i)[1];
     px[2] = pointSet->GetPoint(i)[2];
     double pixelValue = readimage.GetPixelByWorldCoordinates(px);
     if (pixelValue>max)
       max = pixelValue;
     if (pixelValue<min)
       min = pixelValue;
   }
 
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
     Point3D px;
     px[0] = pointSet->GetPoint(i)[0];
     px[1] = pointSet->GetPoint(i)[1];
     px[2] = pointSet->GetPoint(i)[2];
     double pixelValue = readimage.GetPixelByWorldCoordinates(px);
 
     if (normalize)
       pixelValue = (pixelValue-min)/(max-min);
     else if (pixelValue>1)
       pixelValue = 1;
 
     double color[3];
     lookupTable->GetColor(1-pixelValue, color);
 
     rgba[0] = (unsigned char) (255.0 * color[0]);
     rgba[1] = (unsigned char) (255.0 * color[1]);
     rgba[2] = (unsigned char) (255.0 * color[2]);
     if (opacity)
       rgba[3] = (unsigned char) (255.0 * pixelValue);
     else
       rgba[3] = (unsigned char) (255.0);
     m_FiberColors->InsertTypedTuple(i, rgba);
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 
 void mitk::FiberBundle::ColorFibersByFiberWeights(bool opacity, bool normalize)
 {
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetTableRange(0.0, 0.8);
   lookupTable->Build();
   mitkLookup->SetVtkLookupTable(lookupTable);
   mitkLookup->SetType(mitk::LookupTable::JET);
 
   unsigned char rgba[4] = {0,0,0,0};
   unsigned int counter = 0;
 
   float max = -999999;
   float min = 999999;
   for (int i=0; i<m_NumFibers; i++)
   {
     double weight = this->GetFiberWeight(i);
     if (weight>max)
       max = weight;
     if (weight<min)
       min = weight;
   }
   if (fabs(max-min)<0.00001)
   {
     max = 1;
     min = 0;
   }
 
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     double weight = this->GetFiberWeight(i);
 
     for (int j=0; j<numPoints; j++)
     {
       float v = weight;
       if (normalize)
         v = (v-min)/(max-min);
       else if (v>1)
         v = 1;
       double color[3];
       lookupTable->GetColor(1-v, color);
 
       rgba[0] = (unsigned char) (255.0 * color[0]);
       rgba[1] = (unsigned char) (255.0 * color[1]);
       rgba[2] = (unsigned char) (255.0 * color[2]);
       if (opacity)
         rgba[3] = (unsigned char) (255.0 * v);
       else
         rgba[3] = (unsigned char) (255.0);
 
       m_FiberColors->InsertTypedTuple(counter, rgba);
       counter++;
     }
   }
 
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::SetFiberColors(float r, float g, float b, float alpha)
 {
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
   unsigned char rgba[4] = {0,0,0,0};
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
     rgba[0] = (unsigned char) r;
     rgba[1] = (unsigned char) g;
     rgba[2] = (unsigned char) b;
     rgba[3] = (unsigned char) alpha;
     m_FiberColors->InsertTypedTuple(i, rgba);
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::GenerateFiberIds()
 {
   if (m_FiberPolyData == nullptr)
     return;
 
   vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
   idFiberFilter->SetInputData(m_FiberPolyData);
   idFiberFilter->CellIdsOn();
   //  idFiberFilter->PointIdsOn(); // point id's are not needed
   idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
   idFiberFilter->FieldDataOn();
   idFiberFilter->Update();
 
   m_FiberIdDataSet = idFiberFilter->GetOutput();
 
 }
 
 float mitk::FiberBundle::GetOverlap(ItkUcharImgType* mask, bool do_resampling)
 {
   vtkSmartPointer<vtkPolyData> PolyData = m_FiberPolyData;
   mitk::FiberBundle::Pointer fibCopy = this;
   if (do_resampling)
   {
     float minSpacing = 1;
     if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
       minSpacing = mask->GetSpacing()[0];
     else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
       minSpacing = mask->GetSpacing()[1];
     else
       minSpacing = mask->GetSpacing()[2];
 
     fibCopy = this->GetDeepCopy();
     fibCopy->ResampleLinear(minSpacing/5);
     PolyData = fibCopy->GetFiberPolyData();
   }
 
   MITK_INFO << "Calculating overlap";
   int inside = 0;
   int outside = 0;
   boost::progress_display disp(m_NumFibers);
   for (int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = PolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     for (int j=0; j<numPoints; j++)
     {
       double* p = points->GetPoint(j);
       itk::Point<float, 3> itkP;
       itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
       itk::Index<3> idx;
       mask->TransformPhysicalPointToIndex(itkP, idx);
 
       if ( mask->GetLargestPossibleRegion().IsInside(idx) && mask->GetPixel(idx) != 0 )
         inside++;
       else
         outside++;
     }
   }
 
   if (inside+outside==0)
     outside = 1;
   return (float)inside/(inside+outside);
 }
 
-mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert, bool bothEnds, float fraction, bool do_resampling)
-{
-  if (m_NumFibers==0 || mask==nullptr)
-    return mitk::FiberBundle::New(nullptr);
-
-  vtkSmartPointer<vtkPolyData> PolyData = m_FiberPolyData;
-  mitk::FiberBundle::Pointer fibCopy = this;
-  if (anyPoint && do_resampling)
-  {
-    float minSpacing = 1;
-    if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
-      minSpacing = mask->GetSpacing()[0];
-    else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
-      minSpacing = mask->GetSpacing()[1];
-    else
-      minSpacing = mask->GetSpacing()[2];
-
-    fibCopy = this->GetDeepCopy();
-    fibCopy->ResampleLinear(minSpacing/5);
-    PolyData = fibCopy->GetFiberPolyData();
-  }
-  vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
-  vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
-
-  std::vector< float > new_weights;
-
-  MITK_INFO << "Extracting fibers with mask image";
-  boost::progress_display disp(m_NumFibers);
-  for (int i=0; i<m_NumFibers; i++)
-  {
-    ++disp;
-
-    vtkCell* cell = PolyData->GetCell(i);
-    int numPoints = cell->GetNumberOfPoints();
-    vtkPoints* points = cell->GetPoints();
-
-    vtkCell* cellOriginal = m_FiberPolyData->GetCell(i);
-    int numPointsOriginal = cellOriginal->GetNumberOfPoints();
-    vtkPoints* pointsOriginal = cellOriginal->GetPoints();
-
-    vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-
-    if (numPoints>1 && numPointsOriginal)
-    {
-      if (anyPoint)
-      {
-        int inside = 0;
-        int outside = 0;
-        if (!invert)
-        {
-          for (int j=0; j<numPoints; j++)
-          {
-            double* p = points->GetPoint(j);
-
-            itk::Point<float, 3> itkP;
-            itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
-            itk::Index<3> idx;
-            mask->TransformPhysicalPointToIndex(itkP, idx);
-
-            if ( mask->GetLargestPossibleRegion().IsInside(idx) && mask->GetPixel(idx) != 0 )
-            {
-              inside++;
-              if (fraction==0)
-                break;
-            }
-            else
-              outside++;
-          }
-
-          float current_fraction = 0.0;
-          if (inside+outside>0)
-            current_fraction = (float)inside/(inside+outside);
-
-          if (current_fraction>fraction)
-          {
-            for (int k=0; k<numPoints; k++)
-            {
-              double* p = points->GetPoint(k);
-              vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-              container->GetPointIds()->InsertNextId(id);
-            }
-          }
-        }
-        else
-        {
-          bool includeFiber = true;
-          for (int j=0; j<numPoints; j++)
-          {
-            double* p = points->GetPoint(j);
-
-            itk::Point<float, 3> itkP;
-            itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
-            itk::Index<3> idx;
-            mask->TransformPhysicalPointToIndex(itkP, idx);
-
-            if ( mask->GetPixel(idx) != 0 && mask->GetLargestPossibleRegion().IsInside(idx) )
-            {
-              inside++;
-              includeFiber = false;
-              break;
-            }
-            else
-              outside++;
-          }
-          if (includeFiber)
-          {
-
-            for (int k=0; k<numPoints; k++)
-            {
-              double* p = points->GetPoint(k);
-              vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-              container->GetPointIds()->InsertNextId(id);
-            }
-          }
-        }
-      }
-      else
-      {
-        double* start = pointsOriginal->GetPoint(0);
-        itk::Point<float, 3> itkStart;
-        itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
-        itk::Index<3> idxStart;
-        mask->TransformPhysicalPointToIndex(itkStart, idxStart);
-
-        double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
-        itk::Point<float, 3> itkEnd;
-        itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
-        itk::Index<3> idxEnd;
-        mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
-
-        if (invert)
-        {
-          if (bothEnds)
-          {
-            if ( mask->GetPixel(idxStart) == 0 && mask->GetPixel(idxEnd) == 0 )
-            {
-              for (int j=0; j<numPointsOriginal; j++)
-              {
-                double* p = pointsOriginal->GetPoint(j);
-                vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-                container->GetPointIds()->InsertNextId(id);
-              }
-            }
-          }
-          else if ( mask->GetPixel(idxStart) == 0 || mask->GetPixel(idxEnd) == 0 )
-          {
-            for (int j=0; j<numPointsOriginal; j++)
-            {
-              double* p = pointsOriginal->GetPoint(j);
-              vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-              container->GetPointIds()->InsertNextId(id);
-            }
-          }
-        }
-        else
-        {
-          if (bothEnds)
-          {
-            if ( mask->GetPixel(idxStart) != 0 && mask->GetPixel(idxEnd) != 0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
-            {
-              for (int j=0; j<numPointsOriginal; j++)
-              {
-                double* p = pointsOriginal->GetPoint(j);
-                vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-                container->GetPointIds()->InsertNextId(id);
-              }
-            }
-          }
-          else if ( (mask->GetPixel(idxStart) != 0 && mask->GetLargestPossibleRegion().IsInside(idxStart)) || (mask->GetPixel(idxEnd) != 0 && mask->GetLargestPossibleRegion().IsInside(idxEnd)) )
-          {
-            for (int j=0; j<numPointsOriginal; j++)
-            {
-              double* p = pointsOriginal->GetPoint(j);
-              vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-              container->GetPointIds()->InsertNextId(id);
-            }
-          }
-        }
-      }
-    }
-
-    if (container->GetNumberOfPoints()>0)
-    {
-      new_weights.push_back(fibCopy->GetFiberWeight(i));
-      vtkNewCells->InsertNextCell(container);
-    }
-  }
-
-  if (vtkNewCells->GetNumberOfCells()<=0)
-    return mitk::FiberBundle::New(nullptr);
-
-  vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
-  newPolyData->SetPoints(vtkNewPoints);
-  newPolyData->SetLines(vtkNewCells);
-
-  mitk::FiberBundle::Pointer newfib = mitk::FiberBundle::New(newPolyData);
-  for (unsigned int i=0; i<new_weights.size(); i++)
-    newfib->SetFiberWeight(i, new_weights.at(i));
-  return newfib;
-}
-
 mitk::FiberBundle::Pointer mitk::FiberBundle::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
 {
   float minSpacing = 1;
   if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
     minSpacing = mask->GetSpacing()[0];
   else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
     minSpacing = mask->GetSpacing()[1];
   else
     minSpacing = mask->GetSpacing()[2];
 
   mitk::FiberBundle::Pointer fibCopy = this->GetDeepCopy();
   fibCopy->ResampleLinear(minSpacing/10);
   vtkSmartPointer<vtkPolyData> PolyData =fibCopy->GetFiberPolyData();
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   MITK_INFO << "Cutting fibers";
   boost::progress_display disp(m_NumFibers);
   for (int i=0; i<m_NumFibers; i++)
   {
     ++disp;
 
     vtkCell* cell = PolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     if (numPoints>1)
     {
       int newNumPoints = 0;
       for (int j=0; j<numPoints; j++)
       {
         double* p = points->GetPoint(j);
 
         itk::Point<float, 3> itkP;
         itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
         itk::Index<3> idx;
         mask->TransformPhysicalPointToIndex(itkP, idx);
 
         if ( mask->GetPixel(idx) != 0 && mask->GetLargestPossibleRegion().IsInside(idx) && !invert )
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(p);
           container->GetPointIds()->InsertNextId(id);
           newNumPoints++;
         }
         else if ( (mask->GetPixel(idx) == 0 || !mask->GetLargestPossibleRegion().IsInside(idx)) && invert )
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(p);
           container->GetPointIds()->InsertNextId(id);
           newNumPoints++;
         }
         else if (newNumPoints>0)
         {
           vtkNewCells->InsertNextCell(container);
 
           newNumPoints = 0;
           container = vtkSmartPointer<vtkPolyLine>::New();
         }
       }
 
       if (newNumPoints>0)
         vtkNewCells->InsertNextCell(container);
     }
 
   }
 
   if (vtkNewCells->GetNumberOfCells()<=0)
     return nullptr;
 
   vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
   newPolyData->SetPoints(vtkNewPoints);
   newPolyData->SetLines(vtkNewCells);
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(newPolyData);
   newFib->Compress(0.1);
   return newFib;
 }
 
 mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(DataNode* roi, DataStorage* storage)
 {
   if (roi==nullptr || !(dynamic_cast<PlanarFigure*>(roi->GetData()) || dynamic_cast<PlanarFigureComposite*>(roi->GetData())) )
     return nullptr;
 
   std::vector<long> tmp = ExtractFiberIdSubset(roi, storage);
 
   if (tmp.size()<=0)
     return mitk::FiberBundle::New();
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp, weights);
   mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
   fib->SetFiberWeights(weights);
   return fib;
 }
 
 std::vector<long> mitk::FiberBundle::ExtractFiberIdSubset(DataNode *roi, DataStorage* storage)
 {
   std::vector<long> result;
   if (roi==nullptr || roi->GetData()==nullptr)
     return result;
 
   mitk::PlanarFigureComposite::Pointer pfc = dynamic_cast<mitk::PlanarFigureComposite*>(roi->GetData());
   if (!pfc.IsNull()) // handle composite
   {
     DataStorage::SetOfObjects::ConstPointer children = storage->GetDerivations(roi);
     if (children->size()==0)
       return result;
 
     switch (pfc->getOperationType())
     {
     case 0: // AND
     {
       MITK_INFO << "AND";
       result = this->ExtractFiberIdSubset(children->ElementAt(0), storage);
       std::vector<long>::iterator it;
       for (unsigned int i=1; i<children->Size(); ++i)
       {
         std::vector<long> inRoi = this->ExtractFiberIdSubset(children->ElementAt(i), storage);
 
         std::vector<long> rest(std::min(result.size(),inRoi.size()));
         it = std::set_intersection(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
         rest.resize( it - rest.begin() );
         result = rest;
       }
       break;
     }
     case 1: // OR
     {
       MITK_INFO << "OR";
       result = ExtractFiberIdSubset(children->ElementAt(0), storage);
       std::vector<long>::iterator it;
       for (unsigned int i=1; i<children->Size(); ++i)
       {
         it = result.end();
         std::vector<long> inRoi = ExtractFiberIdSubset(children->ElementAt(i), storage);
         result.insert(it, inRoi.begin(), inRoi.end());
       }
 
       // remove duplicates
       sort(result.begin(), result.end());
       it = unique(result.begin(), result.end());
       result.resize( it - result.begin() );
       break;
     }
     case 2: // NOT
     {
       MITK_INFO << "NOT";
       for(long i=0; i<this->GetNumFibers(); i++)
         result.push_back(i);
 
       std::vector<long>::iterator it;
       for (unsigned int i=0; i<children->Size(); ++i)
       {
         std::vector<long> inRoi = ExtractFiberIdSubset(children->ElementAt(i), storage);
 
         std::vector<long> rest(result.size()-inRoi.size());
         it = std::set_difference(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
         rest.resize( it - rest.begin() );
         result = rest;
       }
       break;
     }
     }
   }
   else if ( dynamic_cast<mitk::PlanarFigure*>(roi->GetData()) )  // actual extraction
   {
     if ( dynamic_cast<mitk::PlanarPolygon*>(roi->GetData()) )
     {
       mitk::PlanarFigure::Pointer planarPoly = dynamic_cast<mitk::PlanarFigure*>(roi->GetData());
 
       //create vtkPolygon using controlpoints from planarFigure polygon
       vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
       for (unsigned int i=0; i<planarPoly->GetNumberOfControlPoints(); ++i)
       {
         itk::Point<double,3> p = planarPoly->GetWorldControlPoint(i);
         vtkIdType id = polygonVtk->GetPoints()->InsertNextPoint(p[0], p[1], p[2] );
         polygonVtk->GetPointIds()->InsertNextId(id);
       }
 
       MITK_INFO << "Extracting with polygon";
       boost::progress_display disp(m_NumFibers);
       for (int i=0; i<m_NumFibers; i++)
       {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         for (int j=0; j<numPoints-1; j++)
         {
           // Inputs
           double p1[3] = {0,0,0};
           points->GetPoint(j, p1);
           double p2[3] = {0,0,0};
           points->GetPoint(j+1, p2);
           double tolerance = 0.001;
 
           // Outputs
           double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
           double x[3] = {0,0,0}; // The coordinate of the intersection
           double pcoords[3] = {0,0,0};
           int subId = 0;
 
           int iD = polygonVtk->IntersectWithLine(p1, p2, tolerance, t, x, pcoords, subId);
           if (iD!=0)
           {
             result.push_back(i);
             break;
           }
         }
       }
     }
     else if ( dynamic_cast<mitk::PlanarCircle*>(roi->GetData()) )
     {
       mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(roi->GetData());
       Vector3D planeNormal = planarFigure->GetPlaneGeometry()->GetNormal();
       planeNormal.Normalize();
 
       //calculate circle radius
       mitk::Point3D V1w = planarFigure->GetWorldControlPoint(0); //centerPoint
       mitk::Point3D V2w  = planarFigure->GetWorldControlPoint(1); //radiusPoint
 
       double radius = V1w.EuclideanDistanceTo(V2w);
       radius *= radius;
 
       MITK_INFO << "Extracting with circle";
       boost::progress_display disp(m_NumFibers);
       for (int i=0; i<m_NumFibers; i++)
       {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         for (int j=0; j<numPoints-1; j++)
         {
           // Inputs
           double p1[3] = {0,0,0};
           points->GetPoint(j, p1);
           double p2[3] = {0,0,0};
           points->GetPoint(j+1, p2);
 
           // Outputs
           double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
           double x[3] = {0,0,0}; // The coordinate of the intersection
 
           int iD = vtkPlane::IntersectWithLine(p1,p2,planeNormal.GetDataPointer(),V1w.GetDataPointer(),t,x);
 
           if (iD!=0)
           {
             double dist = (x[0]-V1w[0])*(x[0]-V1w[0])+(x[1]-V1w[1])*(x[1]-V1w[1])+(x[2]-V1w[2])*(x[2]-V1w[2]);
             if( dist <= radius)
             {
               result.push_back(i);
               break;
             }
           }
         }
       }
     }
     return result;
   }
 
   return result;
 }
 
 void mitk::FiberBundle::UpdateFiberGeometry()
 {
   vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
   cleaner->SetInputData(m_FiberPolyData);
   cleaner->PointMergingOff();
   cleaner->Update();
   m_FiberPolyData = cleaner->GetOutput();
 
   m_FiberLengths.clear();
   m_MeanFiberLength = 0;
   m_MedianFiberLength = 0;
   m_LengthStDev = 0;
   m_NumFibers = m_FiberPolyData->GetNumberOfCells();
 
   if (m_FiberColors==nullptr || m_FiberColors->GetNumberOfTuples()!=m_FiberPolyData->GetNumberOfPoints())
     this->ColorFibersByOrientation();
 
   if (m_FiberWeights->GetNumberOfValues()!=m_NumFibers)
   {
     m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     m_FiberWeights->SetName("FIBER_WEIGHTS");
     m_FiberWeights->SetNumberOfValues(m_NumFibers);
     this->SetFiberWeights(1);
   }
 
   if (m_NumFibers<=0) // no fibers present; apply default geometry
   {
     m_MinFiberLength = 0;
     m_MaxFiberLength = 0;
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetImageGeometry(false);
     float b[] = {0, 1, 0, 1, 0, 1};
     geometry->SetFloatBounds(b);
     SetGeometry(geometry);
     return;
   }
   double b[6];
   m_FiberPolyData->GetBounds(b);
 
   // calculate statistics
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int p = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
     float length = 0;
     for (int j=0; j<p-1; j++)
     {
       double p1[3];
       points->GetPoint(j, p1);
       double p2[3];
       points->GetPoint(j+1, p2);
 
       float dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
       length += dist;
     }
     m_FiberLengths.push_back(length);
     m_MeanFiberLength += length;
     if (i==0)
     {
       m_MinFiberLength = length;
       m_MaxFiberLength = length;
     }
     else
     {
       if (length<m_MinFiberLength)
         m_MinFiberLength = length;
       if (length>m_MaxFiberLength)
         m_MaxFiberLength = length;
     }
   }
   m_MeanFiberLength /= m_NumFibers;
 
   std::vector< float > sortedLengths = m_FiberLengths;
   std::sort(sortedLengths.begin(), sortedLengths.end());
   for (int i=0; i<m_NumFibers; i++)
     m_LengthStDev += (m_MeanFiberLength-sortedLengths.at(i))*(m_MeanFiberLength-sortedLengths.at(i));
   if (m_NumFibers>1)
     m_LengthStDev /= (m_NumFibers-1);
   else
     m_LengthStDev = 0;
   m_LengthStDev = std::sqrt(m_LengthStDev);
   m_MedianFiberLength = sortedLengths.at(m_NumFibers/2);
 
   mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
   geometry->SetFloatBounds(b);
   this->SetGeometry(geometry);
 
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 float mitk::FiberBundle::GetFiberWeight(unsigned int fiber) const
 {
   return m_FiberWeights->GetValue(fiber);
 }
 
 void mitk::FiberBundle::SetFiberWeights(float newWeight)
 {
   for (int i=0; i<m_FiberWeights->GetNumberOfValues(); i++)
     m_FiberWeights->SetValue(i, newWeight);
 }
 
 void mitk::FiberBundle::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
 {
   if (m_NumFibers!=weights->GetNumberOfValues())
   {
     MITK_INFO << "Weights array not equal to number of fibers! " << weights->GetNumberOfValues() << " vs " << m_NumFibers;
     return;
   }
 
   for (int i=0; i<weights->GetNumberOfValues(); i++)
     m_FiberWeights->SetValue(i, weights->GetValue(i));
 
   m_FiberWeights->SetName("FIBER_WEIGHTS");
 }
 
 void mitk::FiberBundle::SetFiberWeight(unsigned int fiber, float weight)
 {
   m_FiberWeights->SetValue(fiber, weight);
 }
 
 void mitk::FiberBundle::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
 {
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
     unsigned char source[4] = {0,0,0,0};
     fiberColors->GetTypedTuple(i, source);
 
     unsigned char target[4] = {0,0,0,0};
     target[0] = source[0];
     target[1] = source[1];
     target[2] = source[2];
     target[3] = source[3];
     m_FiberColors->InsertTypedTuple(i, target);
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 itk::Matrix< double, 3, 3 > mitk::FiberBundle::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
 {
   rx = rx*M_PI/180;
   ry = ry*M_PI/180;
   rz = rz*M_PI/180;
 
   itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
   rotX[1][1] = cos(rx);
   rotX[2][2] = rotX[1][1];
   rotX[1][2] = -sin(rx);
   rotX[2][1] = -rotX[1][2];
 
   itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
   rotY[0][0] = cos(ry);
   rotY[2][2] = rotY[0][0];
   rotY[0][2] = sin(ry);
   rotY[2][0] = -rotY[0][2];
 
   itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
   rotZ[0][0] = cos(rz);
   rotZ[1][1] = rotZ[0][0];
   rotZ[0][1] = -sin(rz);
   rotZ[1][0] = -rotZ[0][1];
 
   itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
   m = rot*m;
 
   return m;
 }
 
 itk::Point<float, 3> mitk::FiberBundle::TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz)
 {
   rx = rx*M_PI/180;
   ry = ry*M_PI/180;
   rz = rz*M_PI/180;
 
   vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
   rotX[1][1] = cos(rx);
   rotX[2][2] = rotX[1][1];
   rotX[1][2] = -sin(rx);
   rotX[2][1] = -rotX[1][2];
 
   vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
   rotY[0][0] = cos(ry);
   rotY[2][2] = rotY[0][0];
   rotY[0][2] = sin(ry);
   rotY[2][0] = -rotY[0][2];
 
   vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
   rotZ[0][0] = cos(rz);
   rotZ[1][1] = rotZ[0][0];
   rotZ[0][1] = -sin(rz);
   rotZ[1][0] = -rotZ[0][1];
 
   vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
 
   mitk::BaseGeometry::Pointer geom = this->GetGeometry();
   mitk::Point3D center = geom->GetCenter();
 
   point[0] -= center[0];
   point[1] -= center[1];
   point[2] -= center[2];
   point = rot*point;
   point[0] += center[0]+tx;
   point[1] += center[1]+ty;
   point[2] += center[2]+tz;
   itk::Point<float, 3> out; out[0] = point[0]; out[1] = point[1]; out[2] = point[2];
   return out;
 }
 
 void mitk::FiberBundle::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
 {
   rx = rx*M_PI/180;
   ry = ry*M_PI/180;
   rz = rz*M_PI/180;
 
   vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
   rotX[1][1] = cos(rx);
   rotX[2][2] = rotX[1][1];
   rotX[1][2] = -sin(rx);
   rotX[2][1] = -rotX[1][2];
 
   vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
   rotY[0][0] = cos(ry);
   rotY[2][2] = rotY[0][0];
   rotY[0][2] = sin(ry);
   rotY[2][0] = -rotY[0][2];
 
   vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
   rotZ[0][0] = cos(rz);
   rotZ[1][1] = rotZ[0][0];
   rotZ[0][1] = -sin(rz);
   rotZ[1][0] = -rotZ[0][1];
 
   vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
 
   mitk::BaseGeometry::Pointer geom = this->GetGeometry();
   mitk::Point3D center = geom->GetCenter();
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double* p = points->GetPoint(j);
       vnl_vector_fixed< double, 3 > dir;
       dir[0] = p[0]-center[0];
       dir[1] = p[1]-center[1];
       dir[2] = p[2]-center[2];
       dir = rot*dir;
       dir[0] += center[0]+tx;
       dir[1] += center[1]+ty;
       dir[2] += center[2]+tz;
       vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
       container->GetPointIds()->InsertNextId(id);
     }
     vtkNewCells->InsertNextCell(container);
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::RotateAroundAxis(double x, double y, double z)
 {
   x = x*M_PI/180;
   y = y*M_PI/180;
   z = z*M_PI/180;
 
   vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
   rotX[1][1] = cos(x);
   rotX[2][2] = rotX[1][1];
   rotX[1][2] = -sin(x);
   rotX[2][1] = -rotX[1][2];
 
   vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
   rotY[0][0] = cos(y);
   rotY[2][2] = rotY[0][0];
   rotY[0][2] = sin(y);
   rotY[2][0] = -rotY[0][2];
 
   vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
   rotZ[0][0] = cos(z);
   rotZ[1][1] = rotZ[0][0];
   rotZ[0][1] = -sin(z);
   rotZ[1][0] = -rotZ[0][1];
 
   mitk::BaseGeometry::Pointer geom = this->GetGeometry();
   mitk::Point3D center = geom->GetCenter();
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double* p = points->GetPoint(j);
       vnl_vector_fixed< double, 3 > dir;
       dir[0] = p[0]-center[0];
       dir[1] = p[1]-center[1];
       dir[2] = p[2]-center[2];
       dir = rotZ*rotY*rotX*dir;
       dir[0] += center[0];
       dir[1] += center[1];
       dir[2] += center[2];
       vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
       container->GetPointIds()->InsertNextId(id);
     }
     vtkNewCells->InsertNextCell(container);
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::ScaleFibers(double x, double y, double z, bool subtractCenter)
 {
   MITK_INFO << "Scaling fibers";
   boost::progress_display disp(m_NumFibers);
 
   mitk::BaseGeometry* geom = this->GetGeometry();
   mitk::Point3D c = geom->GetCenter();
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (int i=0; i<m_NumFibers; i++)
   {
     ++disp ;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double* p = points->GetPoint(j);
       if (subtractCenter)
       {
         p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
       }
       p[0] *= x;
       p[1] *= y;
       p[2] *= z;
       if (subtractCenter)
       {
         p[0] += c[0]; p[1] += c[1]; p[2] += c[2];
       }
       vtkIdType id = vtkNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     vtkNewCells->InsertNextCell(container);
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::TranslateFibers(double x, double y, double z)
 {
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double* p = points->GetPoint(j);
       p[0] += x;
       p[1] += y;
       p[2] += z;
       vtkIdType id = vtkNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     vtkNewCells->InsertNextCell(container);
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::MirrorFibers(unsigned int axis)
 {
   if (axis>2)
     return;
 
   MITK_INFO << "Mirroring fibers";
   boost::progress_display disp(m_NumFibers);
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double* p = points->GetPoint(j);
       p[axis] = -p[axis];
       vtkIdType id = vtkNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     vtkNewCells->InsertNextCell(container);
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::RemoveDir(vnl_vector_fixed<double,3> dir, double threshold)
 {
   dir.normalize();
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     ++disp ;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     // calculate curvatures
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     bool discard = false;
     for (int j=0; j<numPoints-1; j++)
     {
       double p1[3];
       points->GetPoint(j, p1);
       double p2[3];
       points->GetPoint(j+1, p2);
 
       vnl_vector_fixed< double, 3 > v1;
       v1[0] = p2[0]-p1[0];
       v1[1] = p2[1]-p1[1];
       v1[2] = p2[2]-p1[2];
       if (v1.magnitude()>0.001)
       {
         v1.normalize();
 
         if (fabs(dot_product(v1,dir))>threshold)
         {
           discard = true;
           break;
         }
       }
     }
     if (!discard)
     {
       for (int j=0; j<numPoints; j++)
       {
         double p1[3];
         points->GetPoint(j, p1);
 
         vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
         container->GetPointIds()->InsertNextId(id);
       }
       vtkNewCells->InsertNextCell(container);
     }
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
 
   this->SetFiberPolyData(m_FiberPolyData, true);
 
   //    UpdateColorCoding();
   //    UpdateFiberGeometry();
 }
 
 bool mitk::FiberBundle::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
 {
   if (minRadius<0)
     return true;
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   MITK_INFO << "Applying curvature threshold";
   boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     ++disp ;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     // calculate curvatures
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints-2; j++)
     {
       double p1[3];
       points->GetPoint(j, p1);
       double p2[3];
       points->GetPoint(j+1, p2);
       double p3[3];
       points->GetPoint(j+2, p3);
 
       vnl_vector_fixed< float, 3 > v1, v2, v3;
 
       v1[0] = p2[0]-p1[0];
       v1[1] = p2[1]-p1[1];
       v1[2] = p2[2]-p1[2];
 
       v2[0] = p3[0]-p2[0];
       v2[1] = p3[1]-p2[1];
       v2[2] = p3[2]-p2[2];
 
       v3[0] = p1[0]-p3[0];
       v3[1] = p1[1]-p3[1];
       v3[2] = p1[2]-p3[2];
 
       float a = v1.magnitude();
       float b = v2.magnitude();
       float c = v3.magnitude();
       float r = a*b*c/std::sqrt((a+b+c)*(a+b-c)*(b+c-a)*(a-b+c)); // radius of triangle via Heron's formula (area of triangle)
 
       vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
       container->GetPointIds()->InsertNextId(id);
 
       if (deleteFibers && r<minRadius)
         break;
 
       if (r<minRadius)
       {
         j += 2;
         vtkNewCells->InsertNextCell(container);
         container = vtkSmartPointer<vtkPolyLine>::New();
       }
       else if (j==numPoints-3)
       {
         id = vtkNewPoints->InsertNextPoint(p2);
         container->GetPointIds()->InsertNextId(id);
         id = vtkNewPoints->InsertNextPoint(p3);
         container->GetPointIds()->InsertNextId(id);
         vtkNewCells->InsertNextCell(container);
       }
     }
   }
 
   if (vtkNewCells->GetNumberOfCells()<=0)
     return false;
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
   return true;
 }
 
 bool mitk::FiberBundle::RemoveShortFibers(float lengthInMM)
 {
   MITK_INFO << "Removing short fibers";
   if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
   {
     MITK_INFO << "No fibers shorter than " << lengthInMM << " mm found!";
     return true;
   }
 
   if (lengthInMM>m_MaxFiberLength)    // can't remove all fibers
   {
     MITK_WARN << "Process aborted. No fibers would be left!";
     return false;
   }
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
   float min = m_MaxFiberLength;
 
   boost::progress_display disp(m_NumFibers);
   for (int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (m_FiberLengths.at(i)>=lengthInMM)
     {
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       for (int j=0; j<numPoints; j++)
       {
         double* p = points->GetPoint(j);
         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       vtkNewCells->InsertNextCell(container);
       if (m_FiberLengths.at(i)<min)
         min = m_FiberLengths.at(i);
     }
   }
 
   if (vtkNewCells->GetNumberOfCells()<=0)
     return false;
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
   return true;
 }
 
 bool mitk::FiberBundle::RemoveLongFibers(float lengthInMM)
 {
   if (lengthInMM<=0 || lengthInMM>m_MaxFiberLength)
     return true;
 
   if (lengthInMM<m_MinFiberLength)    // can't remove all fibers
     return false;
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   MITK_INFO << "Removing long fibers";
   boost::progress_display disp(m_NumFibers);
   for (int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (m_FiberLengths.at(i)<=lengthInMM)
     {
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       for (int j=0; j<numPoints; j++)
       {
         double* p = points->GetPoint(j);
         vtkIdType id = vtkNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       vtkNewCells->InsertNextCell(container);
     }
   }
 
   if (vtkNewCells->GetNumberOfCells()<=0)
     return false;
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkNewPoints);
   m_FiberPolyData->SetLines(vtkNewCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
   return true;
 }
 
 void mitk::FiberBundle::ResampleSpline(float pointDistance, double tension, double continuity, double bias )
 {
   if (pointDistance<=0)
     return;
 
   vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
 
   //in vtkcells all polylines are stored, actually all id's of them are stored
   vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
-  vtkIdType pointHelperCnt = 0;
 
   MITK_INFO << "Smoothing fibers";
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(m_NumFibers);
 
+  std::vector< vtkSmartPointer<vtkPolyLine> > resampled_streamlines;
+  resampled_streamlines.resize(m_NumFibers);
+
   boost::progress_display disp(m_NumFibers);
 #pragma omp parallel for
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
     float length = 0;
-    float weight = 1;
 #pragma omp critical
     {
       length = m_FiberLengths.at(i);
-      weight = m_FiberWeights->GetValue(i);
       ++disp;
       vtkCell* cell = m_FiberPolyData->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
       for (int j=0; j<numPoints; j++)
         newPoints->InsertNextPoint(points->GetPoint(j));
     }
 
     int sampling = std::ceil(length/pointDistance);
 
     vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
     vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
     vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
     xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
     ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
     zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
 
     vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
     spline->SetXSpline(xSpline);
     spline->SetYSpline(ySpline);
     spline->SetZSpline(zSpline);
     spline->SetPoints(newPoints);
 
     vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
     functionSource->SetParametricFunction(spline);
     functionSource->SetUResolution(sampling);
     functionSource->SetVResolution(sampling);
     functionSource->SetWResolution(sampling);
     functionSource->Update();
 
     vtkPolyData* outputFunction = functionSource->GetOutput();
     vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
 
     vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
-    smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
 
 #pragma omp critical
     {
-      for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
+      for (int j=0; j<tmpSmoothPnts->GetNumberOfPoints(); j++)
       {
-        smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
-        vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
+        vtkIdType id = vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
+        smoothLine->GetPointIds()->InsertNextId(id);
       }
 
-      newFiberWeights->SetValue(vtkSmoothCells->GetNumberOfCells(), weight);
-      vtkSmoothCells->InsertNextCell(smoothLine);
-      pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
+      resampled_streamlines[i] = smoothLine;
     }
   }
 
-  SetFiberWeights(newFiberWeights);
+  for (auto container : resampled_streamlines)
+  {
+    vtkSmoothCells->InsertNextCell(container);
+  }
+
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkSmoothPoints);
   m_FiberPolyData->SetLines(vtkSmoothCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::ResampleSpline(float pointDistance)
 {
   ResampleSpline(pointDistance, 0, 0, 0 );
 }
 
 unsigned long mitk::FiberBundle::GetNumberOfPoints() const
 {
   unsigned long points = 0;
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     points += cell->GetNumberOfPoints();
   }
   return points;
 }
 
 void mitk::FiberBundle::Compress(float error)
 {
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   MITK_INFO << "Compressing fibers";
   unsigned long numRemovedPoints = 0;
   boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(m_NumFibers);
 
 #pragma omp parallel for
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
 
     std::vector< vnl_vector_fixed< double, 3 > > vertices;
     float weight = 1;
 
 #pragma omp critical
     {
       ++disp;
       weight = m_FiberWeights->GetValue(i);
       vtkCell* cell = m_FiberPolyData->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       for (int j=0; j<numPoints; j++)
       {
         double cand[3];
         points->GetPoint(j, cand);
         vnl_vector_fixed< double, 3 > candV;
         candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
         vertices.push_back(candV);
       }
     }
 
     // calculate curvatures
     int numPoints = vertices.size();
     std::vector< int > removedPoints; removedPoints.resize(numPoints, 0);
     removedPoints[0]=-1; removedPoints[numPoints-1]=-1;
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     int remCounter = 0;
 
     bool pointFound = true;
     while (pointFound)
     {
       pointFound = false;
       double minError = error;
       int removeIndex = -1;
 
       for (unsigned int j=0; j<vertices.size(); j++)
       {
         if (removedPoints[j]==0)
         {
           vnl_vector_fixed< double, 3 > candV = vertices.at(j);
 
           int validP = -1;
           vnl_vector_fixed< double, 3 > pred;
           for (int k=j-1; k>=0; k--)
             if (removedPoints[k]<=0)
             {
               pred = vertices.at(k);
               validP = k;
               break;
             }
           int validS = -1;
           vnl_vector_fixed< double, 3 > succ;
           for (int k=j+1; k<numPoints; k++)
             if (removedPoints[k]<=0)
             {
               succ = vertices.at(k);
               validS = k;
               break;
             }
 
           if (validP>=0 && validS>=0)
           {
             double a = (candV-pred).magnitude();
             double b = (candV-succ).magnitude();
             double c = (pred-succ).magnitude();
             double s=0.5*(a+b+c);
             double hc=(2.0/c)*sqrt(fabs(s*(s-a)*(s-b)*(s-c)));
 
             if (hc<minError)
             {
               removeIndex = j;
               minError = hc;
               pointFound = true;
             }
           }
         }
       }
 
       if (pointFound)
       {
         removedPoints[removeIndex] = 1;
         remCounter++;
       }
     }
 
     for (int j=0; j<numPoints; j++)
     {
       if (removedPoints[j]<=0)
       {
 #pragma omp critical
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(vertices.at(j).data_block());
           container->GetPointIds()->InsertNextId(id);
         }
       }
     }
 
 #pragma omp critical
     {
       newFiberWeights->SetValue(vtkNewCells->GetNumberOfCells(), weight);
       numRemovedPoints += remCounter;
       vtkNewCells->InsertNextCell(container);
     }
   }
 
   if (vtkNewCells->GetNumberOfCells()>0)
   {
     MITK_INFO << "Removed points: " << numRemovedPoints;
     SetFiberWeights(newFiberWeights);
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
   }
 }
 
 void mitk::FiberBundle::ResampleToNumPoints(unsigned int targetPoints)
 {
   if (targetPoints<2)
     mitkThrow() << "Minimum two points required for resampling!";
 
   MITK_INFO << "Resampling fibers (number of points " << targetPoints << ")";
 
   bool unequal_fibs = true;
   while (unequal_fibs)
   {
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     newFiberWeights->SetName("FIBER_WEIGHTS");
     newFiberWeights->SetNumberOfValues(m_NumFibers);
 
     unequal_fibs = false;
 //#pragma omp parallel for
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
 
       std::vector< vnl_vector_fixed< double, 3 > > vertices;
       float weight = 1;
 
       double seg_len = 0;
 
 //#pragma omp critical
       {
         weight = m_FiberWeights->GetValue(i);
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         if ((unsigned int)numPoints!=targetPoints)
           seg_len = this->GetFiberLength(i)/(targetPoints-1);;
         vtkPoints* points = cell->GetPoints();
 
         for (int j=0; j<numPoints; j++)
         {
           double cand[3];
           points->GetPoint(j, cand);
           vnl_vector_fixed< double, 3 > candV;
           candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
           vertices.push_back(candV);
         }
       }
 
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       vnl_vector_fixed< double, 3 > lastV = vertices.at(0);
 
 //#pragma omp critical
       {
         vtkIdType id = vtkNewPoints->InsertNextPoint(lastV.data_block());
         container->GetPointIds()->InsertNextId(id);
       }
       for (unsigned int j=1; j<vertices.size(); j++)
       {
         vnl_vector_fixed< double, 3 > vec = vertices.at(j) - lastV;
         double new_dist = vec.magnitude();
 
         if (new_dist >= seg_len && seg_len>0)
         {
           vnl_vector_fixed< double, 3 > newV = lastV;
           if ( new_dist-seg_len <= mitk::eps )
           {
             vec.normalize();
             newV += vec * seg_len;
           }
           else
           {
             // intersection between sphere (radius 'pointDistance', center 'lastV') and line (direction 'd' and point 'p')
             vnl_vector_fixed< double, 3 > p = vertices.at(j-1);
             vnl_vector_fixed< double, 3 > d = vertices.at(j) - p;
 
             double a = d[0]*d[0] + d[1]*d[1] + d[2]*d[2];
             double b = 2 * (d[0] * (p[0] - lastV[0]) + d[1] * (p[1] - lastV[1]) + d[2] * (p[2] - lastV[2]));
             double c = (p[0] - lastV[0])*(p[0] - lastV[0]) + (p[1] - lastV[1])*(p[1] - lastV[1]) + (p[2] - lastV[2])*(p[2] - lastV[2]) - seg_len*seg_len;
 
             double v1 =(-b + std::sqrt(b*b-4*a*c))/(2*a);
             double v2 =(-b - std::sqrt(b*b-4*a*c))/(2*a);
 
             if (v1>0)
               newV = p + d * v1;
             else if (v2>0)
               newV = p + d * v2;
             else
               MITK_INFO << "ERROR1 - linear resampling";
 
             j--;
           }
 
 //#pragma omp critical
           {
             vtkIdType id = vtkNewPoints->InsertNextPoint(newV.data_block());
             container->GetPointIds()->InsertNextId(id);
           }
           lastV = newV;
         }
         else if ( (j==vertices.size()-1 && new_dist>0.0001) || seg_len==0)
         {
 //#pragma omp critical
           {
             vtkIdType id = vtkNewPoints->InsertNextPoint(vertices.at(j).data_block());
             container->GetPointIds()->InsertNextId(id);
           }
         }
       }
 
 //#pragma omp critical
       {
         newFiberWeights->SetValue(vtkNewCells->GetNumberOfCells(), weight);
         vtkNewCells->InsertNextCell(container);
         if (container->GetNumberOfPoints()!=targetPoints)
           unequal_fibs = true;
       }
     }
 
     if (vtkNewCells->GetNumberOfCells()>0)
     {
       SetFiberWeights(newFiberWeights);
       m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
       m_FiberPolyData->SetPoints(vtkNewPoints);
       m_FiberPolyData->SetLines(vtkNewCells);
       this->SetFiberPolyData(m_FiberPolyData, true);
     }
   }
 }
 
 void mitk::FiberBundle::ResampleLinear(double pointDistance)
 {
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   MITK_INFO << "Resampling fibers (linear)";
   boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(m_NumFibers);
 
+  std::vector< vtkSmartPointer<vtkPolyLine> > resampled_streamlines;
+  resampled_streamlines.resize(m_FiberPolyData->GetNumberOfCells());
+
 #pragma omp parallel for
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
 
     std::vector< vnl_vector_fixed< double, 3 > > vertices;
-    float weight = 1;
 
 #pragma omp critical
     {
       ++disp;
-      weight = m_FiberWeights->GetValue(i);
       vtkCell* cell = m_FiberPolyData->GetCell(i);
       int numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       for (int j=0; j<numPoints; j++)
       {
         double cand[3];
         points->GetPoint(j, cand);
         vnl_vector_fixed< double, 3 > candV;
         candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
         vertices.push_back(candV);
       }
     }
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     vnl_vector_fixed< double, 3 > lastV = vertices.at(0);
 
 #pragma omp critical
     {
       vtkIdType id = vtkNewPoints->InsertNextPoint(lastV.data_block());
       container->GetPointIds()->InsertNextId(id);
     }
     for (unsigned int j=1; j<vertices.size(); j++)
     {
       vnl_vector_fixed< double, 3 > vec = vertices.at(j) - lastV;
       double new_dist = vec.magnitude();
 
       if (new_dist >= pointDistance)
       {
         vnl_vector_fixed< double, 3 > newV = lastV;
         if ( new_dist-pointDistance <= mitk::eps )
         {
           vec.normalize();
           newV += vec * pointDistance;
         }
         else
         {
           // intersection between sphere (radius 'pointDistance', center 'lastV') and line (direction 'd' and point 'p')
           vnl_vector_fixed< double, 3 > p = vertices.at(j-1);
           vnl_vector_fixed< double, 3 > d = vertices.at(j) - p;
 
           double a = d[0]*d[0] + d[1]*d[1] + d[2]*d[2];
           double b = 2 * (d[0] * (p[0] - lastV[0]) + d[1] * (p[1] - lastV[1]) + d[2] * (p[2] - lastV[2]));
           double c = (p[0] - lastV[0])*(p[0] - lastV[0]) + (p[1] - lastV[1])*(p[1] - lastV[1]) + (p[2] - lastV[2])*(p[2] - lastV[2]) - pointDistance*pointDistance;
 
           double v1 =(-b + std::sqrt(b*b-4*a*c))/(2*a);
           double v2 =(-b - std::sqrt(b*b-4*a*c))/(2*a);
 
           if (v1>0)
             newV = p + d * v1;
           else if (v2>0)
             newV = p + d * v2;
           else
             MITK_INFO << "ERROR1 - linear resampling";
 
           j--;
         }
 
 #pragma omp critical
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(newV.data_block());
           container->GetPointIds()->InsertNextId(id);
         }
         lastV = newV;
       }
       else if (j==vertices.size()-1 && new_dist>0.0001)
       {
 #pragma omp critical
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(vertices.at(j).data_block());
           container->GetPointIds()->InsertNextId(id);
         }
       }
     }
 
 #pragma omp critical
     {
-      newFiberWeights->SetValue(vtkNewCells->GetNumberOfCells(), weight);
-      vtkNewCells->InsertNextCell(container);
+      resampled_streamlines[i] = container;
     }
   }
 
+  for (auto container : resampled_streamlines)
+  {
+    vtkNewCells->InsertNextCell(container);
+  }
+
   if (vtkNewCells->GetNumberOfCells()>0)
   {
-    SetFiberWeights(newFiberWeights);
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
   }
 }
 
 // reapply selected colorcoding in case PolyData structure has changed
 bool mitk::FiberBundle::Equals(mitk::FiberBundle* fib, double eps)
 {
   if (fib==nullptr)
   {
     MITK_INFO << "Reference bundle is nullptr!";
     return false;
   }
 
   if (m_NumFibers!=fib->GetNumFibers())
   {
     MITK_INFO << "Unequal number of fibers!";
     MITK_INFO << m_NumFibers << " vs. " << fib->GetNumFibers();
     return false;
   }
 
   for (int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i);
     int numPoints2 = cell2->GetNumberOfPoints();
     vtkPoints* points2 = cell2->GetPoints();
 
     if (numPoints2!=numPoints)
     {
       MITK_INFO << "Unequal number of points in fiber " << i << "!";
       MITK_INFO << numPoints2 << " vs. " << numPoints;
       return false;
     }
 
     for (int j=0; j<numPoints; j++)
     {
       double* p1 = points->GetPoint(j);
       double* p2 = points2->GetPoint(j);
       if (fabs(p1[0]-p2[0])>eps || fabs(p1[1]-p2[1])>eps || fabs(p1[2]-p2[2])>eps)
       {
         MITK_INFO << "Unequal points in fiber " << i << " at position " << j << "!";
         MITK_INFO << "p1: " << p1[0] << ", " << p1[1] << ", " << p1[2];
         MITK_INFO << "p2: " << p2[0] << ", " << p2[1] << ", " << p2[2];
         return false;
       }
     }
   }
 
   return true;
 }
 
 void mitk::FiberBundle::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << indent << this->GetNameOfClass() << ":\n";
   os << indent << "Number of fibers: " << this->GetNumFibers() << std::endl;
   os << indent << "Min. fiber length: " << this->GetMinFiberLength() << std::endl;
   os << indent << "Max. fiber length: " << this->GetMaxFiberLength() << std::endl;
   os << indent << "Mean fiber length: " << this->GetMeanFiberLength() << std::endl;
   os << indent << "Median fiber length: " << this->GetMedianFiberLength() << std::endl;
   os << indent << "STDEV fiber length: " << this->GetLengthStDev() << std::endl;
   os << indent << "Number of points: " << this->GetNumberOfPoints() << std::endl;
   Superclass::PrintSelf(os, indent);
 }
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
 void mitk::FiberBundle::UpdateOutputInformation()
 {
 
 }
 void mitk::FiberBundle::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::FiberBundle::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 bool mitk::FiberBundle::VerifyRequestedRegion()
 {
   return true;
 }
 void mitk::FiberBundle::SetRequestedRegion(const itk::DataObject* )
 {
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
index c23958824c..7751e2ee65 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.h
@@ -1,182 +1,181 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef _MITK_FiberBundle_H
 #define _MITK_FiberBundle_H
 
 //includes for MITK datastructure
 #include <mitkBaseData.h>
 #include <MitkFiberTrackingExports.h>
 #include <mitkImage.h>
 #include <mitkDataStorage.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPixelTypeTraits.h>
 #include <mitkPlanarFigureComposite.h>
 
 
 //includes storing fiberdata
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkDataSet.h>
 #include <vtkTransform.h>
 #include <vtkFloatArray.h>
 
 
 namespace mitk {
 
 /**
    * \brief Base Class for Fiber Bundles;   */
 class MITKFIBERTRACKING_EXPORT FiberBundle : public BaseData
 {
 public:
 
     typedef itk::Image<unsigned char, 3> ItkUcharImgType;
 
     // fiber colorcodings
     static const char* FIBER_ID_ARRAY;
 
     virtual void UpdateOutputInformation() override;
     virtual void SetRequestedRegionToLargestPossibleRegion() override;
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
     virtual bool VerifyRequestedRegion() override;
     virtual void SetRequestedRegion(const itk::DataObject*) override;
 
     mitkClassMacro( FiberBundle, BaseData )
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>) // custom constructor
 
     // colorcoding related methods
     void ColorFibersByFiberWeights(bool opacity, bool normalize);
     void ColorFibersByCurvature(bool opacity, bool normalize);
     void ColorFibersByScalarMap(mitk::Image::Pointer, bool opacity, bool normalize);
     template <typename TPixel>
     void ColorFibersByScalarMap(const mitk::PixelType pixelType, mitk::Image::Pointer, bool opacity, bool normalize);
     void ColorFibersByOrientation();
     void SetFiberOpacity(vtkDoubleArray *FAValArray);
     void ResetFiberOpacity();
     void SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors);
     void SetFiberColors(float r, float g, float b, float alpha=255);
     vtkSmartPointer<vtkUnsignedCharArray> GetFiberColors() const { return m_FiberColors; }
 
     // fiber compression
     void Compress(float error = 0.0);
 
     // fiber resampling
     void ResampleSpline(float pointDistance=1);
     void ResampleSpline(float pointDistance, double tension, double continuity, double bias );
     void ResampleLinear(double pointDistance=1);
     void ResampleToNumPoints(unsigned int targetPoints);
 
     mitk::FiberBundle::Pointer FilterByWeights(float weight_thr, bool invert=false);
     bool RemoveShortFibers(float lengthInMM);
     bool RemoveLongFibers(float lengthInMM);
     bool ApplyCurvatureThreshold(float minRadius, bool deleteFibers);
     void MirrorFibers(unsigned int axis);
     void RotateAroundAxis(double x, double y, double z);
     void TranslateFibers(double x, double y, double z);
     void ScaleFibers(double x, double y, double z, bool subtractCenter=true);
     void TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz);
     void RemoveDir(vnl_vector_fixed<double,3> dir, double threshold);
     itk::Point<float, 3> TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz);
     itk::Matrix< double, 3, 3 > TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz);
 
     // add/subtract fibers
     FiberBundle::Pointer AddBundle(FiberBundle* fib);
     mitk::FiberBundle::Pointer AddBundles(std::vector< mitk::FiberBundle::Pointer > fibs);
     FiberBundle::Pointer SubtractBundle(FiberBundle* fib);
 
     // fiber subset extraction
     FiberBundle::Pointer           ExtractFiberSubset(DataNode *roi, DataStorage* storage);
     std::vector<long>              ExtractFiberIdSubset(DataNode* roi, DataStorage* storage);
-    FiberBundle::Pointer           ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert=false, bool bothEnds=true, float fraction=0.0, bool do_resampling=true);
     FiberBundle::Pointer           RemoveFibersOutside(ItkUcharImgType* mask, bool invert=false);
     float                          GetOverlap(ItkUcharImgType* mask, bool do_resampling);
     mitk::FiberBundle::Pointer     SubsampleFibers(float factor);
 
     // get/set data
     float GetFiberLength(int index) const { return m_FiberLengths.at(index); }
     vtkSmartPointer<vtkFloatArray> GetFiberWeights() const { return m_FiberWeights; }
     float GetFiberWeight(unsigned int fiber) const;
     void SetFiberWeights(float newWeight);
     void SetFiberWeight(unsigned int fiber, float weight);
     void SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights);
     void SetFiberPolyData(vtkSmartPointer<vtkPolyData>, bool updateGeometry = true);
     vtkSmartPointer<vtkPolyData> GetFiberPolyData() const;
     itkGetConstMacro( NumFibers, int)
     //itkGetMacro( FiberSampling, int)
     itkGetConstMacro( MinFiberLength, float )
     itkGetConstMacro( MaxFiberLength, float )
     itkGetConstMacro( MeanFiberLength, float )
     itkGetConstMacro( MedianFiberLength, float )
     itkGetConstMacro( LengthStDev, float )
     itkGetConstMacro( UpdateTime2D, itk::TimeStamp )
     itkGetConstMacro( UpdateTime3D, itk::TimeStamp )
     void RequestUpdate2D(){ m_UpdateTime2D.Modified(); }
     void RequestUpdate3D(){ m_UpdateTime3D.Modified(); }
     void RequestUpdate(){ m_UpdateTime2D.Modified(); m_UpdateTime3D.Modified(); }
 
     unsigned long GetNumberOfPoints() const;
 
     // copy fiber bundle
     mitk::FiberBundle::Pointer GetDeepCopy();
 
     // compare fiber bundles
     bool Equals(FiberBundle* fib, double eps=0.01);
 
     itkSetMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
     itkGetConstMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
 
     vtkSmartPointer<vtkPolyData>    GeneratePolyDataByIds(std::vector<long> fiberIds, vtkSmartPointer<vtkFloatArray> weights);
 
 protected:
 
     FiberBundle( vtkPolyData* fiberPolyData = nullptr );
     virtual ~FiberBundle();
 
     void                            GenerateFiberIds();
     itk::Point<float, 3>            GetItkPoint(double point[3]);
     void                            UpdateFiberGeometry();
     virtual void                    PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
 private:
 
     // actual fiber container
     vtkSmartPointer<vtkPolyData>  m_FiberPolyData;
 
     // contains fiber ids
     vtkSmartPointer<vtkDataSet>   m_FiberIdDataSet;
 
     int   m_NumFibers;
 
     vtkSmartPointer<vtkUnsignedCharArray> m_FiberColors;
     vtkSmartPointer<vtkFloatArray> m_FiberWeights;
     std::vector< float > m_FiberLengths;
     float   m_MinFiberLength;
     float   m_MaxFiberLength;
     float   m_MeanFiberLength;
     float   m_MedianFiberLength;
     float   m_LengthStDev;
     itk::TimeStamp m_UpdateTime2D;
     itk::TimeStamp m_UpdateTime3D;
     mitk::BaseGeometry::Pointer m_ReferenceGeometry;
 };
 
 } // namespace mitk
 
 #endif /*  _MITK_FiberBundle_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
index 62f24da0bc..87c6c99c95 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
@@ -1,118 +1,139 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkImageCast.h>
 #include <mitkStandaloneDataStorage.h>
 #include <vtkDebugLeaks.h>
 #include <omp.h>
+#include <itkFiberExtractionFilter.h>
 
 /**Documentation
  *  Test if fiber transfortaiom methods work correctly
  */
 int mitkFiberExtractionTest(int argc, char* argv[])
 {
-    MITK_TEST_BEGIN("mitkFiberExtractionTest");
-
-    /// \todo Fix VTK memory leaks. Bug 18097.
-    vtkDebugLeaks::SetExitError(0);
-
-    MITK_INFO << "argc: " << argc;
-    MITK_TEST_CONDITION_REQUIRED(argc==13,"check for input data");
-
-    omp_set_num_threads(1);
-    try{
-        mitk::FiberBundle::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundle*>( mitk::IOUtil::Load(argv[1]).front().GetPointer() );
-        mitk::FiberBundle::Pointer testFibs = dynamic_cast<mitk::FiberBundle*>( mitk::IOUtil::Load(argv[2]).front().GetPointer() );
-
-        // test planar figure based extraction
-        auto data = mitk::IOUtil::Load(argv[3])[0];
-        auto pf1 = mitk::DataNode::New();
-        pf1->SetData(data);
-        
-        data = mitk::IOUtil::Load(argv[4])[0];
-        auto pf2 = mitk::DataNode::New();
-        pf2->SetData(data);
-        
-        data = mitk::IOUtil::Load(argv[5])[0];
-        auto pf3 = mitk::DataNode::New();
-        pf3->SetData(data);
-        
-        mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
-
-        mitk::PlanarFigureComposite::Pointer pfc2 = mitk::PlanarFigureComposite::New();
-        pfc2->setOperationType(mitk::PlanarFigureComposite::OR);
-        mitk::DataNode::Pointer pfcNode2 = mitk::DataNode::New();
-        pfcNode2->SetData(pfc2);
-        mitk::DataStorage::SetOfObjects::Pointer set2 = mitk::DataStorage::SetOfObjects::New();
-        set2->push_back(pfcNode2);
-
-        mitk::PlanarFigureComposite::Pointer pfc1 = mitk::PlanarFigureComposite::New();
-        pfc1->setOperationType(mitk::PlanarFigureComposite::AND);
-        mitk::DataNode::Pointer pfcNode1 = mitk::DataNode::New();
-        pfcNode1->SetData(pfc1);
-        mitk::DataStorage::SetOfObjects::Pointer set1 = mitk::DataStorage::SetOfObjects::New();
-        set1->push_back(pfcNode1);
-
-        storage->Add(pfcNode2);
-        storage->Add(pf1, set2);
-        storage->Add(pfcNode1, set2);
-        storage->Add(pf2, set1);
-        storage->Add(pf3, set1);
-
-        MITK_INFO << "TEST1";
-        mitk::FiberBundle::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfcNode2, storage);
-        MITK_INFO << "TEST2";
-        MITK_TEST_CONDITION_REQUIRED(extractedFibs->Equals(testFibs),"check planar figure extraction");
-
-        MITK_INFO << "TEST3";
-        // test subtraction and addition
-        mitk::FiberBundle::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
-
-        MITK_INFO << argv[11];
-        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[11]).front().GetPointer());
-        MITK_TEST_CONDITION_REQUIRED(notExtractedFibs->Equals(testFibs),"check bundle subtraction");
-
-        mitk::FiberBundle::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
-        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[12]).front().GetPointer());
-        MITK_TEST_CONDITION_REQUIRED(joinded->Equals(testFibs),"check bundle addition");
-
-        // test binary image based extraction
-        mitk::Image::Pointer mitkRoiImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(argv[6]).front().GetPointer());
-        typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
-        itkUCharImageType::Pointer itkRoiImage = itkUCharImageType::New();
-        mitk::CastToItkImage(mitkRoiImage, itkRoiImage);
-
-        mitk::FiberBundle::Pointer passing = groundTruthFibs->ExtractFiberSubset(itkRoiImage, true);
-        mitk::FiberBundle::Pointer ending = groundTruthFibs->ExtractFiberSubset(itkRoiImage, false);
-
-        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[9]).front().GetPointer());
-        MITK_TEST_CONDITION_REQUIRED(passing->Equals(testFibs),"check passing mask extraction");
-
-        testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[10]).front().GetPointer());
-        MITK_TEST_CONDITION_REQUIRED(ending->Equals(testFibs),"check ending in mask extraction");
+  MITK_TEST_BEGIN("mitkFiberExtractionTest");
+
+  /// \todo Fix VTK memory leaks. Bug 18097.
+  vtkDebugLeaks::SetExitError(0);
+
+  MITK_INFO << "argc: " << argc;
+  MITK_TEST_CONDITION_REQUIRED(argc==13,"check for input data");
+
+  omp_set_num_threads(1);
+  try{
+    mitk::FiberBundle::Pointer groundTruthFibs = dynamic_cast<mitk::FiberBundle*>( mitk::IOUtil::Load(argv[1]).front().GetPointer() );
+    mitk::FiberBundle::Pointer testFibs = dynamic_cast<mitk::FiberBundle*>( mitk::IOUtil::Load(argv[2]).front().GetPointer() );
+
+    // test planar figure based extraction
+    auto data = mitk::IOUtil::Load(argv[3])[0];
+    auto pf1 = mitk::DataNode::New();
+    pf1->SetData(data);
+
+    data = mitk::IOUtil::Load(argv[4])[0];
+    auto pf2 = mitk::DataNode::New();
+    pf2->SetData(data);
+
+    data = mitk::IOUtil::Load(argv[5])[0];
+    auto pf3 = mitk::DataNode::New();
+    pf3->SetData(data);
+
+    mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
+
+    mitk::PlanarFigureComposite::Pointer pfc2 = mitk::PlanarFigureComposite::New();
+    pfc2->setOperationType(mitk::PlanarFigureComposite::OR);
+    mitk::DataNode::Pointer pfcNode2 = mitk::DataNode::New();
+    pfcNode2->SetData(pfc2);
+    mitk::DataStorage::SetOfObjects::Pointer set2 = mitk::DataStorage::SetOfObjects::New();
+    set2->push_back(pfcNode2);
+
+    mitk::PlanarFigureComposite::Pointer pfc1 = mitk::PlanarFigureComposite::New();
+    pfc1->setOperationType(mitk::PlanarFigureComposite::AND);
+    mitk::DataNode::Pointer pfcNode1 = mitk::DataNode::New();
+    pfcNode1->SetData(pfc1);
+    mitk::DataStorage::SetOfObjects::Pointer set1 = mitk::DataStorage::SetOfObjects::New();
+    set1->push_back(pfcNode1);
+
+    storage->Add(pfcNode2);
+    storage->Add(pf1, set2);
+    storage->Add(pfcNode1, set2);
+    storage->Add(pf2, set1);
+    storage->Add(pf3, set1);
+
+    MITK_INFO << "TEST1";
+    mitk::FiberBundle::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfcNode2, storage);
+    MITK_INFO << "TEST2";
+    MITK_TEST_CONDITION_REQUIRED(extractedFibs->Equals(testFibs),"check planar figure extraction");
+
+    MITK_INFO << "TEST3";
+    // test subtraction and addition
+    mitk::FiberBundle::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
+
+    MITK_INFO << argv[11];
+    testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[11]).front().GetPointer());
+    MITK_TEST_CONDITION_REQUIRED(notExtractedFibs->Equals(testFibs),"check bundle subtraction");
+
+    mitk::FiberBundle::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
+    testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[12]).front().GetPointer());
+    MITK_TEST_CONDITION_REQUIRED(joinded->Equals(testFibs),"check bundle addition");
+
+    // test binary image based extraction
+    mitk::Image::Pointer mitkRoiImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(argv[6]).front().GetPointer());
+    typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
+    itkUCharImageType::Pointer itkRoiImage = itkUCharImageType::New();
+    mitk::CastToItkImage(mitkRoiImage, itkRoiImage);
+
+    {
+      testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[9]).front().GetPointer());
+      itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
+      mitk::FiberBundle::Pointer test = groundTruthFibs->GetDeepCopy();
+      test->ResampleLinear(0.2);
+      extractor->SetInputFiberBundle(test);
+      extractor->SetRoiImages({itkRoiImage});
+      extractor->SetOverlapFraction(0.0);
+      extractor->SetBothEnds(true);
+      extractor->SetDontResampleFibers(true);
+      extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::OVERLAP);
+      extractor->Update();
+      mitk::FiberBundle::Pointer passing = extractor->GetPositives().at(0);
+      MITK_TEST_CONDITION_REQUIRED(passing->Equals(testFibs),"check passing mask extraction");
     }
-    catch(...) {
-        return EXIT_FAILURE;
+
+    {
+      testFibs = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(argv[10]).front().GetPointer());
+      itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
+      extractor->SetInputFiberBundle(groundTruthFibs);
+      extractor->SetRoiImages({itkRoiImage});
+      extractor->SetOverlapFraction(0.0);
+      extractor->SetBothEnds(true);
+      extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::ENDPOINTS);
+      extractor->Update();
+      mitk::FiberBundle::Pointer ending = extractor->GetPositives().at(0);
+      MITK_TEST_CONDITION_REQUIRED(ending->Equals(testFibs),"check ending in mask extraction");
     }
+  }
+  catch(...) {
+    return EXIT_FAILURE;
+  }
 
-    // always end with this!
-    MITK_TEST_END();
+  // always end with this!
+  MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkMachineLearningTrackingTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkMachineLearningTrackingTest.cpp
index 25dd661f25..36f231a281 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkMachineLearningTrackingTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkMachineLearningTrackingTest.cpp
@@ -1,108 +1,109 @@
 /*===================================================================
 
 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 "mitkTestingMacros.h"
 #include <mitkFiberBundle.h>
 #include <mitkBaseData.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkTestingConfig.h>
 #include <mitkIOUtil.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <mitkTrackingHandlerRandomForest.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <omp.h>
 #include <mitkTractographyForest.h>
 
 #include "mitkTestFixture.h"
 
 class mitkMachineLearningTrackingTestSuite : public mitk::TestFixture
 {
 
     CPPUNIT_TEST_SUITE(mitkMachineLearningTrackingTestSuite);
     MITK_TEST(Track1);
     CPPUNIT_TEST_SUITE_END();
 
-    typedef itk::Image<unsigned char, 3> ItkUcharImgType;
+    typedef itk::Image<float, 3> ItkFloatImgType;
 
 private:
 
     /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
     mitk::FiberBundle::Pointer ref;
     mitk::TrackingHandlerRandomForest<6, 100>* tfh;
     mitk::Image::Pointer dwi;
-    ItkUcharImgType::Pointer seed;
+    ItkFloatImgType::Pointer seed;
 
 public:
 
     void setUp() override
     {
         ref = nullptr;
         tfh = new mitk::TrackingHandlerRandomForest<6,100>();
 
         std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(GetTestDataFilePath("DiffusionImaging/MachineLearningTracking/ReferenceTracts.fib"));
         mitk::BaseData::Pointer baseData = fibInfile.at(0);
         ref = dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 
         dwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("DiffusionImaging/MachineLearningTracking/DiffusionImage.dwi"))[0].GetPointer());
 
 
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("DiffusionImaging/MachineLearningTracking/seed.nrrd"))[0].GetPointer());
-        seed = ItkUcharImgType::New();
+        seed = ItkFloatImgType::New();
         mitk::CastToItkImage(img, seed);
 
         mitk::TractographyForest::Pointer forest = dynamic_cast<mitk::TractographyForest*>(mitk::IOUtil::Load(GetTestDataFilePath("DiffusionImaging/MachineLearningTracking/forest.rf"))[0].GetPointer());
 
         tfh->SetForest(forest);
         tfh->AddDwi(dwi);
     }
 
     void tearDown() override
     {
         delete tfh;
         ref = nullptr;
     }
 
     void Track1()
     {
         omp_set_num_threads(1);
         typedef itk::StreamlineTrackingFilter TrackerType;
         TrackerType::Pointer tracker = TrackerType::New();
         tracker->SetDemoMode(false);
+        tracker->SetInterpolateMask(false);
         tracker->SetSeedImage(seed);
         tracker->SetSeedsPerVoxel(1);
         tracker->SetStepSize(-1);
         tracker->SetAngularThreshold(45);
         tracker->SetMinTractLength(20);
         tracker->SetMaxTractLength(400);
         tracker->SetTrackingHandler(tfh);
         tracker->SetAposterioriCurvCheck(false);
         tracker->SetAvoidStop(true);
         tracker->SetSamplingDistance(0.5);
         tracker->SetRandomSampling(false);
         tracker->Update();
         vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
         mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
         //MITK_INFO << mitk::IOUtil::GetTempPath() << "ReferenceTracts.fib";
         //mitk::IOUtil::Save(outFib, mitk::IOUtil::GetTempPath()+"ReferenceTracts.fib");
 
         CPPUNIT_ASSERT_MESSAGE("Should be equal", ref->Equals(outFib));
     }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkMachineLearningTracking)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp
index 461c3cb8b4..9e23f45457 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp
@@ -1,429 +1,427 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 #include <mitkOdfImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingDataHandler.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTestingMacros.h>
 #include <mitkTestFixture.h>
 #include <mitkFiberBundle.h>
 #include <omp.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkEqual.h>
 
 class mitkStreamlineTractographyTestSuite : public mitk::TestFixture
 {
 
   CPPUNIT_TEST_SUITE(mitkStreamlineTractographyTestSuite);
   MITK_TEST(Test_Peak1);
   MITK_TEST(Test_Peak2);
   MITK_TEST(Test_Tensor1);
   MITK_TEST(Test_Tensor2);
   MITK_TEST(Test_Tensor3);
   MITK_TEST(Test_Odf1);
   MITK_TEST(Test_Odf2);
   MITK_TEST(Test_Odf3);
   MITK_TEST(Test_Odf4);
   MITK_TEST(Test_Odf5);
   MITK_TEST(Test_Odf6);
   CPPUNIT_TEST_SUITE_END();
 
   typedef itk::VectorImage< short, 3>   ItkDwiType;
 
 private:
 
 public:
 
   /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
 
-  typedef itk::Image<unsigned char, 3> ItkUcharImgType;
   typedef itk::Image<float, 3> ItkFloatImgType;
 
   mitk::TrackingHandlerOdf::ItkOdfImageType::Pointer itk_odf_image;
   mitk::TrackingHandlerTensor::ItkTensorImageType::ConstPointer itk_tensor_image;
   mitk::TrackingHandlerPeaks::PeakImgType::Pointer itk_peak_image;
-  ItkUcharImgType::Pointer itk_seed_image;
-  ItkUcharImgType::Pointer itk_mask_image;
+  ItkFloatImgType::Pointer itk_seed_image;
+  ItkFloatImgType::Pointer itk_mask_image;
   ItkFloatImgType::Pointer itk_gfa_image;
 
   float gfa_threshold;
   float odf_threshold;
   float peak_threshold;
 
   itk::StreamlineTrackingFilter::Pointer tracker;
 
   void setUp() override
   {
     omp_set_num_threads(1);
 
     gfa_threshold = 0.2;
     odf_threshold = 0.1;
     peak_threshold = 0.1;
 
     mitk::Image::Pointer odf_image = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/qball_image.qbi"));
     mitk::Image::Pointer tensor_image = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/tensor_image.dti"));
     mitk::Image::Pointer peak_image = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/qball_peak_image.nii.gz"));
     mitk::Image::Pointer seed_image = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/seed_image.nii.gz"));
     mitk::Image::Pointer mask_image = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/mask_image.nii.gz"));
     mitk::Image::Pointer gfa_image = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/gfa_image.nii.gz"));
 
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(peak_image);
       caster->Update();
       itk_peak_image = caster->GetOutput();
     }
 
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerTensor::ItkTensorImageType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(tensor_image);
       caster->Update();
       itk_tensor_image = caster->GetOutput();
     }
 
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerOdf::ItkOdfImageType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(odf_image);
       caster->Update();
       itk_odf_image = caster->GetOutput();
     }
 
     itk_gfa_image = ItkFloatImgType::New();
     mitk::CastToItkImage(gfa_image, itk_gfa_image);
 
-    itk_seed_image = ItkUcharImgType::New();
+    itk_seed_image = ItkFloatImgType::New();
     mitk::CastToItkImage(seed_image, itk_seed_image);
 
-    itk_mask_image = ItkUcharImgType::New();
+    itk_mask_image = ItkFloatImgType::New();
     mitk::CastToItkImage(mask_image, itk_mask_image);
   }
 
   mitk::FiberBundle::Pointer LoadReferenceFib(std::string filename)
   {
     mitk::FiberBundle::Pointer fib = nullptr;
 
     if (itksys::SystemTools::FileExists(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename)))
     {
       mitk::BaseData::Pointer baseData = mitk::IOUtil::Load(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename)).at(0);
       fib = dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
     }
     return fib;
   }
 
   mitk::Image::Pointer LoadReferenceImage(std::string filename)
   {
     mitk::Image::Pointer img = nullptr;
 
     if (itksys::SystemTools::FileExists(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename)))
     {
       img = mitk::IOUtil::LoadImage(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename));
     }
     return img;
   }
 
   void SetupTracker(mitk::TrackingDataHandler* handler)
   {
     tracker = itk::StreamlineTrackingFilter::New();
     tracker->SetRandom(false);
+    tracker->SetInterpolateMask(false);
     tracker->SetNumberOfSamples(0);
     tracker->SetAngularThreshold(-1);
     tracker->SetMaskImage(itk_mask_image);
     tracker->SetSeedImage(itk_seed_image);
     tracker->SetStoppingRegions(nullptr);
     tracker->SetSeedsPerVoxel(1);
     tracker->SetStepSize(0.5);
     tracker->SetSamplingDistance(0.25);
     tracker->SetUseStopVotes(true);
     tracker->SetOnlyForwardSamples(true);
     tracker->SetAposterioriCurvCheck(false);
-    tracker->SetTissueImage(nullptr);
-    tracker->SetSeedOnlyGm(false);
-    tracker->SetControlGmEndings(false);
     tracker->SetMinTractLength(20);
     tracker->SetMaxNumTracts(-1);
     tracker->SetTrackingHandler(handler);
     tracker->SetUseOutputProbabilityMap(false);
   }
 
   void tearDown() override
   {
 
   }
 
   void CheckFibResult(std::string ref_file, mitk::FiberBundle::Pointer test_fib)
   {
     mitk::FiberBundle::Pointer ref = LoadReferenceFib(ref_file);
     if (ref.IsNull())
     {
       mitk::IOUtil::Save(test_fib, mitk::IOUtil::GetTempPath()+ref_file);
       CPPUNIT_FAIL("Reference file not found. Saving test file to " + mitk::IOUtil::GetTempPath() + ref_file);
     }
     else
     {
       bool is_equal = ref->Equals(test_fib);
       if (!is_equal)
       {
         mitk::IOUtil::Save(test_fib, mitk::IOUtil::GetTempPath()+ref_file);
         CPPUNIT_FAIL("Tractograms are not equal! Saving test file to " + mitk::IOUtil::GetTempPath() + ref_file);
       }
     }
   }
 
   void CheckImageResult(std::string ref_file, mitk::Image::Pointer test_img)
   {
     mitk::Image::Pointer ref = LoadReferenceImage(ref_file);
     if (ref.IsNull())
     {
       mitk::IOUtil::Save(test_img, mitk::IOUtil::GetTempPath()+ref_file);
       CPPUNIT_FAIL("Reference file not found. Saving test file to " + mitk::IOUtil::GetTempPath() + ref_file);
     }
     else
     {
       MITK_ASSERT_EQUAL(test_img, ref, "Images should be equal");
     }
   }
 
   void Test_Peak1()
   {
     mitk::TrackingHandlerPeaks* handler = new mitk::TrackingHandlerPeaks();
     handler->SetPeakImage(itk_peak_image);
     handler->SetPeakThreshold(peak_threshold);
 
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Peak1.fib", outFib);
 
     delete handler;
   }
 
   void Test_Peak2()
   {
     mitk::TrackingHandlerPeaks* handler = new mitk::TrackingHandlerPeaks();
     handler->SetPeakImage(itk_peak_image);
     handler->SetPeakThreshold(peak_threshold);
     handler->SetInterpolate(false);
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Peak2.fib", outFib);
 
     delete handler;
   }
 
   void Test_Tensor1()
   {
     mitk::TrackingHandlerTensor* handler = new mitk::TrackingHandlerTensor();
     handler->SetTensorImage(itk_tensor_image);
     handler->SetFaThreshold(gfa_threshold);
 
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Tensor1.fib", outFib);
 
     delete handler;
   }
 
   void Test_Tensor2()
   {
     mitk::TrackingHandlerTensor* handler = new mitk::TrackingHandlerTensor();
     handler->SetTensorImage(itk_tensor_image);
     handler->SetFaThreshold(gfa_threshold);
     handler->SetInterpolate(false);
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Tensor2.fib", outFib);
 
     delete handler;
   }
 
   void Test_Tensor3()
   {
     mitk::TrackingHandlerTensor* handler = new mitk::TrackingHandlerTensor();
     handler->SetTensorImage(itk_tensor_image);
     handler->SetFaThreshold(gfa_threshold);
     handler->SetInterpolate(false);
     handler->SetF(0);
     handler->SetG(1);
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Tensor3.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf1()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
     handler->SetGfaThreshold(gfa_threshold);
     handler->SetOdfThreshold(0);
     handler->SetSharpenOdfs(true);
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf1.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf2()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
     handler->SetGfaThreshold(gfa_threshold);
     handler->SetOdfThreshold(0);
     handler->SetSharpenOdfs(false);
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf2.fib", outFib);
 
     delete handler;
   }
 
 
   void Test_Odf3()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
     handler->SetGfaThreshold(gfa_threshold);
     handler->SetOdfThreshold(0);
     handler->SetSharpenOdfs(true);
     handler->SetInterpolate(false);
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf3.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf4()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
     handler->SetGfaThreshold(gfa_threshold);
     handler->SetOdfThreshold(0);
     handler->SetSharpenOdfs(true);
 
     SetupTracker(handler);
     tracker->SetSeedsPerVoxel(3);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf4.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf5()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
     handler->SetGfaThreshold(gfa_threshold);
     handler->SetOdfThreshold(0);
     handler->SetSharpenOdfs(true);
     handler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
 
     SetupTracker(handler);
     tracker->SetSeedsPerVoxel(3);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf5.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf6()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
     handler->SetGfaThreshold(gfa_threshold);
     handler->SetOdfThreshold(0);
     handler->SetSharpenOdfs(true);
     handler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
 
     SetupTracker(handler);
     tracker->SetSeedsPerVoxel(10);
     tracker->SetUseOutputProbabilityMap(true);
     tracker->Update();
 
     itk::StreamlineTrackingFilter::ItkDoubleImgType::Pointer outImg = tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
+    mitk::IOUtil::Save(img, mitk::IOUtil::GetTempPath()+"Test_Odf6.nrrd");
     CheckImageResult("Test_Odf6.nrrd", img);
 
     delete handler;
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkStreamlineTractography)
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp
index 96da7b68df..124e9fb9b6 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp
@@ -1,164 +1,151 @@
 /*===================================================================
 
 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 <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkStandaloneDataStorage.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 /*!
 \brief Extract fibers from a tractogram using planar figure ROIs
 */
 int main(int argc, char* argv[])
 {
-    mitkCommandLineParser parser;
-
-    parser.setTitle("Fiber Extraction");
-    parser.setCategory("Fiber Tracking and Processing Methods");
-    parser.setContributor("MIC");
-    parser.setDescription("Extract fibers from a tractogram using planar figure ROIs");
-
-    parser.setArgumentPrefix("--", "-");
-    parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
-    parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
-    parser.addArgument("planfirgure1", "pf1", mitkCommandLineParser::String, "Figure 1:", "first ROI", us::Any(), false);
-    parser.addArgument("planfirgure2", "pf2", mitkCommandLineParser::String, "Figure 2:", "second ROI", us::Any());
-    parser.addArgument("operation", "op", mitkCommandLineParser::String, "Operation:", "logical operation (AND, OR, NOT)", us::Any());
-
-
-    std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
-    if (parsedArgs.size()==0)
-        return EXIT_FAILURE;
-
-    std::string inFib = us::any_cast<std::string>(parsedArgs["input"]);
-    std::string outFib = us::any_cast<std::string>(parsedArgs["out"]);
-    std::string pf1_path = us::any_cast<std::string>(parsedArgs["planfirgure1"]);
-
-    std::string operation("");
-    std::string pf2_path("");
-    if (parsedArgs.count("operation"))
+  mitkCommandLineParser parser;
+
+  parser.setTitle("Fiber Extraction");
+  parser.setCategory("Fiber Tracking and Processing Methods");
+  parser.setContributor("MIC");
+  parser.setDescription("Extract fibers from a tractogram using planar figure ROIs");
+
+  parser.setArgumentPrefix("--", "-");
+  parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
+  parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
+  parser.addArgument("planfirgure1", "pf1", mitkCommandLineParser::String, "Figure 1:", "first planar figure ROI", us::Any(), false);
+  parser.addArgument("planfirgure2", "pf2", mitkCommandLineParser::String, "Figure 2:", "second planar figure ROI", us::Any());
+  parser.addArgument("operation", "op", mitkCommandLineParser::String, "Operation:", "logical operation (AND, OR, NOT)", us::Any());
+
+
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  if (parsedArgs.size()==0)
+    return EXIT_FAILURE;
+
+  std::string inFib = us::any_cast<std::string>(parsedArgs["input"]);
+  std::string outFib = us::any_cast<std::string>(parsedArgs["out"]);
+  std::string pf1_path = us::any_cast<std::string>(parsedArgs["planfirgure1"]);
+
+  std::string operation("");
+  std::string pf2_path("");
+  if (parsedArgs.count("operation"))
+  {
+    operation = us::any_cast<std::string>(parsedArgs["operation"]);
+    if (parsedArgs.count("planfirgure2") && (operation=="AND" || operation=="OR"))
+      pf2_path = us::any_cast<std::string>(parsedArgs["planfirgure2"]);
+  }
+
+  try
+  {
+    // load fiber bundle
+    mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(inFib)[0].GetPointer());
+    mitk::FiberBundle::Pointer result;
+
+    mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
+    auto data = mitk::IOUtil::Load(pf1_path)[0];
+    auto input1 = mitk::DataNode::New();
+    input1->SetData(data);
+
+    if (input1.IsNotNull())
     {
-        operation = us::any_cast<std::string>(parsedArgs["operation"]);
-        if (parsedArgs.count("planfirgure2") && (operation=="AND" || operation=="OR"))
-            pf2_path = us::any_cast<std::string>(parsedArgs["planfirgure2"]);
+      mitk::PlanarFigureComposite::Pointer pfc = mitk::PlanarFigureComposite::New();
+      mitk::DataNode::Pointer pfcNode = mitk::DataNode::New();
+      pfcNode->SetData(pfc);
+      mitk::DataStorage::SetOfObjects::Pointer set1 = mitk::DataStorage::SetOfObjects::New();
+      set1->push_back(pfcNode);
+      storage->Add(pfcNode);
+
+      auto input2 = mitk::DataNode::New();
+      if (!pf2_path.empty())
+      {
+        data = mitk::IOUtil::Load(pf2_path)[0];
+        input2->SetData(data);
+      }
+
+      if (operation.empty())
+      {
+        result = inputTractogram->ExtractFiberSubset(input1, nullptr);
+      }
+      else if (operation=="NOT")
+      {
+        pfc->setOperationType(mitk::PlanarFigureComposite::NOT);
+        storage->Add(input1, set1);
+        result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
+      }
+      else if (operation=="AND" && input2.IsNotNull())
+      {
+        pfc->setOperationType(mitk::PlanarFigureComposite::AND);
+        storage->Add(input1, set1);
+        storage->Add(input2, set1);
+        result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
+      }
+      else if (operation=="OR" && input2.IsNotNull())
+      {
+        pfc->setOperationType(mitk::PlanarFigureComposite::OR);
+        storage->Add(input1, set1);
+        storage->Add(input2, set1);
+        result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
+      }
+      else
+      {
+        std::cout << "Could not process input:";
+        std::cout << pf1_path;
+        std::cout << pf2_path;
+        std::cout << operation;
+      }
     }
 
-    try
-    {
-        typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
-
-        // load fiber bundle
-        mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(inFib)[0].GetPointer());
-        mitk::FiberBundle::Pointer result;
-
-        mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
-        auto data = mitk::IOUtil::Load(pf1_path)[0];
-        auto input1 = mitk::DataNode::New();
-        input1->SetData(data);
-
-        if (input1.IsNotNull())
-        {
-            mitk::PlanarFigureComposite::Pointer pfc = mitk::PlanarFigureComposite::New();
-            mitk::DataNode::Pointer pfcNode = mitk::DataNode::New();
-            pfcNode->SetData(pfc);
-            mitk::DataStorage::SetOfObjects::Pointer set1 = mitk::DataStorage::SetOfObjects::New();
-            set1->push_back(pfcNode);
-            storage->Add(pfcNode);
-
-            auto input2 = mitk::DataNode::New();
-            if (!pf2_path.empty())
-            {
-                data = mitk::IOUtil::Load(pf2_path)[0];
-                input2->SetData(data);
-            }
-
-            if (operation.empty())
-            {
-                result = inputTractogram->ExtractFiberSubset(input1, nullptr);
-            }
-            else if (operation=="NOT")
-            {
-                pfc->setOperationType(mitk::PlanarFigureComposite::NOT);
-                storage->Add(input1, set1);
-                result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
-            }
-            else if (operation=="AND" && input2.IsNotNull())
-            {
-                pfc->setOperationType(mitk::PlanarFigureComposite::AND);
-                storage->Add(input1, set1);
-                storage->Add(input2, set1);
-                result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
-            }
-            else if (operation=="OR" && input2.IsNotNull())
-            {
-                pfc->setOperationType(mitk::PlanarFigureComposite::OR);
-                storage->Add(input1, set1);
-                storage->Add(input2, set1);
-                result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
-            }
-            else
-            {
-                std::cout << "Could not process input:";
-                std::cout << pf1_path;
-                std::cout << pf2_path;
-                std::cout << operation;
-            }
-        }
-        else
-        {
-            ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
-            mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(pf1_path)[0].GetPointer());
-            mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
-
-            if (operation=="NOT")
-                result = inputTractogram->ExtractFiberSubset(itkMaskImage, true, true);
-            else
-                result = inputTractogram->ExtractFiberSubset(itkMaskImage, true, false);
-        }
-
-        if (result.IsNotNull())
-            mitk::IOUtil::Save(result, outFib);
-        else
-            std::cout << "No valid fiber bundle extracted.";
-    }
-    catch (itk::ExceptionObject e)
-    {
-        std::cout << e;
-        return EXIT_FAILURE;
-    }
-    catch (std::exception e)
-    {
-        std::cout << e.what();
-        return EXIT_FAILURE;
-    }
-    catch (...)
-    {
-        std::cout << "ERROR!?!";
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
+    if (result.IsNotNull())
+      mitk::IOUtil::Save(result, outFib);
+    else
+      std::cout << "No valid fiber bundle extracted.";
+  }
+  catch (itk::ExceptionObject e)
+  {
+    std::cout << e;
+    return EXIT_FAILURE;
+  }
+  catch (std::exception e)
+  {
+    std::cout << e.what();
+    return EXIT_FAILURE;
+  }
+  catch (...)
+  {
+    std::cout << "ERROR!?!";
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
index cff0bed217..75fbad7cec 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
@@ -1,126 +1,166 @@
 /*===================================================================
 
 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 <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkStandaloneDataStorage.h>
 #include <itksys/SystemTools.hxx>
+#include <itkFiberExtractionFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 typedef itksys::SystemTools ist;
-typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
+typedef itk::Image<float, 3>    ItkFloatImgType;
 
-ItkUcharImgType::Pointer LoadItkMaskImage(const std::string& filename)
+ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
-  ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
-  mitk::CastToItkImage(img, itkMask);
-  return itkMask;
+  ItkFloatImgType::Pointer itk_image = ItkFloatImgType::New();
+  mitk::CastToItkImage(img, itk_image);
+  return itk_image;
 }
 
 /*!
 \brief Extract fibers from a tractogram using binary image ROIs
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Extraction With ROI Image");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
   parser.setDescription("Extract fibers from a tractogram using binary image ROIs");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk/.tck/.dcm)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
   parser.addArgument("rois", "", mitkCommandLineParser::StringList, "ROI images:", "Images with binary ROIs", us::Any(), false);
 
-  parser.addArgument("both_ends", "", mitkCommandLineParser::Bool, "Both ends:", "Fibers are extracted if both endpoints are located in the ROI.", false, false);
-  parser.addArgument("overlap_fraction", "", mitkCommandLineParser::Float, "Overlap fraction:", "Extract by overlap, not by endpoints. Extract fibers that overlap to at least the provided factor (0-1) with the ROI.", -1, false);
-  parser.addArgument("invert", "", mitkCommandLineParser::Bool, "Invert:", "invert mask image", false, false);
+  parser.addArgument("both_ends", "", mitkCommandLineParser::Bool, "Both ends:", "Fibers are extracted if both endpoints are located in the ROI.", false);
+  parser.addArgument("overlap_fraction", "", mitkCommandLineParser::Float, "Overlap fraction:", "Extract by overlap, not by endpoints. Extract fibers that overlap to at least the provided factor (0-1) with the ROI.", -1);
+  parser.addArgument("invert", "", mitkCommandLineParser::Bool, "Invert:", "get streamlines not positive for any of the ROI images", false);
+  parser.addArgument("interpolate", "", mitkCommandLineParser::Bool, "Interpolate:", "interpolate ROI images", false);
+  parser.addArgument("threshold", "", mitkCommandLineParser::Float, "Threshold:", "positive means ROI image value threshold", false, 0.5);
+  parser.addArgument("labels", "", mitkCommandLineParser::StringList, "Labels:", "positive means roi image value in labels vector", false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inFib = us::any_cast<std::string>(parsedArgs["input"]);
   std::string outFib = us::any_cast<std::string>(parsedArgs["out"]);
   mitkCommandLineParser::StringContainerType roi_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["rois"]);
 
   bool both_ends = false;
   if (parsedArgs.count("both_ends"))
     both_ends = us::any_cast<bool>(parsedArgs["both_ends"]);
 
   bool invert = false;
   if (parsedArgs.count("invert"))
     invert = us::any_cast<bool>(parsedArgs["invert"]);
 
   float overlap_fraction = -1;
   if (parsedArgs.count("overlap_fraction"))
     overlap_fraction = us::any_cast<float>(parsedArgs["overlap_fraction"]);
 
   bool any_point = false;
   if (overlap_fraction>=0)
     any_point = true;
 
+  bool interpolate = false;
+  if (parsedArgs.count("interpolate"))
+    interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
+
+  float threshold = 0.5;
+  if (parsedArgs.count("threshold"))
+    threshold = us::any_cast<float>(parsedArgs["threshold"]);
+
+  mitkCommandLineParser::StringContainerType labels;
+  if (parsedArgs.count("labels"))
+    labels = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
+
   try
   {
     // load fiber bundle
     mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(inFib)[0].GetPointer());
 
+    std::vector< ItkFloatImgType::Pointer > roi_images;
     for (std::size_t i=0; i<roi_files.size(); ++i)
+      roi_images.push_back( LoadItkImage(roi_files.at(i)) );
+
+    std::vector< ItkFloatImgType* > roi_images2;
+    for (auto roi : roi_images)
+      roi_images2.push_back(roi);
+
+    std::vector< unsigned short > short_labels;
+    for (auto l : labels)
+      short_labels.push_back(boost::lexical_cast<unsigned short>(l));
+
+    itk::FiberExtractionFilter<float>::Pointer extractor = itk::FiberExtractionFilter<float>::New();
+    extractor->SetInputFiberBundle(inputTractogram);
+    extractor->SetRoiImages(roi_images2);
+    extractor->SetOverlapFraction(overlap_fraction);
+    extractor->SetBothEnds(both_ends);
+    extractor->SetInterpolate(interpolate);
+    extractor->SetThreshold(threshold);
+    extractor->SetLabels(short_labels);
+    if (invert)
+      extractor->SetNoPositives(true);
+    else
+      extractor->SetNoNegatives(true);
+    if (!any_point)
+      extractor->SetMode(itk::FiberExtractionFilter<float>::MODE::ENDPOINTS);
+    if (short_labels.size()>0)
+      extractor->SetInputType(itk::FiberExtractionFilter<float>::INPUT::LABEL_MAP);
+    extractor->Update();
+
+    mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(nullptr);
+    if (invert)
+      mitk::IOUtil::Save(extractor->GetNegatives().at(0), outFib);
+    else
     {
-      try
-      {
-        ItkUcharImgType::Pointer mask = LoadItkMaskImage(roi_files.at(i));
-        mitk::FiberBundle::Pointer result = inputTractogram->ExtractFiberSubset(mask, any_point, invert, both_ends, overlap_fraction);
-        mitk::IOUtil::Save(result, outFib);
-      }
-      catch(...)
-      {
-        std::cout << "could not load: " << roi_files.at(i);
-        return EXIT_FAILURE;
-      }
+      newFib = newFib->AddBundles(extractor->GetPositives());
+      mitk::IOUtil::Save(newFib, outFib);
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FitFibersToImage.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FitFibersToImage.cpp
index fc207cccba..6c466e346f 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FitFibersToImage.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FitFibersToImage.cpp
@@ -1,216 +1,261 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itkImageFileWriter.h>
 #include <mitkPeakImage.h>
 #include <itkFitFibersToImageFilter.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Point<float, 4> PointType4;
 typedef itk::Image< float, 4 >  PeakImgType;
 
 std::vector< std::string > get_file_list(const std::string& path)
 {
   std::vector< std::string > file_list;
   itk::Directory::Pointer dir = itk::Directory::New();
 
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       if (ext==".fib" || ext==".trk")
         file_list.push_back(path + '/' + filename);
     }
   }
   return file_list;
 }
 
 /*!
 \brief Fits the tractogram to the input peak image by assigning a weight to each fiber (similar to https://doi.org/10.1016/j.neuroimage.2015.06.092).
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fit Fibers To Image");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("Assigns a weight to each fiber in order to optimally explain the input peak image");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i1", mitkCommandLineParser::StringList, "Input tractograms:", "input tractograms (.fib, vtk ascii file format)", us::Any(), false);
   parser.addArgument("", "i2", mitkCommandLineParser::InputFile, "Input peaks:", "input peak image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
 
   parser.addArgument("max_iter", "", mitkCommandLineParser::Int, "Max. iterations:", "maximum number of optimizer iterations", 20);
   parser.addArgument("bundle_based", "", mitkCommandLineParser::Bool, "Bundle based fit:", "fit one weight per input tractogram/bundle, not for each fiber", false);
   parser.addArgument("min_g", "", mitkCommandLineParser::Float, "Min. g:", "lower termination threshold for gradient magnitude", 1e-5);
   parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "modifier for regularization", 0.1);
   parser.addArgument("save_res", "", mitkCommandLineParser::Bool, "Save Residuals:", "save residual images", false);
   parser.addArgument("save_weights", "", mitkCommandLineParser::Bool, "Save Weights:", "save fiber weights in a separate text file", false);
   parser.addArgument("dont_filter_outliers", "", mitkCommandLineParser::Bool, "Don't filter outliers:", "don't perform second optimization run with an upper weight bound based on the first weight estimation (95% quantile)", false);
+  parser.addArgument("join_tracts", "", mitkCommandLineParser::Bool, "Join output tracts:", "outout tracts are merged into a single tractogram", false);
+  parser.addArgument("regu", "", mitkCommandLineParser::String, "Regularization:", "MSM, MSE, LocalMSE (default), NONE");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkCommandLineParser::StringContainerType fib_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["i1"]);
   std::string peak_file_name = us::any_cast<std::string>(parsedArgs["i2"]);
   std::string outRoot = us::any_cast<std::string>(parsedArgs["o"]);
 
   bool single_fib = true;
   if (parsedArgs.count("bundle_based"))
     single_fib = !us::any_cast<bool>(parsedArgs["bundle_based"]);
 
   bool save_residuals = false;
   if (parsedArgs.count("save_res"))
     save_residuals = us::any_cast<bool>(parsedArgs["save_res"]);
 
   bool save_weights = false;
   if (parsedArgs.count("save_weights"))
     save_weights = us::any_cast<bool>(parsedArgs["save_weights"]);
 
+  std::string regu = "LocalMSE";
+  if (parsedArgs.count("regu"))
+    regu = us::any_cast<std::string>(parsedArgs["regu"]);
+
+  bool join_tracts = false;
+  if (parsedArgs.count("join_tracts"))
+    join_tracts = us::any_cast<bool>(parsedArgs["join_tracts"]);
+
   int max_iter = 20;
   if (parsedArgs.count("max_iter"))
     max_iter = us::any_cast<int>(parsedArgs["max_iter"]);
 
   float g_tol = 1e-5;
   if (parsedArgs.count("min_g"))
     g_tol = us::any_cast<float>(parsedArgs["min_g"]);
 
   float lambda = 0.1;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   bool filter_outliers = true;
   if (parsedArgs.count("dont_filter_outliers"))
     filter_outliers = !us::any_cast<bool>(parsedArgs["dont_filter_outliers"]);
 
   try
   {
+    MITK_INFO << "Loading data";
+    std::streambuf *old = cout.rdbuf(); // <-- save
+    std::stringstream ss;
+    std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     std::vector< mitk::FiberBundle::Pointer > input_tracts;
 
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Peak Image", "Fiberbundles"}, {});
     mitk::Image::Pointer inputImage = dynamic_cast<mitk::PeakImage*>(mitk::IOUtil::Load(peak_file_name, &functor)[0].GetPointer());
 
     typedef mitk::ImageToItk< PeakImgType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(inputImage);
     caster->Update();
     PeakImgType::Pointer peak_image = caster->GetOutput();
 
     std::vector< std::string > fib_names;
     for (auto item : fib_files)
     {
       if ( ist::FileIsDirectory(item) )
       {
         for ( auto fibFile : get_file_list(item) )
         {
           mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(fibFile)[0].GetPointer());
           if (inputTractogram.IsNull())
             continue;
           input_tracts.push_back(inputTractogram);
           fib_names.push_back(fibFile);
         }
       }
       else
       {
         mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(item)[0].GetPointer());
         if (inputTractogram.IsNull())
           continue;
         input_tracts.push_back(inputTractogram);
         fib_names.push_back(item);
       }
     }
+    std::cout.rdbuf (old);              // <-- restore
 
     itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
     fitter->SetPeakImage(peak_image);
     fitter->SetTractograms(input_tracts);
     fitter->SetFitIndividualFibers(single_fib);
     fitter->SetMaxIterations(max_iter);
     fitter->SetGradientTolerance(g_tol);
     fitter->SetLambda(lambda);
     fitter->SetFilterOutliers(filter_outliers);
+
+    if (regu=="MSM")
+      fitter->SetRegularization(VnlCostFunction::REGU::MSM);
+    else if (regu=="MSE")
+      fitter->SetRegularization(VnlCostFunction::REGU::MSE);
+    else if (regu=="Local_MSE")
+      fitter->SetRegularization(VnlCostFunction::REGU::Local_MSE);
+    else if (regu=="NONE")
+      fitter->SetRegularization(VnlCostFunction::REGU::NONE);
+
     fitter->Update();
 
     if (save_residuals)
     {
       itk::ImageFileWriter< PeakImgType >::Pointer writer = itk::ImageFileWriter< PeakImgType >::New();
       writer->SetInput(fitter->GetFittedImage());
       writer->SetFileName(outRoot + "fitted_image.nrrd");
       writer->Update();
 
       writer->SetInput(fitter->GetResidualImage());
       writer->SetFileName(outRoot + "residual_image.nrrd");
       writer->Update();
 
       writer->SetInput(fitter->GetOverexplainedImage());
       writer->SetFileName(outRoot + "overexplained_image.nrrd");
       writer->Update();
 
       writer->SetInput(fitter->GetUnderexplainedImage());
       writer->SetFileName(outRoot + "underexplained_image.nrrd");
       writer->Update();
     }
 
     std::vector< mitk::FiberBundle::Pointer > output_tracts = fitter->GetTractograms();
-    for (unsigned int bundle=0; bundle<output_tracts.size(); bundle++)
+
+    if (!join_tracts)
+    {
+      for (unsigned int bundle=0; bundle<output_tracts.size(); bundle++)
+      {
+        std::string name = fib_names.at(bundle);
+        name = ist::GetFilenameWithoutExtension(name);
+        mitk::IOUtil::Save(output_tracts.at(bundle), outRoot + name + "_fitted.fib");
+
+        if (save_weights)
+        {
+          ofstream logfile;
+          logfile.open (outRoot + name + "_weights.txt");
+          for (int f=0; f<output_tracts.at(bundle)->GetNumFibers(); ++f)
+            logfile << output_tracts.at(bundle)->GetFiberWeight(f) << "\n";
+          logfile.close();
+        }
+      }
+    }
+    else
     {
-      std::string name = fib_names.at(bundle);
-      name = ist::GetFilenameWithoutExtension(name);
-      mitk::IOUtil::Save(output_tracts.at(bundle), outRoot + name + "_fitted.fib");
+      mitk::FiberBundle::Pointer out = mitk::FiberBundle::New();
+      out = out->AddBundles(output_tracts);
+      out->ColorFibersByFiberWeights(false, true);
+      mitk::IOUtil::Save(out, outRoot + "_fitted.fib");
 
       if (save_weights)
       {
         ofstream logfile;
-        logfile.open (outRoot + name + "_weights.txt");
-        for (int f=0; f<output_tracts.at(bundle)->GetNumFibers(); ++f)
-          logfile << output_tracts.at(bundle)->GetFiberWeight(f) << "\n";
+        logfile.open (outRoot + "_weights.txt");
+        for (int f=0; f<out->GetNumFibers(); ++f)
+          logfile << out->GetFiberWeight(f) << "\n";
         logfile.close();
       }
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp
index 4db8ad3a87..c6864cec9f 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp
@@ -1,135 +1,135 @@
 /*===================================================================
 
 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 <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itksys/SystemTools.hxx>
 #include <itkTractDensityImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 typedef itksys::SystemTools ist;
-typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
+typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 
 /*!
 \brief Extract fibers from a tractogram using binary image ROIs
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Move Overlapping Tracts");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
   parser.setDescription("Move tracts that overlap with one of the reference tracts");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input:", "input tractograms (.fib/.trk/.tck/.dcm)", us::Any(), false);
   parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference:", "reference tractograms (.fib/.trk/.tck/.dcm)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output Folder:", "move input tracts that do/don't overlap here", us::Any(), false);
 
   parser.addArgument("overlap_fraction", "", mitkCommandLineParser::Float, "Overlap fraction:", "", 0.9);
   parser.addArgument("move_overlapping", "", mitkCommandLineParser::Bool, ":", "");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkCommandLineParser::StringContainerType input = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
   mitkCommandLineParser::StringContainerType reference = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   bool move_overlapping = false;
   if (parsedArgs.count("move_overlapping"))
     move_overlapping = us::any_cast<bool>(parsedArgs["move_overlapping"]);
 
   float overlap_threshold = 0.9;
   if (parsedArgs.count("overlap_fraction"))
     overlap_threshold = us::any_cast<float>(parsedArgs["overlap_fraction"]);
 
   try
   {
-    itk::TractDensityImageFilter< ItkUcharImgType >::Pointer filter = itk::TractDensityImageFilter< ItkUcharImgType >::New();
+    itk::TractDensityImageFilter< ItkFloatImgType >::Pointer filter = itk::TractDensityImageFilter< ItkFloatImgType >::New();
     filter->SetDoFiberResampling(true);
     filter->SetUpsamplingFactor(0.25);
     filter->SetBinaryOutput(true);
-    std::vector< ItkUcharImgType::Pointer > masks;
+    std::vector< ItkFloatImgType::Pointer > masks;
     for (auto f : reference)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(f)[0].GetPointer());
       filter->SetFiberBundle(fib);
 
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       filter->Update();
       masks.push_back(filter->GetOutput());
       std::cout.rdbuf (old);              // <-- restore
     }
 
     boost::progress_display disp(input.size());
     for (auto f : input)
     {
       ++disp;
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       bool is_overlapping = false;
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(f)[0].GetPointer());
       fib->ResampleLinear(2);
       for (auto m : masks)
       {
         float overlap = fib->GetOverlap(m, false);
 
         if (overlap>=overlap_threshold)
         {
           is_overlapping = true;
           break;
         }
       }
       if (move_overlapping && is_overlapping)
         ist::CopyAFile(f, out_folder + ist::GetFilenameName(f));
       else if (!move_overlapping && !is_overlapping)
         ist::CopyAFile(f, out_folder + ist::GetFilenameName(f));
       std::cout.rdbuf (old);              // <-- restore
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/StreamlineTractography.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/StreamlineTractography.cpp
index baa8cdfa0d..ce317deddf 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/StreamlineTractography.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/StreamlineTractography.cpp
@@ -1,485 +1,456 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <mitkLog.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 #include <omp.h>
 #include <itksys/SystemTools.hxx>
 
 #include <mitkFiberBundle.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingDataHandler.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <itkTensorImageToOdfImageFilter.h>
 #include <mitkTractographyForest.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const int numOdfSamples = 200;
 typedef itk::Image< itk::Vector< float, numOdfSamples > , 3 > SampledShImageType;
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Streamline Tractography");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("Perform streamline tractography");
   parser.setContributor("MIC");
 
   // parameters fo all methods
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input:", "input image (multiple possible for 'DetTensor' algorithm)", us::Any(), false);
   parser.addArgument("algorithm", "a", mitkCommandLineParser::String, "Algorithm:", "which algorithm to use (Peaks, DetTensor, ProbTensor, DetODF, ProbODF, DetRF, ProbRF)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output fiberbundle/probability map", us::Any(), false);
 
   parser.addArgument("stop_mask", "", mitkCommandLineParser::String, "Stop image:", "streamlines entering the binary mask will stop immediately", us::Any());
   parser.addArgument("target_image", "", mitkCommandLineParser::String, "Target image:", "streamlines not starting and ending in one of the regions in this image are discarded", us::Any());
   parser.addArgument("tracking_mask", "", mitkCommandLineParser::String, "Mask image:", "restrict tractography with a binary mask image", us::Any());
   parser.addArgument("seed_mask", "", mitkCommandLineParser::String, "Seed image:", "binary mask image defining seed voxels", us::Any());
-  parser.addArgument("tissue_image", "", mitkCommandLineParser::String, "Tissue type image:", "image with tissue type labels (WM=3, GM=1)", us::Any());
 
   parser.addArgument("sharpen_odfs", "", mitkCommandLineParser::Bool, "SHarpen ODFs:", "if you are using dODF images as input, it is advisable to sharpen the ODFs (min-max normalize and raise to the power of 4). this is not necessary for CSD fODFs, since they are narurally much sharper.");
   parser.addArgument("cutoff", "", mitkCommandLineParser::Float, "Cutoff:", "set the FA, GFA or Peak amplitude cutoff for terminating tracks", 0.1);
   parser.addArgument("odf_cutoff", "", mitkCommandLineParser::Float, "ODF Cutoff:", "additional threshold on the ODF magnitude. this is useful in case of CSD fODF tractography.", 0.1);
   parser.addArgument("step_size", "", mitkCommandLineParser::Float, "Step size:", "step size (in voxels)", 0.5);
   parser.addArgument("angular_threshold", "", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold between two successive steps, (default: 90° * step_size)");
   parser.addArgument("min_tract_length", "", mitkCommandLineParser::Float, "Min. tract length:", "minimum fiber length (in mm)", 20);
   parser.addArgument("seeds", "", mitkCommandLineParser::Int, "Seeds per voxel:", "number of seed points per voxel", 1);
-  parser.addArgument("seed_gm", "", mitkCommandLineParser::Bool, "Seed only GM:", "Seed only in gray matter (requires tissue type image --tissue_image)");
-  parser.addArgument("control_gm_endings", "", mitkCommandLineParser::Bool, "Control GM endings:", "Seed perpendicular to gray matter and enforce endings inside of the gray matter (requires tissue type image --tissue_image)");
   parser.addArgument("max_tracts", "", mitkCommandLineParser::Int, "Max. number of tracts:", "tractography is stopped if the reconstructed number of tracts is exceeded.", -1);
 
   parser.addArgument("num_samples", "", mitkCommandLineParser::Int, "Num. neighborhood samples:", "number of neighborhood samples that are use to determine the next progression direction", 0);
   parser.addArgument("sampling_distance", "", mitkCommandLineParser::Float, "Sampling distance:", "distance of neighborhood sampling points (in voxels)", 0.25);
   parser.addArgument("use_stop_votes", "", mitkCommandLineParser::Bool, "Use stop votes:", "use stop votes");
   parser.addArgument("use_only_forward_samples", "", mitkCommandLineParser::Bool, "Use only forward samples:", "use only forward samples");
   parser.addArgument("output_prob_map", "", mitkCommandLineParser::Bool, "Output probability map:", "output probability map instead of tractogram");
 
   parser.addArgument("no_interpolation", "", mitkCommandLineParser::Bool, "Don't interpolate:", "don't interpolate image values");
   parser.addArgument("flip_x", "", mitkCommandLineParser::Bool, "Flip X:", "multiply x-coordinate of direction proposal by -1");
   parser.addArgument("flip_y", "", mitkCommandLineParser::Bool, "Flip Y:", "multiply y-coordinate of direction proposal by -1");
   parser.addArgument("flip_z", "", mitkCommandLineParser::Bool, "Flip Z:", "multiply z-coordinate of direction proposal by -1");
   //parser.addArgument("apply_image_rotation", "", mitkCommandLineParser::Bool, "Apply image rotation:", "applies image rotation to image peaks (only for 'Peaks' algorithm). This is necessary in some cases, e.g. if the peaks were obtained with MRtrix.");
 
   parser.addArgument("compress", "", mitkCommandLineParser::Float, "Compress:", "Compress output fibers using the given error threshold (in mm)");
   parser.addArgument("additional_images", "", mitkCommandLineParser::StringList, "Additional images:", "specify a list of float images that hold additional information (FA, GFA, additional Features)", us::Any());
 
   // parameters for random forest based tractography
   parser.addArgument("forest", "", mitkCommandLineParser::String, "Forest:", "input random forest (HDF5 file)", us::Any());
   parser.addArgument("use_sh_features", "", mitkCommandLineParser::Bool, "Use SH features:", "use SH features");
 
   // parameters for tensor tractography
   parser.addArgument("tend_f", "", mitkCommandLineParser::Float, "Weight f", "Weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0);
   parser.addArgument("tend_g", "", mitkCommandLineParser::Float, "Weight g", "Weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0);
 
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkCommandLineParser::StringContainerType input_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
   std::string outFile = us::any_cast<std::string>(parsedArgs["out"]);
   std::string algorithm = us::any_cast<std::string>(parsedArgs["algorithm"]);
 
   bool sharpen_odfs = false;
   if (parsedArgs.count("sharpen_odfs"))
     sharpen_odfs = us::any_cast<bool>(parsedArgs["sharpen_odfs"]);
 
   bool interpolate = true;
   if (parsedArgs.count("no_interpolation"))
     interpolate = !us::any_cast<bool>(parsedArgs["no_interpolation"]);
 
   bool use_sh_features = false;
   if (parsedArgs.count("use_sh_features"))
     use_sh_features = us::any_cast<bool>(parsedArgs["use_sh_features"]);
 
-  bool seed_gm = false;
-  if (parsedArgs.count("seed_gm"))
-    seed_gm = us::any_cast<bool>(parsedArgs["seed_gm"]);
-
-  bool control_gm_endings = false;
-  if (parsedArgs.count("control_gm_endings"))
-    control_gm_endings = us::any_cast<bool>(parsedArgs["control_gm_endings"]);
-
   bool use_stop_votes = false;
   if (parsedArgs.count("use_stop_votes"))
     use_stop_votes = us::any_cast<bool>(parsedArgs["use_stop_votes"]);
 
   bool use_only_forward_samples = false;
   if (parsedArgs.count("use_only_forward_samples"))
     use_only_forward_samples = us::any_cast<bool>(parsedArgs["use_only_forward_samples"]);
 
   bool output_prob_map = false;
   if (parsedArgs.count("output_prob_map"))
     output_prob_map = us::any_cast<bool>(parsedArgs["output_prob_map"]);
 
   bool flip_x = false;
   if (parsedArgs.count("flip_x"))
     flip_x = us::any_cast<bool>(parsedArgs["flip_x"]);
   bool flip_y = false;
   if (parsedArgs.count("flip_y"))
     flip_y = us::any_cast<bool>(parsedArgs["flip_y"]);
   bool flip_z = false;
   if (parsedArgs.count("flip_z"))
     flip_z = us::any_cast<bool>(parsedArgs["flip_z"]);
 
   bool apply_image_rotation = false;
   if (parsedArgs.count("apply_image_rotation"))
     apply_image_rotation = us::any_cast<bool>(parsedArgs["apply_image_rotation"]);
 
   float compress = -1;
   if (parsedArgs.count("compress"))
     compress = us::any_cast<float>(parsedArgs["compress"]);
 
   float min_tract_length = 20;
   if (parsedArgs.count("min_tract_length"))
     min_tract_length = us::any_cast<float>(parsedArgs["min_tract_length"]);
 
   std::string forestFile;
   if (parsedArgs.count("forest"))
     forestFile = us::any_cast<std::string>(parsedArgs["forest"]);
 
   std::string maskFile = "";
   if (parsedArgs.count("tracking_mask"))
     maskFile = us::any_cast<std::string>(parsedArgs["tracking_mask"]);
 
   std::string seedFile = "";
   if (parsedArgs.count("seed_mask"))
     seedFile = us::any_cast<std::string>(parsedArgs["seed_mask"]);
 
   std::string targetFile = "";
   if (parsedArgs.count("target_image"))
     targetFile = us::any_cast<std::string>(parsedArgs["target_image"]);
 
   std::string stopFile = "";
   if (parsedArgs.count("stop_mask"))
     stopFile = us::any_cast<std::string>(parsedArgs["stop_mask"]);
 
-  std::string tissueFile = "";
-  if (parsedArgs.count("tissue_image"))
-    tissueFile = us::any_cast<std::string>(parsedArgs["tissue_image"]);
-
   float cutoff = 0.1;
   if (parsedArgs.count("cutoff"))
     cutoff = us::any_cast<float>(parsedArgs["cutoff"]);
 
   float odf_cutoff = 0.1;
   if (parsedArgs.count("odf_cutoff"))
     odf_cutoff = us::any_cast<float>(parsedArgs["odf_cutoff"]);
 
   float stepsize = -1;
   if (parsedArgs.count("step_size"))
     stepsize = us::any_cast<float>(parsedArgs["step_size"]);
 
   float sampling_distance = -1;
   if (parsedArgs.count("sampling_distance"))
     sampling_distance = us::any_cast<float>(parsedArgs["sampling_distance"]);
 
   int num_samples = 0;
   if (parsedArgs.count("num_samples"))
     num_samples = us::any_cast<int>(parsedArgs["num_samples"]);
 
   int seeds = 1;
   if (parsedArgs.count("seeds"))
     seeds = us::any_cast<int>(parsedArgs["seeds"]);
 
   float tend_f = 1;
   if (parsedArgs.count("tend_f"))
     tend_f = us::any_cast<float>(parsedArgs["tend_f"]);
 
   float tend_g = 0;
   if (parsedArgs.count("tend_g"))
     tend_g = us::any_cast<float>(parsedArgs["tend_g"]);
 
   float angular_threshold = -1;
   if (parsedArgs.count("angular_threshold"))
     angular_threshold = us::any_cast<float>(parsedArgs["angular_threshold"]);
 
   unsigned int max_tracts = -1;
   if (parsedArgs.count("max_tracts"))
     max_tracts = us::any_cast<int>(parsedArgs["max_tracts"]);
 
   // LOAD DATASETS
 
   mitkCommandLineParser::StringContainerType addFiles;
   if (parsedArgs.count("additional_images"))
     addFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["additional_images"]);
 
-  typedef itk::Image<unsigned char, 3> ItkUcharImgType;
-  typedef itk::Image<unsigned int, 3> ItkUintImgType;
+  typedef itk::Image<float, 3> ItkFloatImgType;
 
   MITK_INFO << "loading input";
   std::vector< mitk::Image::Pointer > input_images;
   for (unsigned int i=0; i<input_files.size(); i++)
   {
     mitk::Image::Pointer mitkImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(input_files.at(i))[0].GetPointer());
     input_images.push_back(mitkImage);
   }
 
-  ItkUcharImgType::Pointer mask;
+  ItkFloatImgType::Pointer mask;
   if (!maskFile.empty())
   {
     MITK_INFO << "loading mask image";
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(maskFile)[0].GetPointer());
-    mask = ItkUcharImgType::New();
+    mask = ItkFloatImgType::New();
     mitk::CastToItkImage(img, mask);
   }
 
-  ItkUcharImgType::Pointer seed;
+  ItkFloatImgType::Pointer seed;
   if (!seedFile.empty())
   {
     MITK_INFO << "loading seed image";
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(seedFile)[0].GetPointer());
-    seed = ItkUcharImgType::New();
+    seed = ItkFloatImgType::New();
     mitk::CastToItkImage(img, seed);
   }
 
-  ItkUcharImgType::Pointer stop;
+  ItkFloatImgType::Pointer stop;
   if (!stopFile.empty())
   {
     MITK_INFO << "loading stop image";
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(stopFile)[0].GetPointer());
-    stop = ItkUcharImgType::New();
+    stop = ItkFloatImgType::New();
     mitk::CastToItkImage(img, stop);
   }
 
-  ItkUintImgType::Pointer target;
+  ItkFloatImgType::Pointer target;
   if (!targetFile.empty())
   {
     MITK_INFO << "loading target image";
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(targetFile)[0].GetPointer());
-    target = ItkUintImgType::New();
+    target = ItkFloatImgType::New();
     mitk::CastToItkImage(img, target);
   }
 
-  ItkUcharImgType::Pointer tissue;
-  if (!tissueFile.empty())
-  {
-    MITK_INFO << "loading tissue image";
-    mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(tissueFile)[0].GetPointer());
-    tissue = ItkUcharImgType::New();
-    mitk::CastToItkImage(img, tissue);
-  }
-
   MITK_INFO << "loading additional images";
-  typedef itk::Image<float, 3> ItkFloatImgType;
   std::vector< std::vector< ItkFloatImgType::Pointer > > addImages;
   addImages.push_back(std::vector< ItkFloatImgType::Pointer >());
   for (auto file : addFiles)
   {
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(file)[0].GetPointer());
     ItkFloatImgType::Pointer itkimg = ItkFloatImgType::New();
     mitk::CastToItkImage(img, itkimg);
     addImages.at(0).push_back(itkimg);
   }
 
   //    //////////////////////////////////////////////////////////////////
 //      omp_set_num_threads(1);
 
   if (algorithm == "ProbTensor")
   {
     typedef mitk::ImageToItk< mitk::TrackingHandlerTensor::ItkTensorImageType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(input_images.at(0));
     caster->Update();
     mitk::TrackingHandlerTensor::ItkTensorImageType::Pointer itkTensorImg = caster->GetOutput();
 
     typedef itk::TensorImageToOdfImageFilter< float, float > FilterType;
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput( itkTensorImg );
     filter->Update();
 
     mitk::Image::Pointer image = mitk::Image::New();
     FilterType::OutputImageType::Pointer outimg = filter->GetOutput();
     image->InitializeByItk( outimg.GetPointer() );
     image->SetVolume( outimg->GetBufferPointer() );
 
     input_images.clear();
     input_images.push_back(image);
 
     sharpen_odfs = true;
     odf_cutoff = 0;
   }
 
   typedef itk::StreamlineTrackingFilter TrackerType;
   TrackerType::Pointer tracker = TrackerType::New();
 
   mitk::TrackingDataHandler* handler;
   if (algorithm == "DetRF" || algorithm == "ProbRF")
   {
     mitk::TractographyForest::Pointer forest = dynamic_cast<mitk::TractographyForest*>(mitk::IOUtil::Load(forestFile)[0].GetPointer());
     if (forest.IsNull())
       mitkThrow() << "Forest file " << forestFile << " could not be read.";
 
     if (use_sh_features)
     {
       handler = new mitk::TrackingHandlerRandomForest<6,28>();
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,28>*>(handler)->SetForest(forest);
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,28>*>(handler)->AddDwi(input_images.at(0));
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,28>*>(handler)->SetAdditionalFeatureImages(addImages);
     }
     else
     {
       handler = new mitk::TrackingHandlerRandomForest<6,100>();
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,100>*>(handler)->SetForest(forest);
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,100>*>(handler)->AddDwi(input_images.at(0));
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,100>*>(handler)->SetAdditionalFeatureImages(addImages);
     }
 
     if (algorithm == "ProbRF")
       handler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
   }
   else if (algorithm == "Peaks")
   {
     handler = new mitk::TrackingHandlerPeaks();
 
     typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(input_images.at(0));
     caster->Update();
     mitk::TrackingHandlerPeaks::PeakImgType::Pointer itkImg = caster->GetOutput();
 
     dynamic_cast<mitk::TrackingHandlerPeaks*>(handler)->SetPeakImage(itkImg);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(handler)->SetApplyDirectionMatrix(apply_image_rotation);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(handler)->SetPeakThreshold(cutoff);
   }
   else if (algorithm == "DetTensor")
   {
     handler = new mitk::TrackingHandlerTensor();
 
     for (auto input_image : input_images)
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerTensor::ItkTensorImageType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(input_image);
       caster->Update();
       mitk::TrackingHandlerTensor::ItkTensorImageType::ConstPointer itkImg = caster->GetOutput();
       dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->AddTensorImage(itkImg);
     }
 
     dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetFaThreshold(cutoff);
     dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetF(tend_f);
     dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetG(tend_g);
 
     if (addImages.at(0).size()>0)
       dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetFaImage(addImages.at(0).at(0));
   }
   else if (algorithm == "DetODF" || algorithm == "ProbODF" || algorithm == "ProbTensor")
   {
     handler = new mitk::TrackingHandlerOdf();
 
     typedef mitk::ImageToItk< mitk::TrackingHandlerOdf::ItkOdfImageType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(input_images.at(0));
     caster->Update();
     mitk::TrackingHandlerOdf::ItkOdfImageType::Pointer itkImg = caster->GetOutput();
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetOdfImage(itkImg);
 
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetGfaThreshold(cutoff);
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetOdfThreshold(odf_cutoff);
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetSharpenOdfs(sharpen_odfs);
 
     if (algorithm == "ProbODF" || algorithm == "ProbTensor")
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetMode(mitk::TrackingHandlerOdf::MODE::PROBABILISTIC);
     if (algorithm == "ProbTensor")
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetIsOdfFromTensor(true);
 
     if (addImages.at(0).size()>0)
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetGfaImage(addImages.at(0).at(0));
   }
   else
   {
     MITK_INFO << "Unknown tractography algorithm (" + algorithm+"). Known types are Peaks, DetTensor, ProbTensor, DetODF, ProbODF, DetRF, ProbRF.";
     return EXIT_FAILURE;
   }
   handler->SetInterpolate(interpolate);
   handler->SetFlipX(flip_x);
   handler->SetFlipY(flip_y);
   handler->SetFlipZ(flip_z);
 
   MITK_INFO << "Tractography algorithm: " << algorithm;
 
   tracker->SetNumberOfSamples(num_samples);
   tracker->SetAngularThreshold(angular_threshold);
   tracker->SetMaskImage(mask);
   tracker->SetSeedImage(seed);
   tracker->SetStoppingRegions(stop);
   tracker->SetTargetRegions(target);
   tracker->SetSeedsPerVoxel(seeds);
   tracker->SetStepSize(stepsize);
   tracker->SetSamplingDistance(sampling_distance);
   tracker->SetUseStopVotes(use_stop_votes);
   tracker->SetOnlyForwardSamples(use_only_forward_samples);
   tracker->SetAposterioriCurvCheck(false);
-  tracker->SetTissueImage(tissue);
-  tracker->SetSeedOnlyGm(seed_gm);
-  tracker->SetControlGmEndings(control_gm_endings);
   tracker->SetMaxNumTracts(max_tracts);
   tracker->SetTrackingHandler(handler);
   tracker->SetUseOutputProbabilityMap(output_prob_map);
   tracker->SetMinTractLength(min_tract_length);
   tracker->Update();
 
   std::string ext = itksys::SystemTools::GetFilenameExtension(outFile);
 
   if (!output_prob_map)
   {
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
     if (compress > 0)
       outFib->Compress(compress);
 
     if (ext != ".fib" && ext != ".trk" && ext != ".tck")
       outFile += ".fib";
 
     mitk::IOUtil::Save(outFib, outFile);
   }
   else
   {
     TrackerType::ItkDoubleImgType::Pointer outImg = tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     if (ext != ".nii" && ext != ".nii.gz" && ext != ".nrrd")
       outFile += ".nii.gz";
 
     mitk::IOUtil::Save(img, outFile);
   }
 
   delete handler;
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
index 3f9208ccc5..325afde7dd 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
@@ -1,443 +1,437 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itkImageFileWriter.h>
 #include <mitkPeakImage.h>
 #include <itkFitFibersToImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <itkTractDensityImageFilter.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Point<float, 4> PointType4;
 typedef itk::Image< float, 4 >  PeakImgType;
 typedef itk::Image< unsigned char, 3 >  ItkUcharImageType;
 
-std::vector< std::string > get_file_list(const std::string& path, std::vector< std::string > extensions={".fib", ".trk"})
-{
-  std::vector< std::string > file_list;
-  itk::Directory::Pointer dir = itk::Directory::New();
-
-  if (dir->Load(path.c_str()))
-  {
-    int n = dir->GetNumberOfFiles();
-    for (int r = 0; r < n; r++)
-    {
-      const char *filename = dir->GetFile(r);
-      std::string ext = ist::GetFilenameExtension(filename);
-      for (auto e : extensions)
-      {
-        if (ext==e)
-        {
-          file_list.push_back(path + '/' + filename);
-          break;
-        }
-      }
-    }
-  }
-  return file_list;
-}
-
 std::vector< mitk::FiberBundle::Pointer > CombineTractograms(std::vector< mitk::FiberBundle::Pointer > reference, std::vector< mitk::FiberBundle::Pointer > candidates, int skip=-1)
 {
   std::vector< mitk::FiberBundle::Pointer > fib;
   for (auto f : reference)
     fib.push_back(f);
 
   int c = 0;
   for (auto f : candidates)
   {
     if (c!=skip)
       fib.push_back(f);
     ++c;
   }
 
   return fib;
 }
 
 /*!
 \brief Fits the tractogram to the input peak image by assigning a weight to each fiber (similar to https://doi.org/10.1016/j.neuroimage.2015.06.092).
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Anchor Based Scoring");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
-  parser.addArgument("", "i1", mitkCommandLineParser::InputFile, "Anchor tractogram:", "anchor tracts in one tractogram file", us::Any(), false);
-  parser.addArgument("", "i2", mitkCommandLineParser::InputFile, "Input peaks:", "input peak image", us::Any(), false);
-  parser.addArgument("", "i3", mitkCommandLineParser::InputFile, "Candidate folder:", "folder containing all candidate tracts (separate files)", us::Any(), false);
+  parser.addArgument("", "a", mitkCommandLineParser::InputFile, "Anchor tractogram:", "anchor tracts in one tractogram file", us::Any(), false);
+  parser.addArgument("", "p", mitkCommandLineParser::InputFile, "Input peaks:", "input peak image", us::Any(), false);
+  parser.addArgument("", "c", mitkCommandLineParser::StringList, "Candidates:", "candidate tracts (separate files)", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output folder:", "output folder", us::Any(), false);
 
-  parser.addArgument("reference_mask_folder", "", mitkCommandLineParser::String, "Reference Mask Folder:", "reference tract masks for accuracy evaluation");
+  parser.addArgument("anchor_masks", "", mitkCommandLineParser::StringList, "Reference Masks:", "reference tract masks for accuracy evaluation");
   parser.addArgument("mask", "", mitkCommandLineParser::InputFile, "Mask image:", "scoring is only performed inside the mask image");
   parser.addArgument("greedy_add", "", mitkCommandLineParser::Bool, "Greedy:", "if enabled, the candidate tracts are not jointly fitted to the residual image but one after the other employing a greedy scheme", false);
   parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "modifier for regularization", 0.1);
   parser.addArgument("dont_filter_outliers", "", mitkCommandLineParser::Bool, "Don't filter outliers:", "don't perform second optimization run with an upper weight bound based on the first weight estimation (95% quantile)", false);
+  parser.addArgument("regu", "", mitkCommandLineParser::String, "Regularization:", "MSM, MSE, LocalMSE (default), NONE");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
-  std::string anchors_file = us::any_cast<std::string>(parsedArgs["i1"]);
-  std::string peak_file_name = us::any_cast<std::string>(parsedArgs["i2"]);
-  std::string candidate_folder = us::any_cast<std::string>(parsedArgs["i3"]);
+  std::string anchors_file = us::any_cast<std::string>(parsedArgs["a"]);
+  std::string peak_file_name = us::any_cast<std::string>(parsedArgs["p"]);
+  mitkCommandLineParser::StringContainerType candidate_tract_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["c"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["o"]);
 
   bool greedy_add = false;
   if (parsedArgs.count("greedy_add"))
     greedy_add = us::any_cast<bool>(parsedArgs["greedy_add"]);
 
   float lambda = 0.1;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   bool filter_outliers = true;
   if (parsedArgs.count("dont_filter_outliers"))
     filter_outliers = !us::any_cast<bool>(parsedArgs["dont_filter_outliers"]);
 
   std::string mask_file = "";
   if (parsedArgs.count("mask"))
     mask_file = us::any_cast<std::string>(parsedArgs["mask"]);
 
-  std::string reference_mask_folder = "";
-  if (parsedArgs.count("reference_mask_folder"))
-    reference_mask_folder = us::any_cast<std::string>(parsedArgs["reference_mask_folder"]);
+  mitkCommandLineParser::StringContainerType anchor_mask_files;
+  if (parsedArgs.count("anchor_masks"))
+    anchor_mask_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["anchor_masks"]);
+
+  std::string regu = "NONE";
+  if (parsedArgs.count("regu"))
+    regu = us::any_cast<std::string>(parsedArgs["regu"]);
 
   try
   {
     itk::TimeProbe clock;
     clock.Start();
 
-    MITK_INFO << "Creating directory structure";
+    MITK_INFO << "Creating output directory";
     if (ist::PathExists(out_folder))
       ist::RemoveADirectory(out_folder);
     ist::MakeDirectory(out_folder);
 
     MITK_INFO << "Loading data";
-
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
     ofstream logfile;
     logfile.open (out_folder + "log.txt");
 
     itk::ImageFileWriter< PeakImgType >::Pointer peak_image_writer = itk::ImageFileWriter< PeakImgType >::New();
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Peak Image", "Fiberbundles"}, {});
     mitk::Image::Pointer inputImage = dynamic_cast<mitk::PeakImage*>(mitk::IOUtil::Load(peak_file_name, &functor)[0].GetPointer());
 
     float minSpacing = 1;
     if(inputImage->GetGeometry()->GetSpacing()[0]<inputImage->GetGeometry()->GetSpacing()[1] && inputImage->GetGeometry()->GetSpacing()[0]<inputImage->GetGeometry()->GetSpacing()[2])
       minSpacing = inputImage->GetGeometry()->GetSpacing()[0];
     else if (inputImage->GetGeometry()->GetSpacing()[1] < inputImage->GetGeometry()->GetSpacing()[2])
       minSpacing = inputImage->GetGeometry()->GetSpacing()[1];
     else
       minSpacing = inputImage->GetGeometry()->GetSpacing()[2];
 
     // Load mask file. Fit is only performed inside the mask
     itk::FitFibersToImageFilter::UcharImgType::Pointer mask = nullptr;
     if (mask_file.compare("")!=0)
     {
       mitk::Image::Pointer mitk_mask = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(mask_file)[0].GetPointer());
       mitk::CastToItkImage(mitk_mask, mask);
     }
 
     // Load masks covering the true positives for evaluation purposes
-    std::vector< std::string > reference_mask_filenames;
     std::vector< itk::FitFibersToImageFilter::UcharImgType::Pointer > reference_masks;
-    if (reference_mask_folder.compare("")!=0)
+    for (auto filename : anchor_mask_files)
     {
-      reference_mask_filenames = get_file_list(reference_mask_folder, {".nii", ".nii.gz", ".nrrd"});
-      for (auto filename : reference_mask_filenames)
-      {
-        itk::FitFibersToImageFilter::UcharImgType::Pointer ref_mask = nullptr;
-        mitk::Image::Pointer ref_mitk_mask = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
-        mitk::CastToItkImage(ref_mitk_mask, ref_mask);
-        reference_masks.push_back(ref_mask);
-      }
+      itk::FitFibersToImageFilter::UcharImgType::Pointer ref_mask = nullptr;
+      mitk::Image::Pointer ref_mitk_mask = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
+      mitk::CastToItkImage(ref_mitk_mask, ref_mask);
+      reference_masks.push_back(ref_mask);
     }
 
     // Load peak image
     typedef mitk::ImageToItk< PeakImgType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(inputImage);
     caster->Update();
     PeakImgType::Pointer peak_image = caster->GetOutput();
 
     // Load all candidate tracts
     std::vector< mitk::FiberBundle::Pointer > input_candidates;
-    std::vector< std::string > candidate_tract_files = get_file_list(candidate_folder);
     for (std::string f : candidate_tract_files)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(f)[0].GetPointer());
       if (fib.IsNull())
         continue;
       if (fib->GetNumFibers()<=0)
-        return 0;
+        continue;
       fib->ResampleLinear(minSpacing/10.0);
       input_candidates.push_back(fib);
     }
     std::cout.rdbuf (old);              // <-- restore
 
     double rmse = 0.0;
     int iteration = 0;
     std::string name = "NOANCHOR";
     // Load reference tractogram consisting of all known tracts
     std::vector< mitk::FiberBundle::Pointer > input_reference;
     mitk::FiberBundle::Pointer anchor_tractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(anchors_file)[0].GetPointer());
     if ( !(anchor_tractogram.IsNull() || anchor_tractogram->GetNumFibers()==0) )
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       anchor_tractogram->ResampleLinear(minSpacing/10.0);
       std::cout.rdbuf (old);              // <-- restore
       input_reference.push_back(anchor_tractogram);
 
       // Fit known tracts to peak image to obtain underexplained image
       MITK_INFO << "Fit anchor tracts";
       itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
       fitter->SetTractograms(input_reference);
       fitter->SetLambda(lambda);
       fitter->SetFilterOutliers(filter_outliers);
       fitter->SetPeakImage(peak_image);
       fitter->SetVerbose(true);
       fitter->SetResampleFibers(false);
       fitter->SetMaskImage(mask);
+
+      if (regu=="MSM")
+        fitter->SetRegularization(VnlCostFunction::REGU::MSM);
+      else if (regu=="MSE")
+        fitter->SetRegularization(VnlCostFunction::REGU::MSE);
+      else if (regu=="Local_MSE")
+        fitter->SetRegularization(VnlCostFunction::REGU::Local_MSE);
+      else if (regu=="NONE")
+        fitter->SetRegularization(VnlCostFunction::REGU::NONE);
+
       fitter->Update();
       rmse = fitter->GetRMSE();
 
       name = ist::GetFilenameWithoutExtension(anchors_file);
       mitk::FiberBundle::Pointer anchor_tracts = fitter->GetTractograms().at(0);
       anchor_tracts->SetFiberColors(255,255,255);
       mitk::IOUtil::Save(anchor_tracts, out_folder + "0_" + name + ".fib");
 
       peak_image = fitter->GetUnderexplainedImage();
       peak_image_writer->SetInput(peak_image);
       peak_image_writer->SetFileName(out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".nrrd");
       peak_image_writer->Update();
     }
 
     if (!greedy_add)
     {
       MITK_INFO << "Fit candidate tracts";
       itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
       fitter->SetLambda(lambda);
       fitter->SetFilterOutliers(filter_outliers);
       fitter->SetVerbose(true);
       fitter->SetPeakImage(peak_image);
       fitter->SetResampleFibers(false);
       fitter->SetMaskImage(mask);
       fitter->SetTractograms(input_candidates);
+      fitter->SetFitIndividualFibers(true);
+
+      if (regu=="MSM")
+        fitter->SetRegularization(VnlCostFunction::REGU::MSM);
+      else if (regu=="MSE")
+        fitter->SetRegularization(VnlCostFunction::REGU::MSE);
+      else if (regu=="Local_MSE")
+        fitter->SetRegularization(VnlCostFunction::REGU::Local_MSE);
+      else if (regu=="NONE")
+        fitter->SetRegularization(VnlCostFunction::REGU::NONE);
+
       fitter->Update();
       vnl_vector<double> rms_diff = fitter->GetRmsDiffPerBundle();
 
       vnl_vector<double> log_rms_diff = rms_diff-rms_diff.min_value() + 1;
       log_rms_diff = log_rms_diff.apply(std::log);
       log_rms_diff /= log_rms_diff.max_value();
       int c = 0;
       for (auto fib : input_candidates)
       {
         fib->SetFiberWeights( log_rms_diff[c] );
         fib->ColorFibersByFiberWeights(false, true);
 
         std::string bundle_name = ist::GetFilenameWithoutExtension(candidate_tract_files.at(c));
 
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
         mitk::IOUtil::Save(fib, out_folder + boost::lexical_cast<std::string>((int)(100000*rms_diff[c])) + "_" + bundle_name + ".fib");
 
         float best_overlap = 0;
         int best_overlap_index = -1;
         int m_idx = 0;
         for (auto ref_mask : reference_masks)
         {
           float overlap = fib->GetOverlap(ref_mask, false);
           if (overlap>best_overlap)
           {
             best_overlap = overlap;
             best_overlap_index = m_idx;
           }
           ++m_idx;
         }
 
         unsigned int num_voxels = 0;
         {
           itk::TractDensityImageFilter< ItkUcharImageType >::Pointer masks_filter = itk::TractDensityImageFilter< ItkUcharImageType >::New();
           masks_filter->SetInputImage(mask);
           masks_filter->SetBinaryOutput(true);
           masks_filter->SetFiberBundle(fib);
           masks_filter->SetUseImageGeometry(true);
           masks_filter->Update();
           num_voxels = masks_filter->GetNumCoveredVoxels();
         }
 
         std::cout.rdbuf (old);              // <-- restore
 
         logfile << "RMS_DIFF: " << setprecision(5) << rms_diff[c] << " " << bundle_name << " " << num_voxels << "\n";
         if (best_overlap_index>=0)
-          logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(reference_mask_filenames.at(best_overlap_index)) << "\n";
+          logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(anchor_mask_files.at(best_overlap_index)) << "\n";
         else
           logfile << "No_overlap\n";
 
         ++c;
       }
 
       mitk::FiberBundle::Pointer out_fib = mitk::FiberBundle::New();
       out_fib = out_fib->AddBundles(input_candidates);
       out_fib->ColorFibersByFiberWeights(false, true);
       mitk::IOUtil::Save(out_fib, out_folder + "AllCandidates.fib");
     }
     else
     {
       MITK_INFO << "RMSE: " << setprecision(5) << rmse;
       //    fitter->SetPeakImage(peak_image);
 
       // Iteratively add candidate bundles in a greedy manner
       while (!input_candidates.empty())
       {
         double next_rmse = rmse;
         double num_peaks = 0;
         mitk::FiberBundle::Pointer best_candidate = nullptr;
         PeakImgType::Pointer best_candidate_peak_image = nullptr;
 
         for (int i=0; i<(int)input_candidates.size(); ++i)
         {
           // WHY NECESSARY AGAIN??
           itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
           fitter->SetLambda(lambda);
           fitter->SetFilterOutliers(filter_outliers);
           fitter->SetVerbose(false);
           fitter->SetPeakImage(peak_image);
           fitter->SetResampleFibers(false);
           fitter->SetMaskImage(mask);
           // ******************************
           fitter->SetTractograms({input_candidates.at(i)});
 
           std::streambuf *old = cout.rdbuf(); // <-- save
           std::stringstream ss;
           std::cout.rdbuf (ss.rdbuf());       // <-- redirect
           fitter->Update();
           std::cout.rdbuf (old);              // <-- restore
 
           double candidate_rmse = fitter->GetRMSE();
 
           if (candidate_rmse<next_rmse)
           {
             next_rmse = candidate_rmse;
             num_peaks = fitter->GetNumCoveredDirections();
             best_candidate = fitter->GetTractograms().at(0);
             best_candidate_peak_image = fitter->GetUnderexplainedImage();
           }
         }
 
         if (best_candidate.IsNull())
           break;
 
         //      fitter->SetPeakImage(peak_image);
         peak_image = best_candidate_peak_image;
 
         int i=0;
         std::vector< mitk::FiberBundle::Pointer > remaining_candidates;
         std::vector< std::string > remaining_candidate_files;
         for (auto fib : input_candidates)
         {
           if (fib!=best_candidate)
           {
             remaining_candidates.push_back(fib);
             remaining_candidate_files.push_back(candidate_tract_files.at(i));
           }
           else
             name = ist::GetFilenameWithoutExtension(candidate_tract_files.at(i));
           ++i;
         }
         input_candidates = remaining_candidates;
         candidate_tract_files = remaining_candidate_files;
 
         iteration++;
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
         // Save winning candidate
         mitk::IOUtil::Save(best_candidate, out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".fib");
         peak_image_writer->SetInput(peak_image);
         peak_image_writer->SetFileName(out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".nrrd");
         peak_image_writer->Update();
 
         // Calculate best overlap with reference masks for evaluation purposes
         float best_overlap = 0;
         int best_overlap_index = -1;
         i = 0;
         for (auto ref_mask : reference_masks)
         {
           float overlap = best_candidate->GetOverlap(ref_mask, false);
           if (overlap>best_overlap)
           {
             best_overlap = overlap;
             best_overlap_index = i;
           }
           ++i;
         }
         std::cout.rdbuf (old);              // <-- restore
 
         logfile << "RMSE: " << setprecision(5) << rmse << " " << name << " " << num_peaks << "\n";
         if (best_overlap_index>=0)
-          logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(reference_mask_filenames.at(best_overlap_index)) << "\n";
+          logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(anchor_mask_files.at(best_overlap_index)) << "\n";
         else
           logfile << "No_overlap\n";
       }
     }
 
     clock.Stop();
     int h = clock.GetTotal()/3600;
     int m = ((int)clock.GetTotal()%3600)/60;
     int s = (int)clock.GetTotal()%60;
     MITK_INFO << "Plausibility estimation took " << h << "h, " << m << "m and " << s << "s";
     logfile.close();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/CMakeLists.txt
index 85af60ba39..fb51dda671 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/CMakeLists.txt
@@ -1,45 +1,45 @@
 option(BUILD_DiffusionTractographyEvaluationCmdApps "Build commandline tools for diffusion fiber tractography evaluation" OFF)
 
 if(BUILD_DiffusionTractographyEvaluationCmdApps OR MITK_BUILD_ALL_APPS)
 
   # needed include directories
   include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     )
 
     # list of diffusion cmdapps
     # if an app requires additional dependencies
     # they are added after a "^^" and separated by "_"
     set( diffusionTractographyEvaluationcmdapps
     PeaksAngularError^^MitkFiberTracking
     TractometerMetrics^^MitkFiberTracking
     MergeOverlappingTracts^^MitkFiberTracking
-    ExtractOverlappingTracts^^MitkFiberTracking
+    ExtractAnchorTracts^^MitkFiberTracking
     ExtractSimilarTracts^^MitkFiberTracking
     AnchorBasedScoring^^MitkFiberTracking
     EvaluateLiFE^^MitkFiberTracking
     # LocalDirectionalFiberPlausibility^^MitkFiberTracking # HAS TO USE NEW PEAK IMAGE FORMAT
     )
 
     foreach(diffusionTractographyEvaluationcmdapp ${diffusionTractographyEvaluationcmdapps})
       # extract cmd app name and dependencies
       string(REPLACE "^^" "\\;" cmdapp_info ${diffusionTractographyEvaluationcmdapp})
       set(cmdapp_info_list ${cmdapp_info})
       list(GET cmdapp_info_list 0 appname)
       list(GET cmdapp_info_list 1 raw_dependencies)
       string(REPLACE "_" "\\;" dependencies "${raw_dependencies}")
       set(dependencies_list ${dependencies})
 
       mitkFunctionCreateCommandLineApp(
         NAME ${appname}
         DEPENDS MitkCore MitkDiffusionCore ${dependencies_list}
         PACKAGE_DEPENDS ITK
       )
     endforeach()
 
   if(EXECUTABLE_IS_ENABLED)
     MITK_INSTALL_TARGETS(EXECUTABLES ${EXECUTABLE_TARGET})
   endif()
 
   endif()
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/EvaluateLiFE.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/EvaluateLiFE.cpp
index 66e8baf820..2bc531941f 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/EvaluateLiFE.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/EvaluateLiFE.cpp
@@ -1,226 +1,248 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <fstream>
 #include <chrono>
 #include <boost/progress.hpp>
+#include <itkFiberExtractionFilter.h>
 
 typedef itksys::SystemTools ist;
-typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
-typedef std::tuple< ItkUcharImgType::Pointer, std::string > MaskType;
+typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
+typedef std::tuple< ItkFloatImgType::Pointer, std::string > MaskType;
 
-ItkUcharImgType::Pointer LoadItkMaskImage(const std::string& filename)
+ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
-  ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
+  ItkFloatImgType::Pointer itkMask = ItkFloatImgType::New();
   mitk::CastToItkImage(img, itkMask);
   return itkMask;
 }
 
 std::vector< MaskType > get_file_list(const std::string& path)
 {
   std::chrono::milliseconds ms = std::chrono::duration_cast< std::chrono::milliseconds >(std::chrono::system_clock::now().time_since_epoch());
   std::srand(ms.count());
 
   std::vector< MaskType > mask_list;
 
   itk::Directory::Pointer dir = itk::Directory::New();
 
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     int num_images = 0;
 
     std::vector< int > im_indices;
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       if (ext==".nii" || ext==".nii.gz" || ext==".nrrd")
       {
         ++num_images;
         im_indices.push_back(r);
       }
     }
 
     int c = -1;
     for (int r : im_indices)
     {
       c++;
       const char *filename = dir->GetFile(r);
 
       MITK_INFO << "Loading " << ist::GetFilenameWithoutExtension(filename);
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
-      MaskType m(LoadItkMaskImage(path + '/' + filename), ist::GetFilenameName(filename));
+      MaskType m(LoadItkImage(path + '/' + filename), ist::GetFilenameName(filename));
       mask_list.push_back(m);
       std::cout.rdbuf (old);              // <-- restore
     }
   }
 
   return mask_list;
 }
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Evaluate LiFE results");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output folder", us::Any(), false);
   parser.addArgument("reference_mask_folder", "m", mitkCommandLineParser::String, "Reference Mask Folder:", "reference masks of known bundles", false);
   parser.addArgument("overlap", "", mitkCommandLineParser::Float, "Overlap threshold:", "Overlap threshold used to identify true positives", 0.8);
   parser.addArgument("steps", "", mitkCommandLineParser::Int, "Threshold steps:", "number of weight thresholds used to calculate the ROC curve", 100);
   parser.addArgument("pre_filter_zeros", "", mitkCommandLineParser::Bool, "Remove zero weights:", "remove fibers with zero weights before starting the evaluation");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string fibFile = us::any_cast<std::string>(parsedArgs["input"]);
   std::string reference_mask_folder = us::any_cast<std::string>(parsedArgs["reference_mask_folder"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   float overlap = 0.8;
   if (parsedArgs.count("overlap"))
     overlap = us::any_cast<float>(parsedArgs["overlap"]);
 
   int steps = 10;
   if (parsedArgs.count("steps"))
     steps = us::any_cast<int>(parsedArgs["steps"]);
 
   bool pre_filter_zeros = false;
   if (parsedArgs.count("pre_filter_zeros"))
     pre_filter_zeros = us::any_cast<bool>(parsedArgs["pre_filter_zeros"]);
 
   try
   {
     std::vector< MaskType > known_tract_masks = get_file_list(reference_mask_folder);
     if (known_tract_masks.empty())
       return EXIT_FAILURE;
 
     mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(fibFile)[0].GetPointer());
 
     // resample fibers
     float minSpacing = 1;
     if(std::get<0>(known_tract_masks.at(0))->GetSpacing()[0]<std::get<0>(known_tract_masks.at(0))->GetSpacing()[1] && std::get<0>(known_tract_masks.at(0))->GetSpacing()[0]<std::get<0>(known_tract_masks.at(0))->GetSpacing()[2])
       minSpacing = std::get<0>(known_tract_masks.at(0))->GetSpacing()[0];
     else if (std::get<0>(known_tract_masks.at(0))->GetSpacing()[1] < std::get<0>(known_tract_masks.at(0))->GetSpacing()[2])
       minSpacing = std::get<0>(known_tract_masks.at(0))->GetSpacing()[1];
     else
       minSpacing = std::get<0>(known_tract_masks.at(0))->GetSpacing()[2];
     inputTractogram->ResampleLinear(minSpacing/5);
 
     std::vector< float > weights;
     for (int i=0; i<inputTractogram->GetNumFibers(); ++i)
       weights.push_back(inputTractogram->GetFiberWeight(i));
     std::sort(weights.begin(), weights.end());
 
     if (pre_filter_zeros)
       inputTractogram = inputTractogram->FilterByWeights(0.0);
     mitk::FiberBundle::Pointer pred_positives = inputTractogram->GetDeepCopy();
     mitk::FiberBundle::Pointer pred_negatives = mitk::FiberBundle::New(nullptr);
 
     ofstream logfile;
     logfile.open (out_folder + "LiFE_ROC.txt");
 
     float fpr = 1.0;
     float tpr = 1.0;
     float step = weights.back()/steps;
     float w = 0;
     if (!pre_filter_zeros)
       w -= step;
     while (pred_positives->GetNumFibers()>0 && fpr>0.001 && tpr>0.001)
     {
       w += step;
 
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
       mitk::FiberBundle::Pointer tp_tracts = mitk::FiberBundle::New(nullptr);
       mitk::FiberBundle::Pointer fn_tracts = mitk::FiberBundle::New(nullptr);
+
       for ( MaskType mask : known_tract_masks )
       {
-        ItkUcharImgType::Pointer mask_image = std::get<0>(mask);
-
-        mitk::FiberBundle::Pointer a = pred_positives->ExtractFiberSubset(mask_image, true, false, false, overlap, false);
+        ItkFloatImgType::Pointer mask_image = std::get<0>(mask);
+
+        mitk::FiberBundle::Pointer a;
+        {
+          itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
+          extractor->SetInputFiberBundle(pred_positives);
+          extractor->SetRoiImages({mask_image});
+          extractor->SetOverlapFraction(overlap);
+          extractor->SetDontResampleFibers(true);
+          extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::OVERLAP);
+          extractor->Update();
+          a = extractor->GetPositives().at(0);
+        }
         tp_tracts = tp_tracts->AddBundle(a);
 
-        mitk::FiberBundle::Pointer b = pred_negatives->ExtractFiberSubset(mask_image, true, false, false, overlap, false);
+        mitk::FiberBundle::Pointer b;
+        {
+          itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
+          extractor->SetInputFiberBundle(pred_negatives);
+          extractor->SetRoiImages({mask_image});
+          extractor->SetOverlapFraction(overlap);
+          extractor->SetDontResampleFibers(true);
+          extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::OVERLAP);
+          extractor->Update();
+          b = extractor->GetPositives().at(0);
+        }
         fn_tracts = fn_tracts->AddBundle(b);
       }
       mitk::FiberBundle::Pointer fp_tracts = pred_positives->SubtractBundle(tp_tracts);
       mitk::FiberBundle::Pointer tn_tracts = pred_negatives->SubtractBundle(fn_tracts);
 
       std::cout.rdbuf (old);              // <-- restore
 
       float positives = tp_tracts->GetNumFibers() + fn_tracts->GetNumFibers();
       float negatives = tn_tracts->GetNumFibers() + fp_tracts->GetNumFibers();
       fpr = (float)fp_tracts->GetNumFibers() / negatives;
       tpr = (float)tp_tracts->GetNumFibers() / positives;
 
       float accuracy = 1.0;
       if (pred_positives->GetNumFibers()>0)
         accuracy = (float)tp_tracts->GetNumFibers()/pred_positives->GetNumFibers();
       logfile << w << " " << fpr << " " << tpr << " " << accuracy << " \n";
       MITK_INFO << "#Fibers: " << pred_positives->GetNumFibers();
       MITK_INFO << "FPR/TPR: " << fpr << "/" << tpr;
       MITK_INFO << "Acc: " << accuracy;
 
       pred_positives = inputTractogram->FilterByWeights(w);
       pred_negatives = inputTractogram->FilterByWeights(w, true);
     }
     logfile.close();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractOverlappingTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp
similarity index 73%
rename from Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractOverlappingTracts.cpp
rename to Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp
index 70ecc3ac90..2a09a200e7 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp
@@ -1,268 +1,285 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <fstream>
 #include <chrono>
 #include <boost/progress.hpp>
+#include <itkFiberExtractionFilter.h>
 
 typedef itksys::SystemTools ist;
-typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
-typedef std::tuple< ItkUcharImgType::Pointer, std::string > MaskType;
+typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
+typedef std::tuple< ItkFloatImgType::Pointer, std::string > MaskType;
 
 void CreateFolderStructure(const std::string& path)
 {
   if (ist::PathExists(path))
     ist::RemoveADirectory(path);
 
   ist::MakeDirectory(path);
   ist::MakeDirectory(path + "/anchor_tracts/");
   ist::MakeDirectory(path + "/candidate_tracts/");
   ist::MakeDirectory(path + "/implausible_tracts/");
   ist::MakeDirectory(path + "/skipped_masks/");
 }
 
-ItkUcharImgType::Pointer LoadItkMaskImage(const std::string& filename)
+ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
-  ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
+  ItkFloatImgType::Pointer itkMask = ItkFloatImgType::New();
   mitk::CastToItkImage(img, itkMask);
   return itkMask;
 }
 
-std::vector< MaskType > get_file_list(const std::string& path, float anchor_fraction, const std::string& skipped_path)
+std::vector< MaskType > get_file_list(const std::string& path, float anchor_fraction, const std::string& skipped_path, int random_seed)
 {
   if (anchor_fraction<0)
     anchor_fraction = 0;
   else if (anchor_fraction>1.0)
     anchor_fraction = 1.0;
 
   std::chrono::milliseconds ms = std::chrono::duration_cast< std::chrono::milliseconds >(std::chrono::system_clock::now().time_since_epoch());
-  std::srand(ms.count());
+  if (random_seed<0)
+    std::srand(ms.count());
+  else
+    std::srand(random_seed);
+  MITK_INFO << "random_seed: " << random_seed;
 
   std::vector< MaskType > mask_list;
 
   itk::Directory::Pointer dir = itk::Directory::New();
 
   int skipped = 0;
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     int num_images = 0;
 
     std::vector< int > im_indices;
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       if (ext==".nii" || ext==".nii.gz" || ext==".nrrd")
       {
         ++num_images;
         im_indices.push_back(r);
       }
     }
 
     int skipping_num = num_images * (1.0 - anchor_fraction);
     std::random_shuffle(im_indices.begin(), im_indices.end());
     MITK_INFO << "Skipping " << skipping_num << " images";
     MITK_INFO << "Number of anchors: " << num_images-skipping_num;
 
     int c = -1;
     for (int r : im_indices)
     {
       c++;
       const char *filename = dir->GetFile(r);
 
       if (c<skipping_num && (skipping_num==num_images || ist::GetFilenameWithoutExtension(filename)!="CC"))
       {
         MITK_INFO << "Skipping " << ist::GetFilenameWithoutExtension(filename);
         ist::CopyAFile(path + '/' + filename, skipped_path + ist::GetFilenameName(filename));
         skipped++;
         continue;
       }
 
       MITK_INFO << "Loading " << ist::GetFilenameWithoutExtension(filename);
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
-      MaskType m(LoadItkMaskImage(path + '/' + filename), ist::GetFilenameName(filename));
+      MaskType m(LoadItkImage(path + '/' + filename), ist::GetFilenameName(filename));
       mask_list.push_back(m);
       std::cout.rdbuf (old);              // <-- restore
     }
   }
 
   return mask_list;
 }
 
 mitk::FiberBundle::Pointer TransformToMRtrixSpace(mitk::FiberBundle::Pointer fib)
 {
   mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
   vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
   matrix->Identity();
   matrix->SetElement(0,0,-matrix->GetElement(0,0));
   matrix->SetElement(1,1,-matrix->GetElement(1,1));
   geometry->SetIndexToWorldTransformByVtkMatrix(matrix);
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(fib->GetFiberPolyData());
   transformFilter->SetTransform(geometry->GetVtkTransform());
   transformFilter->Update();
   mitk::FiberBundle::Pointer transformed_fib = mitk::FiberBundle::New(transformFilter->GetOutput());
   return transformed_fib;
 }
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Extract Overlapping Tracts");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output folder", us::Any(), false);
   parser.addArgument("reference_mask_folder", "m", mitkCommandLineParser::String, "Reference Mask Folder:", "reference masks of known bundles", us::Any(), false);
   parser.addArgument("gray_matter_mask", "gm", mitkCommandLineParser::String, "GM mask:", "remove fibers not ending in the gray matter");
   parser.addArgument("anchor_fraction", "", mitkCommandLineParser::Float, "Anchor fraction:", "Fraction of tracts used as anchors", 0.5);
   parser.addArgument("overlap", "", mitkCommandLineParser::Float, "Overlap threshold:", "Overlap threshold used to identify the anchor tracts", 0.8);
   parser.addArgument("subsample", "", mitkCommandLineParser::Float, "Subsampling factor:", "Only use specified fraction of input fibers for the analysis", 1.0);
+  parser.addArgument("random_seed", "", mitkCommandLineParser::Int, ":", "", -1);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string fibFile = us::any_cast<std::string>(parsedArgs["input"]);
   std::string reference_mask_folder = us::any_cast<std::string>(parsedArgs["reference_mask_folder"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   std::string gray_matter_mask = "";
   if (parsedArgs.count("gray_matter_mask"))
     gray_matter_mask = us::any_cast<std::string>(parsedArgs["gray_matter_mask"]);
 
   float anchor_fraction = 0.5;
   if (parsedArgs.count("anchor_fraction"))
     anchor_fraction = us::any_cast<float>(parsedArgs["anchor_fraction"]);
 
+  int random_seed = -1;
+  if (parsedArgs.count("random_seed"))
+    random_seed = us::any_cast<int>(parsedArgs["random_seed"]);
+
   float overlap = 0.8;
   if (parsedArgs.count("overlap"))
     overlap = us::any_cast<float>(parsedArgs["overlap"]);
 
   float subsample = 1.0;
   if (parsedArgs.count("subsample"))
     subsample = us::any_cast<float>(parsedArgs["subsample"]);
 
   try
   {
     CreateFolderStructure(out_folder);
-    std::vector< MaskType > known_tract_masks = get_file_list(reference_mask_folder, anchor_fraction, out_folder + "/skipped_masks/");
+    std::vector< MaskType > known_tract_masks = get_file_list(reference_mask_folder, anchor_fraction, out_folder + "/skipped_masks/", random_seed);
     mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(fibFile)[0].GetPointer());
 
     MITK_INFO << "Removing fibers not ending inside of GM";
     if (gray_matter_mask.compare("")!=0)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
-      ItkUcharImgType::Pointer gm_image = LoadItkMaskImage(gray_matter_mask);
+      ItkFloatImgType::Pointer gm_image = LoadItkImage(gray_matter_mask);
       std::cout.rdbuf (old);              // <-- restore
 
-      mitk::FiberBundle::Pointer not_gm_fibers = inputTractogram->ExtractFiberSubset(gm_image, false, true, true);
+      itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
+      extractor->SetInputFiberBundle(inputTractogram);
+      extractor->SetRoiImages({gm_image});
+      extractor->SetBothEnds(true);
+      extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::ENDPOINTS);
+      extractor->Update();
+
+      mitk::FiberBundle::Pointer not_gm_fibers = extractor->GetNegatives().at(0);
 
       old = cout.rdbuf(); // <-- save
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       mitk::IOUtil::Save(not_gm_fibers, out_folder + "/implausible_tracts/no_gm_endings.trk");
-      inputTractogram = inputTractogram->ExtractFiberSubset(gm_image, false, false, true);
+      inputTractogram = extractor->GetPositives().at(0);
       std::cout.rdbuf (old);              // <-- restore
     }
 
+    std::srand(0);
     if (subsample<1.0)
       inputTractogram = inputTractogram->SubsampleFibers(subsample);
 
-
-    // resample fibers
-    float minSpacing = 1;
-    if (!known_tract_masks.empty())
-    {
-      if(std::get<0>(known_tract_masks.at(0))->GetSpacing()[0]<std::get<0>(known_tract_masks.at(0))->GetSpacing()[1] && std::get<0>(known_tract_masks.at(0))->GetSpacing()[0]<std::get<0>(known_tract_masks.at(0))->GetSpacing()[2])
-        minSpacing = std::get<0>(known_tract_masks.at(0))->GetSpacing()[0];
-      else if (std::get<0>(known_tract_masks.at(0))->GetSpacing()[1] < std::get<0>(known_tract_masks.at(0))->GetSpacing()[2])
-        minSpacing = std::get<0>(known_tract_masks.at(0))->GetSpacing()[1];
-      else
-        minSpacing = std::get<0>(known_tract_masks.at(0))->GetSpacing()[2];
-    }
-    inputTractogram->ResampleLinear(minSpacing/5);
-
-    mitk::FiberBundle::Pointer all_anchor_tracts = mitk::FiberBundle::New(nullptr);
+    mitk::FiberBundle::Pointer anchor_tractogram = mitk::FiberBundle::New(nullptr);
+    mitk::FiberBundle::Pointer candidate_tractogram = mitk::FiberBundle::New(nullptr);
     if (!known_tract_masks.empty())
     {
       MITK_INFO << "Find known tracts via overlap match";
-      boost::progress_display disp(known_tract_masks.size());
-      for ( MaskType mask : known_tract_masks )
+      std::vector< ItkFloatImgType::Pointer > mask_images;
+      for (auto mask : known_tract_masks)
+        mask_images.push_back(std::get<0>(mask));
+
+      std::vector< ItkFloatImgType* > roi_images2;
+      for (auto roi : mask_images)
+        roi_images2.push_back(roi);
+
+      itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
+      extractor->SetInputFiberBundle(inputTractogram);
+      extractor->SetRoiImages(roi_images2);
+      extractor->SetOverlapFraction(overlap);
+      extractor->SetDontResampleFibers(true);
+      extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::OVERLAP);
+      extractor->Update();
+      std::vector< mitk::FiberBundle::Pointer > positives = extractor->GetPositives();
+      candidate_tractogram = extractor->GetNegatives().at(0);
+
+      for ( unsigned int i=0; i<known_tract_masks.size(); ++i )
       {
-        ++disp;
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
-        ItkUcharImgType::Pointer mask_image = std::get<0>(mask);
-        std::string mask_name = std::get<1>(mask);
-        mitk::FiberBundle::Pointer known_tract = inputTractogram->ExtractFiberSubset(mask_image, true, false, false, overlap, false);
-        mitk::IOUtil::Save(known_tract, out_folder + "/anchor_tracts/" + mask_name + ".trk");
-
-        all_anchor_tracts = all_anchor_tracts->AddBundle(known_tract);
+        std::string mask_name = std::get<1>(known_tract_masks.at(i));
+        mitk::IOUtil::Save(positives.at(i), out_folder + "/anchor_tracts/" + mask_name + ".trk");
 
         std::cout.rdbuf (old);              // <-- restore
       }
+      anchor_tractogram = anchor_tractogram->AddBundles(positives);
     }
 
-    mitk::IOUtil::Save(all_anchor_tracts, out_folder + "/anchor_tracts/anchor_tractogram.trk");
-    mitk::FiberBundle::Pointer remaining_tracts = inputTractogram->SubtractBundle(all_anchor_tracts);
-    mitk::IOUtil::Save(remaining_tracts, out_folder + "/candidate_tracts/candidate_tractogram.trk");
+    mitk::IOUtil::Save(anchor_tractogram, out_folder + "/anchor_tracts/anchor_tractogram.trk");
+    mitk::IOUtil::Save(candidate_tractogram, out_folder + "/candidate_tracts/candidate_tractogram.trk");
     mitk::IOUtil::Save(inputTractogram, out_folder + "/filtered_tractogram.trk");
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp
index dbbe833487..fd07b7bac2 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp
@@ -1,216 +1,240 @@
 /*===================================================================
 
 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 <mitkFiberBundle.h>
 #include <mitkCommandLineParser.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkIOUtil.h>
 #include <itkTractClusteringFilter.h>
 #include <mitkClusteringMetricEuclideanMean.h>
 #include <mitkClusteringMetricEuclideanMax.h>
 #include <mitkClusteringMetricEuclideanStd.h>
 #include <mitkClusteringMetricAnatomic.h>
 #include <mitkClusteringMetricScalarMap.h>
 
 typedef itksys::SystemTools ist;
-typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
+typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
   std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
   if( fibInfile.empty() )
     std::cout << "File " << filename << " could not be read!";
   mitk::BaseData::Pointer baseData = fibInfile.at(0);
   return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
-ItkUcharImgType::Pointer LoadItkMaskImage(const std::string& filename)
+ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
-  ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
+  ItkFloatImgType::Pointer itkMask = ItkFloatImgType::New();
   mitk::CastToItkImage(img, itkMask);
   return itkMask;
 }
 
 /*!
 \brief Spatially cluster fibers
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Extract Similar Tracts");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
   parser.addArgument("ref_tracts", "", mitkCommandLineParser::StringList, "Ref. Tracts:", "reference tracts (.fib, .trk, .tck)", us::Any(), false);
   parser.addArgument("ref_masks", "", mitkCommandLineParser::StringList, "Ref. Masks:", "reference bundle masks", us::Any());
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
   parser.addArgument("distance", "", mitkCommandLineParser::Int, "Distance:", "", 10);
   parser.addArgument("metric", "", mitkCommandLineParser::String, "Metric:", "");
+  parser.addArgument("subsample", "", mitkCommandLineParser::Float, "Subsampling factor:", "Only use specified fraction of input fibers", 1.0);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string in_fib = us::any_cast<std::string>(parsedArgs["i"]);
   std::string out_root = us::any_cast<std::string>(parsedArgs["o"]);
   mitkCommandLineParser::StringContainerType ref_bundle_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["ref_tracts"]);
   mitkCommandLineParser::StringContainerType ref_mask_files;
   if (parsedArgs.count("ref_masks"))
     ref_mask_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["ref_masks"]);
 
   if (ref_mask_files.size()>0 && ref_mask_files.size()!=ref_bundle_files.size())
   {
     MITK_INFO << "If reference masks are used, there has to be one mask per reference tract.";
     return EXIT_FAILURE;
   }
 
   int distance = 10;
   if (parsedArgs.count("distance"))
     distance = us::any_cast<int>(parsedArgs["distance"]);
 
   std::string metric = "EU_MEAN";
   if (parsedArgs.count("metric"))
     metric = us::any_cast<std::string>(parsedArgs["metric"]);
 
+  float subsample = 1.0;
+  if (parsedArgs.count("subsample"))
+    subsample = us::any_cast<float>(parsedArgs["subsample"]);
+
   try
   {
     mitk::FiberBundle::Pointer fib = LoadFib(in_fib);
-    fib->ResampleToNumPoints(12);
+
+    std::srand(0);
+    if (subsample<1.0)
+      fib = fib->SubsampleFibers(subsample);
+
+    mitk::FiberBundle::Pointer resampled_fib = fib->GetDeepCopy();
+    resampled_fib->ResampleToNumPoints(12);
 
     std::vector< mitk::FiberBundle::Pointer > ref_fibs;
-    std::vector< ItkUcharImgType::Pointer > ref_masks;
+    std::vector< ItkFloatImgType::Pointer > ref_masks;
     for (std::size_t i=0; i<ref_bundle_files.size(); ++i)
     {
       MITK_INFO << "Loading " << ist::GetFilenameName(ref_bundle_files.at(i));
       if (i<ref_mask_files.size())
         MITK_INFO << "Loading " << ist::GetFilenameName(ref_mask_files.at(i));
 
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       try
       {
         ref_fibs.push_back(LoadFib(ref_bundle_files.at(i)));
         if (i<ref_mask_files.size())
-          ref_masks.push_back(LoadItkMaskImage(ref_mask_files.at(i)));
+          ref_masks.push_back(LoadItkImage(ref_mask_files.at(i)));
         else
           ref_masks.push_back(nullptr);
         std::cout.rdbuf (old);              // <-- restore
       }
       catch(...){
         std::cout.rdbuf (old);              // <-- restore
         std::cout << "could not load: " << ref_bundle_files.at(i);
         return EXIT_FAILURE;
       }
     }
 
     std::vector< float > distances;
     distances.push_back(distance);
 
     mitk::FiberBundle::Pointer anchor_tractogram = mitk::FiberBundle::New(nullptr);
     unsigned int c = 0;
     for (auto ref_fib : ref_fibs)
     {
       MITK_INFO << "Extracting " << ist::GetFilenameName(ref_bundle_files.at(c));
 
-      std::streambuf *old = cout.rdbuf(); // <-- save
-      std::stringstream ss;
-      std::cout.rdbuf (ss.rdbuf());       // <-- redirect
+//      std::streambuf *old = cout.rdbuf(); // <-- save
+//      std::stringstream ss;
+//      std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       try
       {
         itk::TractClusteringFilter::Pointer segmenter = itk::TractClusteringFilter::New();
 
         // calculate centroids from reference bundle
         {
+          MITK_INFO << "TEST 1";
           itk::TractClusteringFilter::Pointer clusterer = itk::TractClusteringFilter::New();
           clusterer->SetDistances({10,20,30});
           clusterer->SetTractogram(ref_fib);
           clusterer->SetMetrics({new mitk::ClusteringMetricEuclideanStd()});
+          clusterer->SetMergeDuplicateThreshold(0.0);
           clusterer->Update();
+          MITK_INFO << "TEST 2";
           std::vector<mitk::FiberBundle::Pointer> tracts = clusterer->GetOutCentroids();
           ref_fib = mitk::FiberBundle::New(nullptr);
           ref_fib = ref_fib->AddBundles(tracts);
+          MITK_INFO << "TEST 3";
           mitk::IOUtil::Save(ref_fib, out_root + "centroids_" + ist::GetFilenameName(ref_bundle_files.at(c)));
           segmenter->SetInCentroids(ref_fib);
+          MITK_INFO << "TEST 4";
         }
 
         // segment tract
         segmenter->SetFilterMask(ref_masks.at(c));
         segmenter->SetOverlapThreshold(0.8);
         segmenter->SetDistances(distances);
-        segmenter->SetTractogram(fib);
+        segmenter->SetTractogram(resampled_fib);
+        segmenter->SetMergeDuplicateThreshold(0.0);
         segmenter->SetDoResampling(false);
         if (metric=="EU_MEAN")
           segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanMean()});
         else if (metric=="EU_STD")
           segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanStd()});
         else if (metric=="EU_MAX")
           segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanMax()});
         segmenter->Update();
 
-        std::vector<mitk::FiberBundle::Pointer> clusters = segmenter->GetOutTractograms();
+        std::vector< std::vector< long > > clusters = segmenter->GetOutFiberIndices();
         if (clusters.size()>0)
         {
-          fib = clusters.back();
-          clusters.pop_back();
+          vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
+
           mitk::FiberBundle::Pointer result = mitk::FiberBundle::New(nullptr);
-          result = result->AddBundles(clusters);
+          std::vector< mitk::FiberBundle::Pointer > result_fibs;
+          for (unsigned int cluster_index=0; cluster_index<clusters.size()-1; ++cluster_index)
+            result_fibs.push_back(mitk::FiberBundle::New(fib->GeneratePolyDataByIds(clusters.at(cluster_index), weights)));
+          result = result->AddBundles(result_fibs);
+
           anchor_tractogram = anchor_tractogram->AddBundle(result);
           mitk::IOUtil::Save(result, out_root + "anchor_" + ist::GetFilenameName(ref_bundle_files.at(c)));
+
+          fib = mitk::FiberBundle::New(fib->GeneratePolyDataByIds(clusters.back(), weights));
+          resampled_fib = mitk::FiberBundle::New(resampled_fib->GeneratePolyDataByIds(clusters.back(), weights));
         }
       }
       catch(itk::ExceptionObject& excpt)
       {
         MITK_INFO << "Exception while processing " << ist::GetFilenameName(ref_bundle_files.at(c));
         MITK_INFO << excpt.GetDescription();
       }
       catch(std::exception& excpt)
       {
         MITK_INFO << "Exception while processing " << ist::GetFilenameName(ref_bundle_files.at(c));
         MITK_INFO << excpt.what();
       }
-      std::cout.rdbuf (old);              // <-- restore
+//      std::cout.rdbuf (old);              // <-- restore
       if (fib->GetNumFibers()==0)
         break;
       ++c;
     }
     MITK_INFO << "Streamlines in anchor tractogram: " << anchor_tractogram->GetNumFibers();
     mitk::IOUtil::Save(anchor_tractogram, out_root + "anchor_tractogram.trk");
 
     MITK_INFO << "Streamlines remaining in candidate tractogram: " << fib->GetNumFibers();
     mitk::IOUtil::Save(fib, out_root + "candidate_tractogram.trk");
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
index a9488c0b72..f95146e500 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
@@ -1,251 +1,251 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <fstream>
 #include <chrono>
 #include <boost/progress.hpp>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkImageFileWriter.h>
 
 typedef itksys::SystemTools ist;
-typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
+typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 typedef itk::Image<unsigned int, 3>    ItkUIntImgType;
 
 std::vector< std::string > get_file_list(const std::string& path, std::vector< std::string > extensions={".fib", ".trk"})
 {
   std::vector< std::string > file_list;
   itk::Directory::Pointer dir = itk::Directory::New();
 
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       for (auto e : extensions)
       {
         if (ext==e)
         {
           file_list.push_back(path + '/' + filename);
           break;
         }
       }
     }
   }
   return file_list;
 }
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Merge Overlapping Tracts");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input Folder:", "input folder", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output Folder:", "output folder", us::Any(), false);
   parser.addArgument("overlap", "", mitkCommandLineParser::Float, "Overlap threshold:", "Tracts with overlap larger than this threshold are merged", false, 0.8);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string input_folder = us::any_cast<std::string>(parsedArgs["in"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   float overlap = 0.8;
   if (parsedArgs.count("overlap"))
     overlap = us::any_cast<float>(parsedArgs["overlap"]);
 
   try
   {
     if (ist::PathExists(out_folder))
       ist::RemoveADirectory(out_folder);
     ist::MakeDirectory(out_folder);
 
     std::vector< std::string > fib_files = get_file_list(input_folder, {".fib", ".trk", ".tck"});
     if (fib_files.empty())
       return EXIT_FAILURE;
 
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
     std::vector< mitk::FiberBundle::Pointer > fibs;
     for (std::string f : fib_files)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(f)[0].GetPointer());
       fibs.push_back(fib);
     }
 
     mitk::FiberBundle::Pointer combined = mitk::FiberBundle::New();
     combined = combined->AddBundles(fibs);
 
-    itk::TractsToFiberEndingsImageFilter< ItkUcharImgType >::Pointer endings = itk::TractsToFiberEndingsImageFilter< ItkUcharImgType >::New();
+    itk::TractsToFiberEndingsImageFilter< ItkFloatImgType >::Pointer endings = itk::TractsToFiberEndingsImageFilter< ItkFloatImgType >::New();
     endings->SetFiberBundle(combined);
     endings->SetUpsamplingFactor(0.25);
     endings->Update();
-    ItkUcharImgType::Pointer ref_image = endings->GetOutput();
+    ItkFloatImgType::Pointer ref_image = endings->GetOutput();
 
     std::cout.rdbuf (old);              // <-- restore
 
     for (int its = 0; its<3; its++)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
-      std::vector< ItkUcharImgType::Pointer > mask_images;
+      std::vector< ItkFloatImgType::Pointer > mask_images;
       for (auto fib : fibs)
       {
-        itk::TractDensityImageFilter< ItkUcharImgType >::Pointer masks = itk::TractDensityImageFilter< ItkUcharImgType >::New();
+        itk::TractDensityImageFilter< ItkFloatImgType >::Pointer masks = itk::TractDensityImageFilter< ItkFloatImgType >::New();
         masks->SetInputImage(ref_image);
         masks->SetBinaryOutput(true);
         masks->SetFiberBundle(fib);
         masks->SetUseImageGeometry(true);
         masks->Update();
         mask_images.push_back(masks->GetOutput());
       }
 
       int r=0;
       vnl_matrix< int > mat; mat.set_size(mask_images.size(), mask_images.size()); mat.fill(0);
       for (auto m1 : mask_images)
       {
         float max_overlap = overlap;
         int c = 0;
         for (auto m2 : mask_images)
         {
           if (c<=r)
           {
             ++c;
             continue;
           }
 
-          itk::ImageRegionConstIterator<ItkUcharImgType> it1(m1, m1->GetLargestPossibleRegion());
-          itk::ImageRegionConstIterator<ItkUcharImgType> it2(m2, m2->GetLargestPossibleRegion());
+          itk::ImageRegionConstIterator<ItkFloatImgType> it1(m1, m1->GetLargestPossibleRegion());
+          itk::ImageRegionConstIterator<ItkFloatImgType> it2(m2, m2->GetLargestPossibleRegion());
 
           unsigned int c1 = 0;
           unsigned int c2 = 0;
           unsigned int intersect = 0;
           while( !it1.IsAtEnd() )
           {
             if( it1.Get()>0 && it2.Get()>0)
               ++intersect;
             if(it1.Get()>0)
               ++c1;
             if(it2.Get()>0)
               ++c2;
             ++it1;
             ++it2;
           }
 
           if ( (float)intersect/c1>max_overlap )
           {
             max_overlap = (float)intersect/c1;
             mat.put(r,c, 1);
           }
           if ( (float)intersect/c2>max_overlap )
           {
             max_overlap = (float)intersect/c2;
             mat.put(r,c, 1);
           }
           ++c;
         }
 
         ++r;
       }
 
       std::vector< mitk::FiberBundle::Pointer > out_fibs;
       std::vector< bool > used;
       for (unsigned int i=0; i<fibs.size(); i++)
         used.push_back(false);
       for (unsigned int r=0; r<mask_images.size(); r++)
       {
         if (used.at(r))
           continue;
 
         mitk::FiberBundle::Pointer fib = fibs.at(r);
         for (unsigned int c=r+1; c<mask_images.size(); c++)
         {
           if (mat.get(r,c)>0)
           {
             fib = fib->AddBundle(fibs.at(c));
             MITK_INFO << c;
             used[c] = true;
           }
         }
 
         out_fibs.push_back(fib);
       }
       std::cout.rdbuf (old);              // <-- restore
 
       MITK_INFO << fibs.size() << " --> " << out_fibs.size();
 
       if (fibs.size()==out_fibs.size())
         break;
       fibs = out_fibs;
     }
 
     int c = 0;
     for (auto fib : fibs)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       mitk::IOUtil::Save(fib, out_folder + "/bundle_" + boost::lexical_cast<std::string>(c) + ".trk");
       std::cout.rdbuf (old);              // <-- restore
 
       ++c;
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake
index 1fe24d7019..8fbb5beec8 100644
--- a/Modules/DiffusionImaging/FiberTracking/files.cmake
+++ b/Modules/DiffusionImaging/FiberTracking/files.cmake
@@ -1,102 +1,103 @@
 set(CPP_FILES
 
   mitkFiberTrackingModuleActivator.cpp
 
   ## IO datastructures
   IODataStructures/FiberBundle/mitkFiberBundle.cpp
   IODataStructures/FiberBundle/mitkTrackvis.cpp
   IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
   IODataStructures/mitkTractographyForest.cpp
 
   # Interactions
 
   # Tractography
   Algorithms/GibbsTracking/mitkParticleGrid.cpp
   Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp
   Algorithms/GibbsTracking/mitkEnergyComputer.cpp
   Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp
   Algorithms/GibbsTracking/mitkFiberBuilder.cpp
   Algorithms/GibbsTracking/mitkSphereInterpolator.cpp
 
   Algorithms/itkStreamlineTrackingFilter.cpp
   Algorithms/TrackingHandlers/mitkTrackingDataHandler.cpp
   Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp
   Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.cpp
   Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
 )
 
 set(H_FILES
   # DataStructures -> FiberBundle
   IODataStructures/FiberBundle/mitkFiberBundle.h
   IODataStructures/FiberBundle/mitkTrackvis.h
   IODataStructures/mitkFiberfoxParameters.h
   IODataStructures/mitkTractographyForest.h
 
   # Algorithms
   Algorithms/itkTractDensityImageFilter.h
   Algorithms/itkTractsToFiberEndingsImageFilter.h
   Algorithms/itkTractsToRgbaImageFilter.h
   Algorithms/itkTractsToVectorImageFilter.h
   Algorithms/itkEvaluateDirectionImagesFilter.h
   Algorithms/itkEvaluateTractogramDirectionsFilter.h
   Algorithms/itkFiberCurvatureFilter.h
   Algorithms/itkFitFibersToImageFilter.h
   Algorithms/itkTractClusteringFilter.h
+  Algorithms/itkFiberExtractionFilter.h
 
   # Tractography
   Algorithms/TrackingHandlers/mitkTrackingDataHandler.h
   Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h
   Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h
   Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h
   Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h
 
   Algorithms/itkGibbsTrackingFilter.h
   Algorithms/itkStochasticTractographyFilter.h
   Algorithms/GibbsTracking/mitkParticle.h
   Algorithms/GibbsTracking/mitkParticleGrid.h
   Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h
   Algorithms/GibbsTracking/mitkSimpSamp.h
   Algorithms/GibbsTracking/mitkEnergyComputer.h
   Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h
   Algorithms/GibbsTracking/mitkSphereInterpolator.h
   Algorithms/GibbsTracking/mitkFiberBuilder.h
 
   Algorithms/itkStreamlineTrackingFilter.h
 
   # Clustering
   Algorithms/ClusteringMetrics/mitkClusteringMetric.h
   Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMean.h
   Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMax.h
   Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanStd.h
   Algorithms/ClusteringMetrics/mitkClusteringMetricAnatomic.h
   Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
   Algorithms/ClusteringMetrics/mitkClusteringMetricInnerAngles.h
 
   # Fiberfox
   Fiberfox/itkFibersFromPlanarFiguresFilter.h
   Fiberfox/itkTractsToDWIImageFilter.h
   Fiberfox/itkKspaceImageFilter.h
   Fiberfox/itkDftImageFilter.h
   Fiberfox/itkFieldmapGeneratorFilter.h
 
   Fiberfox/SignalModels/mitkDiffusionSignalModel.h
   Fiberfox/SignalModels/mitkTensorModel.h
   Fiberfox/SignalModels/mitkBallModel.h
   Fiberfox/SignalModels/mitkDotModel.h
   Fiberfox/SignalModels/mitkAstroStickModel.h
   Fiberfox/SignalModels/mitkStickModel.h
   Fiberfox/SignalModels/mitkRawShModel.h
   Fiberfox/SignalModels/mitkDiffusionNoiseModel.h
   Fiberfox/SignalModels/mitkRicianNoiseModel.h
   Fiberfox/SignalModels/mitkChiSquareNoiseModel.h
 
   Fiberfox/Sequences/mitkAcquisitionType.h
   Fiberfox/Sequences/mitkSingleShotEpi.h
   Fiberfox/Sequences/mitkCartesianReadout.h
 )
 
 set(RESOURCE_FILES
   # Binary directory resources
   FiberTrackingLUTBaryCoords.bin
   FiberTrackingLUTIndices.bin
 )
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberFitViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberFitViewControls.ui
index 7905b595a8..28ab5be067 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberFitViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberFitViewControls.ui
@@ -1,179 +1,179 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkFiberFitViewControls</class>
  <widget class="QWidget" name="QmitkFiberFitViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>484</width>
     <height>574</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_10">
    <item row="0" column="0">
     <widget class="QFrame" name="frame">
      <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <property name="spacing">
        <number>6</number>
       </property>
       <item row="0" column="1">
        <widget class="QmitkDataStorageComboBox" name="m_ImageBox">
         <property name="toolTip">
          <string>Select a peak or raw diffusion-weighted image.</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QCheckBox" name="m_OutliersBox">
         <property name="text">
          <string/>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label_3">
         <property name="text">
          <string>Input Image:</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="label_5">
         <property name="text">
          <string>Suppress Outliers:</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QDoubleSpinBox" name="m_ReguBox">
         <property name="toolTip">
          <string>Modifier for regularization.</string>
         </property>
         <property name="maximum">
          <double>999999.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
         <property name="value">
-         <double>0.100000000000000</double>
+         <double>1.000000000000000</double>
         </property>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QCommandLinkButton" name="m_StartButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="maximumSize">
          <size>
           <width>200</width>
           <height>16777215</height>
          </size>
         </property>
         <property name="font">
          <font>
           <pointsize>11</pointsize>
          </font>
         </property>
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Start</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_4">
         <property name="text">
          <string>Tractogram:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QmitkDataStorageComboBox" name="m_TractBox"/>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>λ:</string>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QLabel" name="label_6">
         <property name="text">
          <string>Output Residuals:</string>
         </property>
        </widget>
       </item>
       <item row="4" column="1">
        <widget class="QCheckBox" name="m_ResidualsBox">
         <property name="text">
          <string/>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="1" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.cpp
index 9f353d6f34..25ba19ad35 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1577 +1,1596 @@
 /*===================================================================
 
 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 <berryIWorkbenchPart.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberProcessingView.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 #include "usModuleRegistry.h"
 #include <itkFiberCurvatureFilter.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
+#include <itkFiberExtractionFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 
 const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberProcessingView::QmitkFiberProcessingView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_CircleCounter(0)
   , m_PolygonCounter(0)
   , m_UpsamplingFactor(1)
 {
 
 }
 
 // Destructor
 QmitkFiberProcessingView::~QmitkFiberProcessingView()
 {
   RemoveObservers();
 }
 
 void QmitkFiberProcessingView::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::QmitkFiberProcessingViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
     connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
     connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
     connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
     connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
     connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
 
     connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
     connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
     connect(m_Controls->m_CopyBundle, SIGNAL(clicked()), this, SLOT(CopyBundles()) );
 
     connect(m_Controls->m_ExtractFibersButton, SIGNAL(clicked()), this, SLOT(Extract()));
     connect(m_Controls->m_RemoveButton, SIGNAL(clicked()), this, SLOT(Remove()));
     connect(m_Controls->m_ModifyButton, SIGNAL(clicked()), this, SLOT(Modify()));
 
     connect(m_Controls->m_ExtractionMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
     connect(m_Controls->m_RemovalMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
     connect(m_Controls->m_ModificationMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
     connect(m_Controls->m_ExtractionBoxMask, SIGNAL(currentIndexChanged(int)), this, SLOT(OnMaskExtractionChanged()));
 
     m_Controls->m_ColorMapBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
     mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
     mitk::NodePredicateDataType::Pointer isOdf = mitk::NodePredicateDataType::New("OdfImage");
     mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
     isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isOdf);
     mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
     mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
     m_Controls->m_ColorMapBox->SetPredicate(finalPredicate);
 
     m_Controls->label_17->setVisible(false);
     m_Controls->m_FiberExtractionFractionBox->setVisible(false);
   }
 
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::OnMaskExtractionChanged()
 {
-  if (m_Controls->m_ExtractionBoxMask->currentIndex() == 2)
+  if (m_Controls->m_ExtractionBoxMask->currentIndex() == 2 || m_Controls->m_ExtractionBoxMask->currentIndex() == 3)
   {
     m_Controls->label_17->setVisible(true);
     m_Controls->m_FiberExtractionFractionBox->setVisible(true);
     m_Controls->m_BothEnds->setVisible(false);
   }
   else
   {
     m_Controls->label_17->setVisible(false);
     m_Controls->m_FiberExtractionFractionBox->setVisible(false);
     if (m_Controls->m_ExtractionBoxMask->currentIndex() != 3)
       m_Controls->m_BothEnds->setVisible(true);
   }
 }
 
 void QmitkFiberProcessingView::SetFocus()
 {
   m_Controls->toolBoxx->setFocus();
 }
 
 void QmitkFiberProcessingView::Modify()
 {
   switch (m_Controls->m_ModificationMethodBox->currentIndex())
   {
   case 0:
   {
     ResampleSelectedBundlesSpline();
     break;
   }
   case 1:
   {
     ResampleSelectedBundlesLinear();
     break;
   }
   case 2:
   {
     CompressSelectedBundles();
     break;
   }
   case 3:
   {
     DoImageColorCoding();
     break;
   }
   case 4:
   {
     MirrorFibers();
     break;
   }
   case 5:
   {
     WeightFibers();
     break;
   }
   case 6:
   {
     DoCurvatureColorCoding();
     break;
   }
   case 7:
   {
     DoWeightColorCoding();
     break;
   }
   }
 }
 
 void QmitkFiberProcessingView::WeightFibers()
 {
   float weight = this->m_Controls->m_BundleWeightBox->value();
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->SetFiberWeights(weight);
   }
 
 }
 
 void QmitkFiberProcessingView::Remove()
 {
   switch (m_Controls->m_RemovalMethodBox->currentIndex())
   {
   case 0:
   {
     RemoveDir();
     break;
   }
   case 1:
   {
     PruneBundle();
     break;
   }
   case 2:
   {
     ApplyCurvatureThreshold();
     break;
   }
   case 3:
   {
     RemoveWithMask(false);
     break;
   }
   case 4:
   {
     RemoveWithMask(true);
     break;
   }
   case 5:
   {
     ApplyWeightThreshold();
     break;
   }
   }
 }
 
 void QmitkFiberProcessingView::Extract()
 {
   switch (m_Controls->m_ExtractionMethodBox->currentIndex())
   {
   case 0:
   {
     ExtractWithPlanarFigure();
     break;
   }
   case 1:
   {
     switch (m_Controls->m_ExtractionBoxMask->currentIndex())
     {
     {
     case 0:
         ExtractWithMask(true, false);
         break;
     }
     {
     case 1:
         ExtractWithMask(true, true);
         break;
     }
     {
     case 2:
         ExtractWithMask(false, false);
         break;
     }
     {
     case 3:
         ExtractWithMask(false, true);
         break;
     }
     }
     break;
   }
   }
 }
 
 void QmitkFiberProcessingView::PruneBundle()
 {
   int minLength = this->m_Controls->m_PruneFibersMinBox->value();
   int maxLength = this->m_Controls->m_PruneFibersMaxBox->value();
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     if (!fib->RemoveShortFibers(minLength))
       QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
     else if (!fib->RemoveLongFibers(maxLength))
       QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ApplyWeightThreshold()
 {
   float thr = this->m_Controls->m_WeightThresholdBox->value();
   std::vector< DataNode::Pointer > nodes = m_SelectedFB;
   for (auto node : nodes)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
     mitk::FiberBundle::Pointer newFib = fib->FilterByWeights(thr);
     if (newFib->GetNumFibers()>0)
     {
       newFib->ColorFibersByFiberWeights(false, true);
       node->SetData(newFib);
     }
     else
       QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ApplyCurvatureThreshold()
 {
   int angle = this->m_Controls->m_CurvSpinBox->value();
   int dist = this->m_Controls->m_CurvDistanceSpinBox->value();
   std::vector< DataNode::Pointer > nodes = m_SelectedFB;
   for (auto node : nodes)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
     itk::FiberCurvatureFilter::Pointer filter = itk::FiberCurvatureFilter::New();
     filter->SetInputFiberBundle(fib);
     filter->SetAngularDeviation(angle);
     filter->SetDistance(dist);
     filter->SetRemoveFibers(m_Controls->m_RemoveCurvedFibersBox->isChecked());
     filter->Update();
     mitk::FiberBundle::Pointer newFib = filter->GetOutputFiberBundle();
     if (newFib->GetNumFibers()>0)
     {
       newFib->ColorFibersByOrientation();
       node->SetData(newFib);
     }
     else
       QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveDir()
 {
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     vnl_vector_fixed<double,3> dir;
     dir[0] = m_Controls->m_ExtractDirX->value();
     dir[1] = m_Controls->m_ExtractDirY->value();
     dir[2] = m_Controls->m_ExtractDirZ->value();
     fib->RemoveDir(dir,cos((float)m_Controls->m_ExtractAngle->value()*M_PI/180));
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveWithMask(bool removeInside)
 {
-  if (m_MaskImageNode.IsNull())
+  if (m_RoiImageNode.IsNull())
     return;
 
-  mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
+  mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_RoiImageNode->GetData());
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
-    itkUCharImageType::Pointer mask = itkUCharImageType::New();
+    ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
     mitk::CastToItkImage(mitkMask, mask);
     mitk::FiberBundle::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
     if (newFib->GetNumFibers()<=0)
     {
       QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
       continue;
     }
     node->SetData(newFib);
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ExtractWithMask(bool onlyEnds, bool invert)
 {
-  if (m_MaskImageNode.IsNull())
+  if (m_RoiImageNode.IsNull())
     return;
 
-  mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
+  mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_RoiImageNode->GetData());
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     QString name(node->GetName().c_str());
 
-    itkUCharImageType::Pointer mask = itkUCharImageType::New();
+    ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(mitkMask, mask);
-    mitk::FiberBundle::Pointer newFib = fib->ExtractFiberSubset(mask, !onlyEnds, invert, m_Controls->m_BothEnds->isChecked(), m_Controls->m_FiberExtractionFractionBox->value());
-    if (newFib->GetNumFibers()<=0)
+
+    itk::FiberExtractionFilter<float>::Pointer extractor = itk::FiberExtractionFilter<float>::New();
+    extractor->SetInputFiberBundle(fib);
+    extractor->SetRoiImages({mask});
+    extractor->SetOverlapFraction(m_Controls->m_FiberExtractionFractionBox->value());
+    extractor->SetBothEnds(m_Controls->m_BothEnds->isChecked());
+    extractor->SetInterpolate(m_Controls->m_InterpolateRoiBox->isChecked());
+    if (invert)
+      extractor->SetNoPositives(true);
+    else
+      extractor->SetNoNegatives(true);
+    if (onlyEnds)
+      extractor->SetMode(itk::FiberExtractionFilter<float>::MODE::ENDPOINTS);
+    extractor->Update();
+
+    mitk::FiberBundle::Pointer newFib;
+    if (invert)
+      newFib = extractor->GetNegatives().at(0);
+    else
+      newFib = extractor->GetPositives().at(0);
+
+    if (newFib.IsNull() || newFib->GetNumFibers()<=0)
     {
       QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
       continue;
     }
 
     DataNode::Pointer newNode = DataNode::New();
     newNode->SetData(newFib);
 
     if (invert)
     {
       name += "_not";
 
       if (onlyEnds)
         name += "-ending-in-mask";
       else
         name += "-passing-mask";
     }
     else
     {
       if (onlyEnds)
         name += "_ending-in-mask";
       else
         name += "_passing-mask";
     }
 
     newNode->SetName(name.toStdString());
     GetDataStorage()->Add(newNode);
     node->SetVisibility(false);
   }
 }
 
 void QmitkFiberProcessingView::GenerateRoiImage()
 {
   if (m_SelectedPF.empty())
     return;
 
   mitk::BaseGeometry::Pointer geometry;
   if (!m_SelectedFB.empty())
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.front()->GetData());
     geometry = fib->GetGeometry();
   }
   else if (m_SelectedImage)
     geometry = m_SelectedImage->GetGeometry();
   else
     return;
 
   itk::Vector<double,3> spacing = geometry->GetSpacing();
   spacing /= m_UpsamplingFactor;
 
   mitk::Point3D newOrigin = geometry->GetOrigin();
   mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
   newOrigin[0] += bounds.GetElement(0);
   newOrigin[1] += bounds.GetElement(2);
   newOrigin[2] += bounds.GetElement(4);
 
   itk::Matrix<double, 3, 3> direction;
   itk::ImageRegion<3> imageRegion;
   for (int i=0; i<3; i++)
     for (int j=0; j<3; j++)
       direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
   imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
   imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
   imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
 
-  m_PlanarFigureImage = itkUCharImageType::New();
+  m_PlanarFigureImage = ItkUCharImageType::New();
   m_PlanarFigureImage->SetSpacing( spacing );   // Set the image spacing
   m_PlanarFigureImage->SetOrigin( newOrigin );     // Set the image origin
   m_PlanarFigureImage->SetDirection( direction );  // Set the image direction
   m_PlanarFigureImage->SetRegions( imageRegion );
   m_PlanarFigureImage->Allocate();
   m_PlanarFigureImage->FillBuffer( 0 );
 
   Image::Pointer tmpImage = Image::New();
   tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
   tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
 
   std::string name = m_SelectedPF.at(0)->GetName();
   WritePfToImage(m_SelectedPF.at(0), tmpImage);
   for (unsigned int i=1; i<m_SelectedPF.size(); i++)
   {
     name += "+";
     name += m_SelectedPF.at(i)->GetName();
     WritePfToImage(m_SelectedPF.at(i), tmpImage);
   }
 
   DataNode::Pointer node = DataNode::New();
   tmpImage = Image::New();
   tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
   tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
   node->SetData(tmpImage);
   node->SetName(name);
   this->GetDataStorage()->Add(node);
 }
 
 void QmitkFiberProcessingView::WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image)
 {
   if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
   {
     m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     AccessFixedDimensionByItk_2(
           image,
           InternalReorientImagePlane, 3,
           m_PlanarFigure->GetGeometry(), -1);
 
     AccessFixedDimensionByItk_2(
           m_InternalImage,
           InternalCalculateMaskFromPlanarFigure,
           3, 2, node->GetName() );
   }
   else if (dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()))
   {
     DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(node);
     for (unsigned int i=0; i<children->Size(); i++)
     {
       WritePfToImage(children->at(i), image);
     }
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
   typedef itk::Image< float, VImageDimension > FloatImageType;
 
   typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
   typename ResamplerType::Pointer resampler = ResamplerType::New();
 
   mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
 
   float upsamp = m_UpsamplingFactor;
   float gausssigma = 0.5;
 
   // Spacing
   typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
   spacing[0] = image->GetSpacing()[0] / upsamp;
   spacing[1] = image->GetSpacing()[1] / upsamp;
   spacing[2] = image->GetSpacing()[2];
   resampler->SetOutputSpacing( spacing );
 
   // Size
   typename ResamplerType::SizeType size;
   size[0] = planegeo->GetExtentInMM(0) / spacing[0];
   size[1] = planegeo->GetExtentInMM(1) / spacing[1];
   size[2] = 1;
   resampler->SetSize( size );
 
   // Origin
   typename mitk::Point3D orig = planegeo->GetOrigin();
   typename mitk::Point3D corrorig;
   planegeo3D->WorldToIndex(orig,corrorig);
   corrorig[0] += 0.5/upsamp;
   corrorig[1] += 0.5/upsamp;
   corrorig[2] += 0;
   planegeo3D->IndexToWorld(corrorig,corrorig);
   resampler->SetOutputOrigin(corrorig );
 
   // Direction
   typename ResamplerType::DirectionType direction;
   typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
   for(unsigned int c=0; c<matrix.ColumnDimensions; c++)
   {
     double sum = 0;
     for(unsigned int r=0; r<matrix.RowDimensions; r++)
       sum += matrix(r,c)*matrix(r,c);
     for(unsigned int r=0; r<matrix.RowDimensions; r++)
       direction(r,c) = matrix(r,c)/sqrt(sum);
   }
   resampler->SetOutputDirection( direction );
 
   // Gaussian interpolation
   if(gausssigma != 0)
   {
     double sigma[3];
     for( unsigned int d = 0; d < 3; d++ )
       sigma[d] = gausssigma * image->GetSpacing()[d];
     double alpha = 2.0;
     typedef itk::GaussianInterpolateImageFunction<ImageType, double> GaussianInterpolatorType;
     typename GaussianInterpolatorType::Pointer interpolator = GaussianInterpolatorType::New();
     interpolator->SetInputImage( image );
     interpolator->SetParameters( sigma, alpha );
     resampler->SetInterpolator( interpolator );
   }
   else
   {
     typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
     typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
     interpolator->SetInputImage( image );
     resampler->SetInterpolator( interpolator );
   }
 
   resampler->SetInput( image );
   resampler->SetDefaultPixelValue(0);
   resampler->Update();
 
   if(additionalIndex < 0)
   {
     this->m_InternalImage = mitk::Image::New();
     this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
     this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string )
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
-  typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
+  typedef itk::CastImageFilter< ImageType, ItkUCharImageType > CastFilterType;
 
   // Generate mask image as new image with same header as input image and
   // initialize with "1".
-  itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
+  ItkUCharImageType::Pointer newMaskImage = ItkUCharImageType::New();
   newMaskImage->SetSpacing( image->GetSpacing() );   // Set the image spacing
   newMaskImage->SetOrigin( image->GetOrigin() );     // Set the image origin
   newMaskImage->SetDirection( image->GetDirection() );  // Set the image direction
   newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
   newMaskImage->Allocate();
   newMaskImage->FillBuffer( 1 );
 
   // Generate VTK polygon from (closed) PlanarFigure polyline
   // (The polyline points are shifted by -0.5 in z-direction to make sure
   // that the extrusion filter, which afterwards elevates all points by +0.5
   // in z-direction, creates a 3D object which is cut by the the plane z=0)
   const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
   const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
   const BaseGeometry *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
 
   vtkPolyData *polyline = vtkPolyData::New();
   polyline->Allocate( 1, 1 );
 
   // Determine x- and y-dimensions depending on principal axis
   int i0, i1;
   switch ( axis )
   {
   case 0:
     i0 = 1;
     i1 = 2;
     break;
   case 1:
     i0 = 0;
     i1 = 2;
     break;
   case 2:
   default:
     i0 = 0;
     i1 = 1;
     break;
   }
 
   // Create VTK polydata object of polyline contour
   vtkPoints *points = vtkPoints::New();
   PlanarFigure::PolyLineType::const_iterator it;
   unsigned int numberOfPoints = 0;
 
   for ( it = planarFigurePolyline.begin(); it != planarFigurePolyline.end(); ++it )
   {
     Point3D point3D;
 
     // Convert 2D point back to the local index coordinates of the selected image
     Point2D point2D = *it;
     planarFigurePlaneGeometry->WorldToIndex(point2D, point2D);
     point2D[0] -= 0.5/m_UpsamplingFactor;
     point2D[1] -= 0.5/m_UpsamplingFactor;
     planarFigurePlaneGeometry->IndexToWorld(point2D, point2D);
     planarFigurePlaneGeometry->Map( point2D, point3D );
 
     // Polygons (partially) outside of the image bounds can not be processed further due to a bug in vtkPolyDataToImageStencil
     if ( !imageGeometry3D->IsInside( point3D ) )
     {
       float bounds[2] = {0,0};
       bounds[0] =
           this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
       bounds[1] =
           this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
 
       imageGeometry3D->WorldToIndex( point3D, point3D );
 
       if (point3D[i0]<0)
         point3D[i0] = 0.0;
       else if (point3D[i0]>bounds[0])
         point3D[i0] = bounds[0]-0.001;
 
       if (point3D[i1]<0)
         point3D[i1] = 0.0;
       else if (point3D[i1]>bounds[1])
         point3D[i1] = bounds[1]-0.001;
 
       points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
       numberOfPoints++;
     }
     else
     {
       imageGeometry3D->WorldToIndex( point3D, point3D );
       // Add point to polyline array
       points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
       numberOfPoints++;
     }
   }
   polyline->SetPoints( points );
   points->Delete();
 
   vtkIdType *ptIds = new vtkIdType[numberOfPoints];
   for ( vtkIdType i = 0; i < numberOfPoints; ++i )
     ptIds[i] = i;
   polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
 
   // Extrude the generated contour polygon
   vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
   extrudeFilter->SetInputData( polyline );
   extrudeFilter->SetScaleFactor( 1 );
   extrudeFilter->SetExtrusionTypeToNormalExtrusion();
   extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
 
   // Make a stencil from the extruded polygon
   vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
   polyDataToImageStencil->SetInputConnection( extrudeFilter->GetOutputPort() );
 
   // Export from ITK to VTK (to use a VTK filter)
-  typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
-  typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
+  typedef itk::VTKImageImport< ItkUCharImageType > ImageImportType;
+  typedef itk::VTKImageExport< ItkUCharImageType > ImageExportType;
 
   typename ImageExportType::Pointer itkExporter = ImageExportType::New();
   itkExporter->SetInput( newMaskImage );
 
   vtkImageImport *vtkImporter = vtkImageImport::New();
   this->ConnectPipelines( itkExporter, vtkImporter );
   vtkImporter->Update();
 
   // Apply the generated image stencil to the input image
   vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
   imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
   imageStencilFilter->SetStencilConnection(polyDataToImageStencil->GetOutputPort() );
   imageStencilFilter->ReverseStencilOff();
   imageStencilFilter->SetBackgroundValue( 0 );
   imageStencilFilter->Update();
 
   // Export from VTK back to ITK
   vtkImageExport *vtkExporter = vtkImageExport::New();
   vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
   vtkExporter->Update();
 
   typename ImageImportType::Pointer itkImporter = ImageImportType::New();
   this->ConnectPipelines( vtkExporter, itkImporter );
   itkImporter->Update();
 
   // calculate cropping bounding box
   m_InternalImageMask3D = itkImporter->GetOutput();
   m_InternalImageMask3D->SetDirection(image->GetDirection());
 
-  itk::ImageRegionConstIterator<itkUCharImageType>
+  itk::ImageRegionConstIterator<ItkUCharImageType>
       itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
   itk::ImageRegionIterator<ImageType>
       itimage(image, image->GetLargestPossibleRegion());
 
   itmask.GoToBegin();
   itimage.GoToBegin();
 
   typename ImageType::SizeType lowersize = {{itk::NumericTraits<unsigned long>::max(),itk::NumericTraits<unsigned long>::max(),itk::NumericTraits<unsigned long>::max()}};
   typename ImageType::SizeType uppersize = {{0,0,0}};
   while( !itmask.IsAtEnd() )
   {
     if(itmask.Get() == 0)
       itimage.Set(0);
     else
     {
       typename ImageType::IndexType index = itimage.GetIndex();
       typename ImageType::SizeType signedindex;
       signedindex[0] = index[0];
       signedindex[1] = index[1];
       signedindex[2] = index[2];
 
       lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
       lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
       lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
 
       uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
       uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
       uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
     }
 
     ++itmask;
     ++itimage;
   }
 
   typename ImageType::IndexType index;
   index[0] = lowersize[0];
   index[1] = lowersize[1];
   index[2] = lowersize[2];
 
   typename ImageType::SizeType size;
   size[0] = uppersize[0] - lowersize[0] + 1;
   size[1] = uppersize[1] - lowersize[1] + 1;
   size[2] = uppersize[2] - lowersize[2] + 1;
 
   itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
 
   // crop internal mask
-  typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
+  typedef itk::RegionOfInterestImageFilter< ItkUCharImageType, ItkUCharImageType > ROIMaskFilterType;
   typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
   roi2->SetRegionOfInterest(cropRegion);
   roi2->SetInput(m_InternalImageMask3D);
   roi2->Update();
   m_InternalImageMask3D = roi2->GetOutput();
 
   Image::Pointer tmpImage = Image::New();
   tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
   tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
 
   Image::Pointer tmpImage2 = Image::New();
   tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
   const BaseGeometry *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
 
   const BaseGeometry *intImageGeometry3D = tmpImage->GetGeometry( 0 );
 
-  typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
+  typedef itk::ImageRegionIteratorWithIndex<ItkUCharImageType> IteratorType;
   IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
   imageIterator.GoToBegin();
   while ( !imageIterator.IsAtEnd() )
   {
     unsigned char val = imageIterator.Value();
     if (val>0)
     {
       itk::Index<3> index = imageIterator.GetIndex();
       Point3D point;
       point[0] = index[0];
       point[1] = index[1];
       point[2] = index[2];
 
       intImageGeometry3D->IndexToWorld(point, point);
       pfImageGeometry3D->WorldToIndex(point, point);
 
       point[i0] += 0.5;
       point[i1] += 0.5;
 
       index[0] = point[0];
       index[1] = point[1];
       index[2] = point[2];
 
       if (pfImageGeometry3D->IsIndexInside(index))
         m_PlanarFigureImage->SetPixel(index, 1);
     }
     ++imageIterator;
   }
 
   // Clean up VTK objects
   polyline->Delete();
   extrudeFilter->Delete();
   polyDataToImageStencil->Delete();
   vtkImporter->Delete();
   imageStencilFilter->Delete();
   //vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
   delete[] ptIds;
 }
 
 void QmitkFiberProcessingView::UpdateGui()
 {
   m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
   m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
   m_Controls->m_InputData->setTitle("Please Select Input Data");
 
   m_Controls->m_RemoveButton->setEnabled(false);
 
   m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
   m_Controls->PFCompoANDButton->setEnabled(false);
   m_Controls->PFCompoORButton->setEnabled(false);
   m_Controls->PFCompoNOTButton->setEnabled(false);
 
   m_Controls->m_GenerateRoiImage->setEnabled(false);
   m_Controls->m_ExtractFibersButton->setEnabled(false);
   m_Controls->m_ModifyButton->setEnabled(false);
 
   m_Controls->m_CopyBundle->setEnabled(false);
   m_Controls->m_JoinBundles->setEnabled(false);
   m_Controls->m_SubstractBundles->setEnabled(false);
 
   // disable alle frames
   m_Controls->m_BundleWeightFrame->setVisible(false);
   m_Controls->m_ExtactionFramePF->setVisible(false);
   m_Controls->m_RemoveDirectionFrame->setVisible(false);
   m_Controls->m_RemoveLengthFrame->setVisible(false);
   m_Controls->m_RemoveCurvatureFrame->setVisible(false);
   m_Controls->m_RemoveByWeightFrame->setVisible(false);
   m_Controls->m_SmoothFibersFrame->setVisible(false);
   m_Controls->m_CompressFibersFrame->setVisible(false);
   m_Controls->m_ColorFibersFrame->setVisible(false);
   m_Controls->m_MirrorFibersFrame->setVisible(false);
   m_Controls->m_MaskExtractionFrame->setVisible(false);
   m_Controls->m_ColorMapBox->setVisible(false);
 
   bool pfSelected = !m_SelectedPF.empty();
   bool fibSelected = !m_SelectedFB.empty();
   bool multipleFibsSelected = (m_SelectedFB.size()>1);
-  bool maskSelected = m_MaskImageNode.IsNotNull();
+  bool maskSelected = m_RoiImageNode.IsNotNull();
   bool imageSelected = m_SelectedImage.IsNotNull();
 
   // toggle visibility of elements according to selected method
   switch ( m_Controls->m_ExtractionMethodBox->currentIndex() )
   {
   case 0:
     m_Controls->m_ExtactionFramePF->setVisible(true);
     break;
   case 1:
     m_Controls->m_MaskExtractionFrame->setVisible(true);
     break;
   }
 
   switch ( m_Controls->m_RemovalMethodBox->currentIndex() )
   {
   case 0:
     m_Controls->m_RemoveDirectionFrame->setVisible(true);
     if ( fibSelected )
       m_Controls->m_RemoveButton->setEnabled(true);
     break;
   case 1:
     m_Controls->m_RemoveLengthFrame->setVisible(true);
     if ( fibSelected )
       m_Controls->m_RemoveButton->setEnabled(true);
     break;
   case 2:
     m_Controls->m_RemoveCurvatureFrame->setVisible(true);
     if ( fibSelected )
       m_Controls->m_RemoveButton->setEnabled(true);
     break;
   case 3:
     break;
   case 4:
     break;
   case 5:
     m_Controls->m_RemoveByWeightFrame->setVisible(true);
     if ( fibSelected )
       m_Controls->m_RemoveButton->setEnabled(true);
     break;
   }
 
   switch ( m_Controls->m_ModificationMethodBox->currentIndex() )
   {
   case 0:
     m_Controls->m_SmoothFibersFrame->setVisible(true);
     break;
   case 1:
     m_Controls->m_SmoothFibersFrame->setVisible(true);
     break;
   case 2:
     m_Controls->m_CompressFibersFrame->setVisible(true);
     break;
   case 3:
     m_Controls->m_ColorFibersFrame->setVisible(true);
     m_Controls->m_ColorMapBox->setVisible(true);
     break;
   case 4:
     m_Controls->m_MirrorFibersFrame->setVisible(true);
     if (m_SelectedSurfaces.size()>0)
       m_Controls->m_ModifyButton->setEnabled(true);
     break;
   case 5:
     m_Controls->m_BundleWeightFrame->setVisible(true);
     break;
   case 6:
     m_Controls->m_ColorFibersFrame->setVisible(true);
     break;
   case 7:
     m_Controls->m_ColorFibersFrame->setVisible(true);
     break;
   }
 
   // are fiber bundles selected?
   if ( fibSelected )
   {
     m_Controls->m_CopyBundle->setEnabled(true);
     m_Controls->m_ModifyButton->setEnabled(true);
     m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
     m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
 
     // one bundle and one planar figure needed to extract fibers
     if (pfSelected && m_Controls->m_ExtractionMethodBox->currentIndex()==0)
     {
       m_Controls->m_InputData->setTitle("Input Data");
       m_Controls->m_PfLabel->setText(QString(m_SelectedPF.at(0)->GetName().c_str()));
       m_Controls->m_ExtractFibersButton->setEnabled(true);
     }
 
     // more than two bundles needed to join/subtract
     if (multipleFibsSelected)
     {
       m_Controls->m_FibLabel->setText("multiple bundles selected");
 
       m_Controls->m_JoinBundles->setEnabled(true);
       m_Controls->m_SubstractBundles->setEnabled(true);
     }
 
     if (maskSelected && m_Controls->m_ExtractionMethodBox->currentIndex()==1)
     {
       m_Controls->m_InputData->setTitle("Input Data");
-      m_Controls->m_PfLabel->setText(QString(m_MaskImageNode->GetName().c_str()));
+      m_Controls->m_PfLabel->setText(QString(m_RoiImageNode->GetName().c_str()));
       m_Controls->m_ExtractFibersButton->setEnabled(true);
     }
 
     if (maskSelected && (m_Controls->m_RemovalMethodBox->currentIndex()==3 || m_Controls->m_RemovalMethodBox->currentIndex()==4) )
     {
       m_Controls->m_InputData->setTitle("Input Data");
-      m_Controls->m_PfLabel->setText(QString(m_MaskImageNode->GetName().c_str()));
+      m_Controls->m_PfLabel->setText(QString(m_RoiImageNode->GetName().c_str()));
       m_Controls->m_RemoveButton->setEnabled(true);
     }
   }
 
   // are planar figures selected?
   if (pfSelected)
   {
     if ( fibSelected || m_SelectedImage.IsNotNull())
       m_Controls->m_GenerateRoiImage->setEnabled(true);
 
     if (m_SelectedPF.size() > 1)
     {
       m_Controls->PFCompoANDButton->setEnabled(true);
       m_Controls->PFCompoORButton->setEnabled(true);
     }
     else
       m_Controls->PFCompoNOTButton->setEnabled(true);
   }
 
   // is image selected
   if (imageSelected || maskSelected)
   {
     m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
   }
 }
 
 void QmitkFiberProcessingView::NodeRemoved(const mitk::DataNode* node )
 {
   for (auto fnode: m_SelectedFB)
     if (node == fnode)
     {
       m_SelectedFB.clear();
       break;
     }
 
   berry::IWorkbenchPart::Pointer nullPart;
   QList<mitk::DataNode::Pointer> nodes;
   OnSelectionChanged(nullPart, nodes);
 }
 
 void QmitkFiberProcessingView::NodeAdded(const mitk::DataNode* )
 {
   if (!m_Controls->m_InteractiveBox->isChecked())
   {
     berry::IWorkbenchPart::Pointer nullPart;
     QList<mitk::DataNode::Pointer> nodes;
     OnSelectionChanged(nullPart, nodes);
   }
 }
 
 void QmitkFiberProcessingView::OnEndInteraction()
 {
   if (m_Controls->m_InteractiveBox->isChecked())
     ExtractWithPlanarFigure(true);
 }
 
 void QmitkFiberProcessingView::AddObservers()
 {
   typedef itk::SimpleMemberCommand< QmitkFiberProcessingView > SimpleCommandType;
   for (auto node : m_SelectedPF)
   {
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     if (figure!=nullptr)
     {
       figure->RemoveAllObservers();
 
       // add observer for event when interaction with figure starts
       SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
       endInteractionCommand->SetCallbackFunction( this, &QmitkFiberProcessingView::OnEndInteraction);
       m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
     }
   }
 }
 
 void QmitkFiberProcessingView::RemoveObservers()
 {
   for (auto node : m_SelectedPF)
   {
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     if (figure!=nullptr)
       figure->RemoveAllObservers();
   }
 }
 
 void QmitkFiberProcessingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   RemoveObservers();
 
   //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
   std::vector<mitk::DataNode::Pointer>  lastSelectedFB = m_SelectedFB;
   m_SelectedFB.clear();
   m_SelectedPF.clear();
   m_SelectedSurfaces.clear();
   m_SelectedImage = nullptr;
-  m_MaskImageNode = nullptr;
+  m_RoiImageNode = nullptr;
 
   for (auto node: nodes)
   {
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
       m_SelectedFB.push_back(node);
     else if (dynamic_cast<mitk::PlanarPolygon*>(node->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()) || dynamic_cast<mitk::PlanarCircle*>(node->GetData()))
       m_SelectedPF.push_back(node);
     else if (dynamic_cast<mitk::Image*>(node->GetData()))
     {
       m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
-      bool isBinary = false;
-      node->GetPropertyValue<bool>("binary", isBinary);
-      if (isBinary)
-        m_MaskImageNode = node;
+      if (m_SelectedImage->GetDimension()==3)
+        m_RoiImageNode = node;
     }
     else if (dynamic_cast<mitk::Surface*>(node->GetData()))
       m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
   }
 
   // if we perform interactive fiber extraction, we want to avoid auto-selection of the extracted bundle
   if (m_SelectedFB.empty() && m_Controls->m_InteractiveBox->isChecked())
     m_SelectedFB = lastSelectedFB;
 
   // if no fibers or surfaces are selected, select topmost
   if (m_SelectedFB.empty() && m_SelectedSurfaces.empty())
   {
     int maxLayer = 0;
     itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDataStorage()->GetAll();
     for (unsigned int i=0; i<nodes->Size(); i++)
       if (dynamic_cast<mitk::FiberBundle*>(nodes->at(i)->GetData()))
       {
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
         if (sources->Size()>0)
           continue;
 
         int layer = 0;
         nodes->at(i)->GetPropertyValue("layer", layer);
         if (layer>=maxLayer)
         {
           maxLayer = layer;
           m_SelectedFB.clear();
           m_SelectedFB.push_back(nodes->at(i));
         }
       }
   }
 
   // if no plar figure is selected, select topmost
   if (m_SelectedPF.empty())
   {
     int maxLayer = 0;
     itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDataStorage()->GetAll();
     for (unsigned int i=0; i<nodes->Size(); i++)
       if (dynamic_cast<mitk::PlanarPolygon*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarCircle*>(nodes->at(i)->GetData()))
       {
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
         if (sources->Size()>0)
           continue;
 
         int layer = 0;
         nodes->at(i)->GetPropertyValue("layer", layer);
         if (layer>=maxLayer)
         {
           maxLayer = layer;
           m_SelectedPF.clear();
           m_SelectedPF.push_back(nodes->at(i));
         }
       }
   }
 
   AddObservers();
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::OnDrawPolygon()
 {
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 }
 
 void QmitkFiberProcessingView::OnDrawCircle()
 {
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 }
 
 void QmitkFiberProcessingView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *, mitk::BaseProperty* )
 {
   // initialize figure's geometry with empty geometry
   mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
   figure->SetPlaneGeometry( emptygeometry );
 
   //set desired data to DataNode where Planarfigure is stored
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
   newNode->SetBoolProperty("planarfigure.3drendering", true);
   newNode->SetBoolProperty("planarfigure.3drendering.fill", true);
 
   mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->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(newNode);
   }
 
   // figure drawn on the topmost layer / image
   GetDataStorage()->Add(newNode );
 
   RemoveObservers();
   for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
     m_SelectedPF[i]->SetSelected(false);
 
   newNode->SetSelected(true);
   m_SelectedPF.clear();
   m_SelectedPF.push_back(newNode);
   AddObservers();
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::ExtractWithPlanarFigure(bool interactive)
 {
   if ( m_SelectedFB.empty() || m_SelectedPF.empty() ){
     QMessageBox::information( nullptr, "Warning", "No fibe bundle selected!");
     return;
   }
 
   try
   {
     std::vector<mitk::DataNode::Pointer> fiberBundles = m_SelectedFB;
     mitk::DataNode::Pointer planarFigure = m_SelectedPF.at(0);
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(fiberBundles.at(i)->GetData());
       mitk::FiberBundle::Pointer extFB = fib->ExtractFiberSubset(planarFigure, GetDataStorage());
 
       if (interactive && 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);
         }
         float op = 5.0/sqrt(fib->GetNumFibers());
         float currentOp = 0;
         fiberBundles.at(i)->GetFloatProperty("opacity", currentOp);
 
         if (currentOp!=op)
         {
           fib->SetFiberColors(255, 255, 255);
           fiberBundles.at(i)->SetFloatProperty("opacity", op);
           fiberBundles.at(i)->SetBoolProperty("Fiber2DfadeEFX", false);
         }
         m_InteractiveNode->SetData(extFB);
       }
       else
       {
         if (extFB->GetNumFibers()<=0)
         {
           QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers.");
           continue;
         }
 
         mitk::DataNode::Pointer node;
         node = mitk::DataNode::New();
         node->SetData(extFB);
         QString name(fiberBundles.at(i)->GetName().c_str());
         name += "*";
         node->SetName(name.toStdString());
         fiberBundles.at(i)->SetVisibility(false);
         GetDataStorage()->Add(node);
       }
     }
   }
   catch(const std::out_of_range& )
   {
     QMessageBox::warning( nullptr, "Fiber extraction failed", "Did you only create the planar figure, using the circle or polygon button, but forgot to actually place it in the image afterwards? \nAfter creating a planar figure, simply left-click at the desired position in the image or on the tractogram to place it.");
   }
 }
 
 void QmitkFiberProcessingView::GenerateAndComposite()
 {
   mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
   PFCAnd->setOperationType(mitk::PlanarFigureComposite::AND);
 
   mitk::DataNode::Pointer newPFCNode;
   newPFCNode = mitk::DataNode::New();
   newPFCNode->SetName("AND");
   newPFCNode->SetData(PFCAnd);
 
   AddCompositeToDatastorage(newPFCNode, m_SelectedPF);
   RemoveObservers();
   m_SelectedPF.clear();
   m_SelectedPF.push_back(newPFCNode);
   AddObservers();
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::GenerateOrComposite()
 {
   mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
   PFCOr->setOperationType(mitk::PlanarFigureComposite::OR);
 
   mitk::DataNode::Pointer newPFCNode;
   newPFCNode = mitk::DataNode::New();
   newPFCNode->SetName("OR");
   newPFCNode->SetData(PFCOr);
 
   RemoveObservers();
   AddCompositeToDatastorage(newPFCNode, m_SelectedPF);
   m_SelectedPF.clear();
   m_SelectedPF.push_back(newPFCNode);
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::GenerateNotComposite()
 {
   mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
   PFCNot->setOperationType(mitk::PlanarFigureComposite::NOT);
 
   mitk::DataNode::Pointer newPFCNode;
   newPFCNode = mitk::DataNode::New();
   newPFCNode->SetName("NOT");
   newPFCNode->SetData(PFCNot);
 
   RemoveObservers();
   AddCompositeToDatastorage(newPFCNode, m_SelectedPF);
   m_SelectedPF.clear();
   m_SelectedPF.push_back(newPFCNode);
   AddObservers();
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::AddCompositeToDatastorage(mitk::DataNode::Pointer pfc, std::vector<mitk::DataNode::Pointer> children, mitk::DataNode::Pointer parentNode )
 {
   pfc->SetSelected(true);
   if (parentNode.IsNotNull())
     GetDataStorage()->Add(pfc, parentNode);
   else
     GetDataStorage()->Add(pfc);
 
   for (auto child : children)
   {
     if (dynamic_cast<PlanarFigure*>(child->GetData()))
     {
       mitk::DataNode::Pointer newChild;
       newChild = mitk::DataNode::New();
       newChild->SetData(dynamic_cast<PlanarFigure*>(child->GetData()));
       newChild->SetName( child->GetName() );
       newChild->SetBoolProperty("planarfigure.3drendering", true);
       newChild->SetBoolProperty("planarfigure.3drendering.fill", true);
 
       GetDataStorage()->Add(newChild, pfc);
       GetDataStorage()->Remove(child);
     }
     else if (dynamic_cast<PlanarFigureComposite*>(child->GetData()))
     {
       mitk::DataNode::Pointer newChild;
       newChild = mitk::DataNode::New();
       newChild->SetData(dynamic_cast<PlanarFigureComposite*>(child->GetData()));
       newChild->SetName( child->GetName() );
 
       std::vector< mitk::DataNode::Pointer > grandChildVector;
       mitk::DataStorage::SetOfObjects::ConstPointer grandchildren = GetDataStorage()->GetDerivations(child);
       for( mitk::DataStorage::SetOfObjects::const_iterator it = grandchildren->begin(); it != grandchildren->end(); ++it )
         grandChildVector.push_back(*it);
 
       AddCompositeToDatastorage(newChild, grandChildVector, pfc);
       GetDataStorage()->Remove(child);
     }
   }
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::CopyBundles()
 {
   if ( m_SelectedFB.empty() ){
     QMessageBox::information( nullptr, "Warning", "Select at least one fiber bundle!");
     MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
     return;
   }
 
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     mitk::FiberBundle::Pointer newFib = fib->GetDeepCopy();
 
     node->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     name += "_copy";
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newFib);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
   }
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::JoinBundles()
 {
   if ( m_SelectedFB.size()<2 ){
     QMessageBox::information( nullptr, "Warning", "Select at least two fiber bundles!");
     MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
     return;
   }
 
   m_SelectedFB.at(0)->SetVisibility(false);
   mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
 
   std::vector< mitk::FiberBundle::Pointer > tractograms;
   for (unsigned int i=1; i<m_SelectedFB.size(); i++)
   {
     m_SelectedFB.at(i)->SetVisibility(false);
     tractograms.push_back(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData()));
   }
   newBundle = newBundle->AddBundles(tractograms);
 
   mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
   fbNode->SetData(newBundle);
   fbNode->SetName("Joined_Tractograms");
   fbNode->SetVisibility(true);
   GetDataStorage()->Add(fbNode);
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::SubstractBundles()
 {
   if ( m_SelectedFB.size()<2 ){
     QMessageBox::information( nullptr, "Warning", "Select at least two fiber bundles!");
     MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
     return;
   }
 
   mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
   m_SelectedFB.at(0)->SetVisibility(false);
   QString name("");
   name += QString(m_SelectedFB.at(0)->GetName().c_str());
   for (unsigned int i=1; i<m_SelectedFB.size(); i++)
   {
     newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData()));
     if (newBundle.IsNull())
       break;
     name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
     m_SelectedFB.at(i)->SetVisibility(false);
   }
   if (newBundle.IsNull())
   {
     QMessageBox::information(nullptr, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
     return;
   }
 
   mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
   fbNode->SetData(newBundle);
   fbNode->SetName(name.toStdString());
   fbNode->SetVisibility(true);
   GetDataStorage()->Add(fbNode);
   UpdateGui();
 }
 
 void QmitkFiberProcessingView::ResampleSelectedBundlesSpline()
 {
   double factor = this->m_Controls->m_SmoothFibersBox->value();
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->ResampleSpline(factor);
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ResampleSelectedBundlesLinear()
 {
   double factor = this->m_Controls->m_SmoothFibersBox->value();
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->ResampleLinear(factor);
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::CompressSelectedBundles()
 {
   double factor = this->m_Controls->m_ErrorThresholdBox->value();
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->Compress(factor);
     fib->ColorFibersByOrientation();
   }
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::DoImageColorCoding()
 {
   if (m_Controls->m_ColorMapBox->GetSelectedNode().IsNull())
   {
     QMessageBox::information(nullptr, "Bundle coloring aborted:", "No image providing the scalar values for coloring the selected bundle available.");
     return;
   }
 
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->ColorFibersByScalarMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()), m_Controls->m_FiberOpacityBox->isChecked(), m_Controls->m_NormalizeColorValues->isChecked());
   }
 
   if (auto renderWindowPart = this->GetRenderWindowPart())
   {
     renderWindowPart->RequestUpdate();
   }
 }
 
 
 void QmitkFiberProcessingView::DoCurvatureColorCoding()
 {
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->ColorFibersByCurvature(m_Controls->m_FiberOpacityBox->isChecked(), m_Controls->m_NormalizeColorValues->isChecked());
   }
 
   if (auto renderWindowPart = this->GetRenderWindowPart())
   {
     renderWindowPart->RequestUpdate();
   }
 }
 
 void QmitkFiberProcessingView::DoWeightColorCoding()
 {
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     fib->ColorFibersByFiberWeights(m_Controls->m_FiberOpacityBox->isChecked(), m_Controls->m_NormalizeColorValues->isChecked());
   }
 
   if (auto renderWindowPart = this->GetRenderWindowPart())
   {
     renderWindowPart->RequestUpdate();
   }
 }
 
 void QmitkFiberProcessingView::MirrorFibers()
 {
   unsigned int axis = this->m_Controls->m_MirrorFibersBox->currentIndex();
   for (auto node : m_SelectedFB)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
     if (m_SelectedImage.IsNotNull())
       fib->SetReferenceGeometry(m_SelectedImage->GetGeometry());
     fib->MirrorFibers(axis);
   }
 
 
   for (auto surf : m_SelectedSurfaces)
   {
     vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     for (int i=0; i<poly->GetNumberOfPoints(); i++)
     {
       double* point = poly->GetPoint(i);
       point[axis] *= -1;
       vtkNewPoints->InsertNextPoint(point);
     }
     poly->SetPoints(vtkNewPoints);
     surf->CalculateBoundingBox();
   }
 
   if (auto renderWindowPart = this->GetRenderWindowPart())
   {
     renderWindowPart->RequestUpdate();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.h
index 4651a3f7ed..0e56b555cf 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingView.h
@@ -1,200 +1,201 @@
 /*===================================================================
 
 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 QmitkFiberProcessingView_h
 #define QmitkFiberProcessingView_h
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkFiberProcessingViewControls.h"
 
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkSurface.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 
 /*!
 \brief View to process fiber bundles. Supplies methods to extract fibers from the bundle, fiber resampling, mirroring, join and subtract bundles and much more.
 */
 class QmitkFiberProcessingView : 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:
 
-  typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
+  typedef itk::Image< unsigned char, 3 >    ItkUCharImageType;
+  typedef itk::Image< float, 3 >            ItkFloatImageType;
 
   static const std::string VIEW_ID;
 
   QmitkFiberProcessingView();
   virtual ~QmitkFiberProcessingView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Sets the focus to an internal widget.
   ///
   virtual void SetFocus() override;
 
 protected slots:
 
   void OnDrawCircle();          ///< add circle interactors etc.
   void OnDrawPolygon();         ///< add circle interactors etc.
   void GenerateAndComposite();
   void GenerateOrComposite();
   void GenerateNotComposite();
 
   void CopyBundles();               ///< add copies of selected bundles to data storage
   void JoinBundles();               ///< merge selected fiber bundles
   void SubstractBundles();          ///< subtract bundle A from bundle B. Not commutative! Defined by order of selection.
   void GenerateRoiImage();          ///< generate binary image of selected planar figures.
 
   void Remove();
   void Extract();
   void Modify();
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
   void OnMaskExtractionChanged();
 
   virtual void AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *propertyKey = nullptr, mitk::BaseProperty *property = nullptr );
 
 protected:
 
   void MirrorFibers();              ///< mirror bundle on the specified plane
   void ResampleSelectedBundlesSpline();   ///<
   void ResampleSelectedBundlesLinear();   ///<
   void DoImageColorCoding();        ///< color fibers by selected scalar image
   void DoWeightColorCoding();        ///< color fibers by their respective weights
   void DoCurvatureColorCoding();    ///< color fibers by curvature
   void CompressSelectedBundles();   ///< remove points below certain error threshold
   void WeightFibers();
   void ApplyWeightThreshold();
 
   void RemoveWithMask(bool removeInside);
   void RemoveDir();
   void ApplyCurvatureThreshold();   ///< remove/split fibers with a too high curvature threshold
   void PruneBundle();               ///< remove too short/too long fibers
 
   void ExtractWithMask(bool onlyEnds, bool invert);
   void ExtractWithPlanarFigure(bool interactive=false);
 
   void OnEndInteraction();
 
   /// \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::QmitkFiberProcessingViewControls* m_Controls;
 
   /** Connection from VTK to ITK */
   template <typename VTK_Exporter, typename ITK_Importer>
       void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template <typename ITK_Exporter, typename VTK_Importer>
       void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalCalculateMaskFromPlanarFigure(
           itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalReorientImagePlane(
         const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex );
 
   int m_CircleCounter;                                      ///< used for data node naming
   int m_PolygonCounter;                                     ///< used for data node naming
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
   std::vector<mitk::DataNode::Pointer>  m_SelectedPF;       ///< selected planar figure nodes
   std::vector<mitk::Surface::Pointer>   m_SelectedSurfaces;
   mitk::Image::Pointer                  m_SelectedImage;
   mitk::Image::Pointer                  m_InternalImage;
   mitk::PlanarFigure::Pointer           m_PlanarFigure;
-  itkUCharImageType::Pointer            m_InternalImageMask3D;
-  itkUCharImageType::Pointer            m_PlanarFigureImage;
+  ItkUCharImageType::Pointer            m_InternalImageMask3D;
+  ItkUCharImageType::Pointer            m_PlanarFigureImage;
   float                                 m_UpsamplingFactor; ///< upsampling factor for all image generations
-  mitk::DataNode::Pointer               m_MaskImageNode;
+  mitk::DataNode::Pointer               m_RoiImageNode;
 
   unsigned int                          m_StartInteractionObserverTag;
   unsigned int                          m_EndInteractionObserverTag;
   mitk::DataNode::Pointer               m_InteractiveNode;
 
   void AddCompositeToDatastorage(mitk::DataNode::Pointer pfc, std::vector<mitk::DataNode::Pointer> children, mitk::DataNode::Pointer parentNode=nullptr);
   void debugPFComposition(mitk::PlanarFigureComposite::Pointer , int );
   void WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image);
   mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
   mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
   mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
   mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
 
   void NodeAdded( const mitk::DataNode* node ) override;
   void NodeRemoved(const mitk::DataNode* node) override;
   void RemoveObservers();
   void AddObservers();
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingViewControls.ui
index 627a3e8a96..3a3acd8ae6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberProcessingViewControls.ui
@@ -1,1505 +1,1515 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkFiberProcessingViewControls</class>
  <widget class="QWidget" name="QmitkFiberProcessingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>385</width>
     <height>684</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_3">
    <item row="1" column="0">
     <widget class="QToolBox" name="toolBoxx">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <property name="tabSpacing">
       <number>5</number>
      </property>
      <widget class="QWidget" name="page">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
-        <width>367</width>
-        <height>382</height>
+        <width>353</width>
+        <height>411</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Fiber Extraction</string>
       </attribute>
       <attribute name="toolTip">
        <string>Extract a fiber subset from the selected fiber bundle using manually placed planar figures as waypoints or binary regions of interest.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_14">
        <item row="5" column="0">
         <widget class="QCommandLinkButton" name="m_ExtractFibersButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Extract fibers passing through selected ROI or composite ROI. Select ROI and fiber bundle to execute.</string>
          </property>
          <property name="text">
           <string>Extract</string>
          </property>
         </widget>
        </item>
        <item row="6" column="0">
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_ExtactionFramePF">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_8">
           <property name="leftMargin">
            <number>9</number>
           </property>
           <property name="topMargin">
            <number>9</number>
           </property>
           <property name="rightMargin">
            <number>9</number>
           </property>
           <property name="bottomMargin">
            <number>9</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QFrame" name="m_PlanarFigureButtonsFrame_2">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimumSize">
              <size>
               <width>200</width>
               <height>0</height>
              </size>
             </property>
             <property name="maximumSize">
              <size>
               <width>16777215</width>
               <height>60</height>
              </size>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_5">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="1">
               <widget class="QCommandLinkButton" name="PFCompoORButton">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>60</width>
                  <height>16777215</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Create OR composition with selected ROIs.</string>
                </property>
                <property name="text">
                 <string>OR</string>
                </property>
               </widget>
              </item>
              <item row="0" column="3">
               <spacer name="horizontalSpacer_3">
                <property name="orientation">
                 <enum>Qt::Horizontal</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>40</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item row="0" column="2">
               <widget class="QCommandLinkButton" name="PFCompoNOTButton">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>60</width>
                  <height>16777215</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Create NOT composition from selected ROI.</string>
                </property>
                <property name="text">
                 <string>NOT</string>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QCommandLinkButton" name="PFCompoANDButton">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>60</width>
                  <height>16777215</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Create AND composition with selected ROIs.</string>
                </property>
                <property name="text">
                 <string>AND</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QFrame" name="m_PlanarFigureButtonsFrame">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimumSize">
              <size>
               <width>200</width>
               <height>0</height>
              </size>
             </property>
             <property name="maximumSize">
              <size>
               <width>16777215</width>
               <height>60</height>
              </size>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QPushButton" name="m_CircleButton">
                <property name="maximumSize">
                 <size>
                  <width>30</width>
                  <height>30</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Draw circular ROI. Select reference fiber bundle to execute.</string>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="icon">
                 <iconset resource="../../../org.mitk.gui.qt.diffusionimaging.fiberfox/resources/QmitkDiffusionImaging.qrc">
                  <normaloff>:/QmitkDiffusionImaging/circle.png</normaloff>:/QmitkDiffusionImaging/circle.png</iconset>
                </property>
                <property name="iconSize">
                 <size>
                  <width>32</width>
                  <height>32</height>
                 </size>
                </property>
                <property name="checkable">
                 <bool>false</bool>
                </property>
                <property name="flat">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <spacer name="horizontalSpacer">
                <property name="orientation">
                 <enum>Qt::Horizontal</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>40</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item row="0" column="1">
               <widget class="QPushButton" name="m_PolygonButton">
                <property name="maximumSize">
                 <size>
                  <width>30</width>
                  <height>30</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Draw polygonal ROI. Select reference fiber bundle to execute.</string>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="icon">
                 <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
                  <normaloff>:/QmitkDiffusionImaging/polygon.png</normaloff>:/QmitkDiffusionImaging/polygon.png</iconset>
                </property>
                <property name="iconSize">
                 <size>
                  <width>32</width>
                  <height>32</height>
                 </size>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="flat">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QCommandLinkButton" name="m_GenerateRoiImage">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>16777215</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="font">
              <font>
               <pointsize>11</pointsize>
              </font>
             </property>
             <property name="toolTip">
              <string>Generate a binary image containing all selected ROIs. Select at least one ROI (planar figure) and a reference fiber bundle or image.</string>
             </property>
             <property name="text">
              <string>Generate ROI Image</string>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCheckBox" name="m_InteractiveBox">
             <property name="text">
              <string>Interactive Extraction </string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QComboBox" name="m_ExtractionMethodBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Extract using planar figures</string>
           </property>
          </item>
          <item>
           <property name="text">
-           <string>Extract using binary ROI image</string>
+           <string>Extract using ROI image</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QFrame" name="m_MaskExtractionFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_19">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
-          <item row="3" column="0">
+          <item row="4" column="0">
            <widget class="QCheckBox" name="m_BothEnds">
             <property name="text">
              <string>Both ends</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_16">
+            <property name="text">
+             <string>Extract fibers:</string>
+            </property>
+           </widget>
+          </item>
           <item row="2" column="2">
            <widget class="QDoubleSpinBox" name="m_FiberExtractionFractionBox">
             <property name="maximum">
              <double>1.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
            </widget>
           </item>
-          <item row="0" column="0">
-           <widget class="QLabel" name="label_16">
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_17">
             <property name="text">
-             <string>Extract fibers:</string>
+             <string>Min. overlap:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="2">
            <widget class="QComboBox" name="m_ExtractionBoxMask">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <item>
              <property name="text">
-              <string>Ending in mask</string>
+              <string>Ending in ROI</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>Not ending in mask</string>
+              <string>Not ending in ROI</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>Passing mask</string>
+              <string>Passing ROI</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>Not passing mask</string>
+              <string>Not passing ROI</string>
              </property>
             </item>
            </widget>
           </item>
-          <item row="2" column="0">
-           <widget class="QLabel" name="label_17">
+          <item row="3" column="0">
+           <widget class="QCheckBox" name="m_InterpolateRoiBox">
             <property name="text">
-             <string>Min. overlap:</string>
+             <string>Interpolate ROI</string>
+            </property>
+            <property name="checked">
+             <bool>false</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_3">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>367</width>
         <height>408</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Fiber Removal</string>
       </attribute>
       <attribute name="toolTip">
        <string>Remove fibers that satisfy certain criteria from the selected bundle.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_4">
        <item row="3" column="0">
         <widget class="QFrame" name="m_RemoveCurvatureFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_11">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="2" column="2">
            <widget class="QCheckBox" name="m_RemoveCurvedFibersBox">
             <property name="toolTip">
              <string>If unchecked, the fiber exceeding the threshold will be split in two instead of removed.</string>
             </property>
             <property name="text">
              <string>Remove Fiber</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="2">
            <widget class="QFrame" name="frame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_12">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="verticalSpacing">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="label_8">
                <property name="text">
                 <string>Max. Angular Deviation:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <spacer name="horizontalSpacer_5">
                <property name="orientation">
                 <enum>Qt::Horizontal</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>40</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_CurvSpinBox">
                <property name="toolTip">
                 <string>Maximum angular deviation in degree</string>
                </property>
                <property name="maximum">
                 <double>180.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>30.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="label_14">
                <property name="text">
                 <string>Distance:</string>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_CurvDistanceSpinBox">
                <property name="toolTip">
                 <string>Distance in mm</string>
                </property>
                <property name="decimals">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <double>999.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>1.000000000000000</double>
                </property>
                <property name="value">
                 <double>10.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_RemoveDirectionFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_2">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="horizontalSpacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label">
             <property name="text">
              <string>X:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_3">
             <property name="text">
              <string>Y:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractDirX"/>
           </item>
           <item row="1" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractDirY"/>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="label_4">
             <property name="text">
              <string>Z:</string>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractDirZ"/>
           </item>
           <item row="3" column="0">
            <widget class="QLabel" name="label_5">
             <property name="text">
              <string>Angle:</string>
             </property>
            </widget>
           </item>
           <item row="3" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractAngle">
             <property name="toolTip">
              <string>Angular deviation threshold in degree</string>
             </property>
             <property name="decimals">
              <number>1</number>
             </property>
             <property name="maximum">
              <double>90.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>1.000000000000000</double>
             </property>
             <property name="value">
              <double>25.000000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QFrame" name="m_RemoveLengthFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_6">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="2">
            <spacer name="horizontalSpacer_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="0" column="1">
            <widget class="QSpinBox" name="m_PruneFibersMinBox">
             <property name="toolTip">
              <string>Minimum fiber length in mm</string>
             </property>
             <property name="minimum">
              <number>0</number>
             </property>
             <property name="maximum">
              <number>999999999</number>
             </property>
             <property name="value">
              <number>20</number>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_9">
             <property name="text">
              <string>Max. Length:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_7">
             <property name="text">
              <string>Min. Length:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QSpinBox" name="m_PruneFibersMaxBox">
             <property name="toolTip">
              <string>Maximum fiber length in mm</string>
             </property>
             <property name="minimum">
              <number>0</number>
             </property>
             <property name="maximum">
              <number>999999999</number>
             </property>
             <property name="value">
              <number>300</number>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QCommandLinkButton" name="m_RemoveButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Remove</string>
          </property>
         </widget>
        </item>
        <item row="6" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="0" column="0">
         <widget class="QComboBox" name="m_RemovalMethodBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Remove fibers in direction</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fibers by length</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fibers by curvature</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fiber parts outside mask</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fiber parts inside mask</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fibers by weight</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QFrame" name="m_RemoveByWeightFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_20">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QLabel" name="label_18">
             <property name="text">
              <string>Weight threshold:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QDoubleSpinBox" name="m_WeightThresholdBox">
             <property name="toolTip">
              <string>Only fibers with weight larger than this threshold are kept.</string>
             </property>
             <property name="decimals">
              <number>5</number>
             </property>
             <property name="maximum">
              <double>99999.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_4">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>367</width>
         <height>408</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Bundle Modification</string>
       </attribute>
       <attribute name="toolTip">
        <string>Modify the selected bundle with operations such as fiber resampling, FA coloring, etc.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_10">
        <item row="2" column="0">
         <widget class="QFrame" name="m_CompressFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_15">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label_10">
             <property name="text">
              <string>Error threshold in mm:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QDoubleSpinBox" name="m_ErrorThresholdBox">
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
             <property name="value">
              <double>0.100000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QFrame" name="m_MirrorFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_17">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QComboBox" name="m_MirrorFibersBox">
             <item>
              <property name="text">
               <string>Sagittal</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Coronal</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Axial</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_13">
             <property name="text">
              <string>Select direction:</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_ColorFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_16">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QCheckBox" name="m_FiberOpacityBox">
             <property name="toolTip">
              <string>If checked, the image values are not only used to color the fibers but are also used as opaxity values.</string>
             </property>
             <property name="text">
              <string>Values as opacity</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QmitkDataStorageComboBox" name="m_ColorMapBox"/>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_12">
             <property name="text">
              <string>Scalar map:</string>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QCheckBox" name="m_NormalizeColorValues">
             <property name="toolTip">
              <string>The values used to color the fibers are min-max normalized. If not checked, the values should be between 0 and 1. </string>
             </property>
             <property name="text">
              <string>Normalize values</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QComboBox" name="m_ModificationMethodBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Resample fibers (spline)</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Resample fibers (linear)</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Compress fibers</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Color fibers by scalar map (e.g. FA)</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Mirror fibers</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Weight bundle</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Color fibers by curvature</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Color fibers by fiber weights</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_SmoothFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_7">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QDoubleSpinBox" name="m_SmoothFibersBox">
             <property name="minimum">
              <double>0.010000000000000</double>
             </property>
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
             <property name="value">
              <double>1.000000000000000</double>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_11">
             <property name="text">
              <string>Point distance in mm:</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="7" column="0">
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="6" column="0">
         <widget class="QCommandLinkButton" name="m_ModifyButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Execute</string>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QFrame" name="m_BundleWeightFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_18">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label_15">
             <property name="text">
              <string>Weight:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QDoubleSpinBox" name="m_BundleWeightBox">
             <property name="decimals">
              <number>7</number>
             </property>
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
             <property name="value">
              <double>1.000000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_2">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>367</width>
         <height>165</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Bundle Operations</string>
       </attribute>
       <attribute name="toolTip">
        <string>Join, subtract or copy bundles.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_13">
        <item row="0" column="0">
         <widget class="QCommandLinkButton" name="m_SubstractBundles">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Returns all fibers contained in bundle X that are not contained in bundle Y (not commutative!). Select at least two fiber bundles to execute.</string>
          </property>
          <property name="text">
           <string>Substract</string>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="0" column="2">
         <widget class="QCommandLinkButton" name="m_JoinBundles">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Merge selected fiber bundles. Select at least two fiber bundles to execute.</string>
          </property>
          <property name="text">
           <string>Join</string>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QCommandLinkButton" name="m_CopyBundle">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Merge selected fiber bundles. Select at least two fiber bundles to execute.</string>
          </property>
          <property name="text">
           <string>Copy</string>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item row="0" column="0">
     <widget class="QGroupBox" name="m_InputData">
      <property name="title">
       <string>Please Select Input Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_9">
       <item row="0" column="1">
        <widget class="QLabel" name="m_FibLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="m_PfLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#969696;&quot;&gt;needed for extraction&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label_2">
         <property name="toolTip">
          <string>Input DTI</string>
         </property>
         <property name="text">
          <string>Fiber Bundle:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_6">
         <property name="toolTip">
          <string>Binary seed ROI. If not specified, the whole image area is seeded.</string>
         </property>
         <property name="text">
          <string>ROI:</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="3" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../org.mitk.gui.qt.diffusionimaging.fiberfox/resources/QmitkDiffusionImaging.qrc"/>
   <include location="../../resources/QmitkDiffusionImaging.qrc"/>
  </resources>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
index baf223d57c..62ebf80acf 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
@@ -1,310 +1,310 @@
 /*===================================================================
 
 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 <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 #include "QmitkTractometryView.h"
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImage.h>
 #include <mitkFiberBundle.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <QmitkChartWidget.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <berryIPreferences.h>
 #include <berryWorkbenchPlugin.h>
 #include <berryQtPreferences.h>
 #include <vtkLookupTable.h>
 #include <QClipboard>
 #include <boost/lexical_cast.hpp>
 
 const std::string QmitkTractometryView::VIEW_ID = "org.mitk.views.tractometry";
 using namespace mitk;
 
 QmitkTractometryView::QmitkTractometryView()
   : QmitkAbstractView()
   , m_Controls( nullptr )
 {
 
 }
 
 // Destructor
 QmitkTractometryView::~QmitkTractometryView()
 {
 
 }
 
 void QmitkTractometryView::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::QmitkTractometryViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->m_SamplingPointsBox, SIGNAL(valueChanged(int)), this, SLOT(UpdateGui()) );
     connect( m_Controls->m_StDevBox, SIGNAL(stateChanged(int)), this, SLOT(UpdateGui()) );
 
     mitk::TNodePredicateDataType<mitk::Image>::Pointer imageP = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateDimension::Pointer dimP = mitk::NodePredicateDimension::New(3);
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageBox->SetPredicate(mitk::NodePredicateAnd::New(imageP, dimP));
 
     this->m_Controls->m_ChartWidget->SetXAxisLabel("Tract position");
     this->m_Controls->m_ChartWidget->SetYAxisLabel("Image Value");
   }
 }
 
 void QmitkTractometryView::OnPageSuccessfullyLoaded()
 {
   berry::IPreferencesService* prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
   berry::IPreferences::Pointer m_StylePref = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
 
   QString styleName = m_StylePref->Get(berry::QtPreferences::QT_STYLE_NAME, "");
 
   if (styleName == ":/org.blueberry.ui.qt/darkstyle.qss")
   {
     this->m_Controls->m_ChartWidget->SetTheme(QmitkChartWidget::ChartStyle::darkstyle);
   }
   else
   {
     this->m_Controls->m_ChartWidget->SetTheme(QmitkChartWidget::ChartStyle::lightstyle);
   }
 }
 
 void QmitkTractometryView::SetFocus()
 {
 }
 
 void QmitkTractometryView::UpdateGui()
 {
   berry::IWorkbenchPart::Pointer nullPart;
   OnSelectionChanged(nullPart, QList<mitk::DataNode::Pointer>(m_CurrentSelection));
 }
 
 bool QmitkTractometryView::Flip(vtkSmartPointer< vtkPolyData > polydata1, int i, vtkSmartPointer< vtkPolyData > ref_poly)
 {
   float d_direct = 0;
   float d_flipped = 0;
 
   vtkCell* cell1 = polydata1->GetCell(0);
   if (ref_poly!=nullptr)
     cell1 = ref_poly->GetCell(0);
   int numPoints1 = cell1->GetNumberOfPoints();
   vtkPoints* points1 = cell1->GetPoints();
 
   vtkCell* cell2 = polydata1->GetCell(i);
   vtkPoints* points2 = cell2->GetPoints();
 
   for (int j=0; j<numPoints1; ++j)
   {
     double* p1 = points1->GetPoint(j);
     double* p2 = points2->GetPoint(j);
     d_direct = (p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]) + (p1[2]-p2[2])*(p1[2]-p2[2]);
 
     double* p3 = points2->GetPoint(numPoints1-j-1);
     d_flipped = (p1[0]-p3[0])*(p1[0]-p3[0]) + (p1[1]-p3[1])*(p1[1]-p3[1]) + (p1[2]-p3[2])*(p1[2]-p3[2]);
   }
 
   if (d_direct>d_flipped)
     return true;
   return false;
 }
 
 template <typename TPixel>
 void QmitkTractometryView::ImageValuesAlongTract(const mitk::PixelType, mitk::Image::Pointer image, mitk::FiberBundle::Pointer fib, std::vector<std::vector<double> > &data, std::string& clipboard_string)
 {
   int num_points = m_Controls->m_SamplingPointsBox->value();
   mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
   mitk::FiberBundle::Pointer working_fib = fib->GetDeepCopy();
   working_fib->ResampleToNumPoints(num_points);
   vtkSmartPointer< vtkPolyData > polydata = working_fib->GetFiberPolyData();
 
   std::vector<std::vector<double> > all_values;
   std::vector< double > mean_values;
   for (int i=0; i<num_points; ++i)
     mean_values.push_back(0);
 
   double min = 100000;
   double max = 0;
   double mean = 0;
   for (int i=0; i<working_fib->GetNumFibers(); ++i)
   {
     vtkCell* cell = polydata->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     std::vector< double > fib_vals;
 
     bool flip = false;
     if (i>0)
       flip = Flip(polydata, i);
     else if (m_ReferencePolyData!=nullptr)
       flip = Flip(polydata, 0, m_ReferencePolyData);
 
     for (int j=0; j<numPoints; j++)
     {
       double* p;
       if (flip)
         p = points->GetPoint(numPoints - j - 1);
       else
         p = points->GetPoint(j);
 
       Point3D px;
       px[0] = p[0];
       px[1] = p[1];
       px[2] = p[2];
       double pixelValue = readimage.GetPixelByWorldCoordinates(px);
       fib_vals.push_back(pixelValue);
       mean += pixelValue;
       if (pixelValue<min)
         min = pixelValue;
       else if (pixelValue>max)
         max = pixelValue;
 
       mean_values.at(j) += pixelValue;
     }
 
     all_values.push_back(fib_vals);
   }
 
   if (m_ReferencePolyData==nullptr)
     m_ReferencePolyData = polydata;
 
   std::vector< double > std_values1;
   std::vector< double > std_values2;
   for (int i=0; i<num_points; ++i)
   {
     mean_values.at(i) /= working_fib->GetNumFibers();
     double stdev = 0;
 
     for (unsigned int j=0; j<all_values.size(); ++j)
     {
       double diff = mean_values.at(i) - all_values.at(j).at(i);
       diff *= diff;
       stdev += diff;
     }
     stdev /= all_values.size();
     stdev = std::sqrt(stdev);
-    std_values1.push_back(mean_values.at(i) + stdev/2);
-    std_values2.push_back(mean_values.at(i) - stdev/2);
+    std_values1.push_back(mean_values.at(i) + stdev);
+    std_values2.push_back(mean_values.at(i) - stdev);
 
     clipboard_string += boost::lexical_cast<std::string>(mean_values.at(i));
     clipboard_string += " ";
     clipboard_string += boost::lexical_cast<std::string>(stdev);
     clipboard_string += "\n";
   }
   clipboard_string += "\n";
 
   data.push_back(mean_values);
   data.push_back(std_values1);
   data.push_back(std_values2);
 
   MITK_INFO << "Min: " << min;
   MITK_INFO << "Max: " << max;
   MITK_INFO << "Mean: " << mean/working_fib->GetNumberOfPoints();
 }
 
 std::string QmitkTractometryView::RGBToHexString(double *rgb)
 {
   std::ostringstream os;
   for (int i = 0; i < 3; ++i)
     {
     os << std::setw(2) << std::setfill('0') << std::hex
        << static_cast<int>(rgb[i] * 255);
     }
   return os.str();
 }
 
 void QmitkTractometryView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   m_CurrentSelection.clear();
   if(m_Controls->m_ImageBox->GetSelectedNode().IsNull())
     return;
 
   std::string clipboardString = "";
   m_ReferencePolyData = nullptr;
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData());
 
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetTableRange(0.0, 1.0);
   lookupTable->Build();
 
   int num_tracts = 0;
   for (auto node: nodes)
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
       num_tracts++;
 
   int c = 1;
   this->m_Controls->m_ChartWidget->Clear();
   for (auto node: nodes)
   {
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
     {
       clipboardString += node->GetName() + "\n";
       clipboardString += "mean stdev\n";
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
       m_CurrentSelection.push_back(node);
 
       std::vector< std::vector< double > > data;
       mitkPixelTypeMultiplex4( ImageValuesAlongTract, image->GetPixelType(), image, fib, data, clipboardString );
 
       m_Controls->m_ChartWidget->AddData1D(data.at(0), node->GetName() + " Mean", QmitkChartWidget::ChartType::line);
       if (m_Controls->m_StDevBox->isChecked())
       {
         this->m_Controls->m_ChartWidget->AddData1D(data.at(1), node->GetName() + " +STDEV", QmitkChartWidget::ChartType::line);
         this->m_Controls->m_ChartWidget->AddData1D(data.at(2), node->GetName() + " -STDEV", QmitkChartWidget::ChartType::line);
       }
 
       double color[3];
       if (num_tracts>1)
       {
         float scalar_color = ( (float)c/num_tracts - 1.0/num_tracts )/(1.0-1.0/num_tracts);
         lookupTable->GetColor(1.0 - scalar_color, color);
       }
       else
         lookupTable->GetColor(0, color);
 
       this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " Mean", RGBToHexString(color));
 
       if (m_Controls->m_StDevBox->isChecked())
       {
         color[0] *= 0.8;
         color[1] *= 0.8;
         color[2] *= 0.8;
         this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " +STDEV", RGBToHexString(color));
         this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " -STDEV", RGBToHexString(color));
       }
 
       this->m_Controls->m_ChartWidget->Show(true);
       this->m_Controls->m_ChartWidget->SetShowDataPoints(false);
       ++c;
     }
   }
 
   QApplication::clipboard()->setText(clipboardString.c_str(), QClipboard::Clipboard);
 
 }
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 be53ab681c..b33d3b55eb 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,859 +1,838 @@
 /*===================================================================
 
 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 <mitkOdfImage.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 <itkTensorImageToOdfImageFilter.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_TargetImageBox->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->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_SeedImageBox->SetZeroEntryText("--");
-    m_Controls->m_MaskImageBox->SetPredicate( mitk::NodePredicateAnd::New(isBinaryPredicate, dimensionPredicate) );
+    m_Controls->m_MaskImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_MaskImageBox->SetZeroEntryText("--");
-    m_Controls->m_StopImageBox->SetPredicate( mitk::NodePredicateAnd::New(isBinaryPredicate, dimensionPredicate) );
+    m_Controls->m_StopImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_StopImageBox->SetZeroEntryText("--");
-    m_Controls->m_TargetImageBox->SetPredicate( dimensionPredicate );
+    m_Controls->m_TargetImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_TargetImageBox->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_TargetImageBox, 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_MaskInterpolationBox, 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()) );
 
     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_ParentNode->GetData())->GetGeometry());
     if (m_Controls->m_ResampleFibersBox->isChecked() && fiberBundle->GetNumberOfLines()>0)
       fib->Compress(m_Controls->m_FiberErrorBox->value());
     fib->ColorFibersByOrientation();
     m_Tracker->SetDicomProperties(fib);
 
     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_ParentNode->GetName().c_str();
       name += "_Streamline";
       node->SetName(name.toStdString());
       GetDataStorage()->Add(node, m_ParentNode);
     }
   }
   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_ParentNode->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_ParentNode);
     }
   }
   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();
 
   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);
 
 
     m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
     connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
   }
   else
   {
     QApplication::restoreOverrideCursor();
     QApplication::processEvents();
 
     m_InteractiveNode = nullptr;
     m_InteractivePointSetNode = nullptr;
 
     m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
     disconnect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
   }
 }
 
 void QmitkStreamlineTrackingView::OnSliceChanged()
 {
   InteractiveSeedChanged(true);
 }
 
 void QmitkStreamlineTrackingView::SetFocus()
 {
 }
 
 void QmitkStreamlineTrackingView::DeleteTrackingHandler()
 {
   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();
   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::OdfImage*>(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();
   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( ( std::to_string(m_InputImageNodes.size()) + " images selected").c_str() );
     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::OdfImage*>(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 mitk::ImageToItk<mitk::TensorImage::ItkTensorImageType> 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();
         mitk::TensorImage::ItkTensorImageType::Pointer itkImg = mitk::TensorImage::ItkTensorImageType::New();
         mitk::CastToItkImage(m_InputImages.at(0), itkImg);
 
         typedef itk::TensorImageToOdfImageFilter< 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);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetIsOdfFromTensor(true);
     }
     else
     {
       if (m_TrackingHandler==nullptr)
       {
         m_TrackingHandler = new mitk::TrackingHandlerTensor();
         for (int i=0; i<(int)m_InputImages.size(); i++)
         {
           typedef mitk::ImageToItk< mitk::TrackingHandlerTensor::ItkTensorImageType > CasterType;
           CasterType::Pointer caster = CasterType::New();
           caster->SetInput(m_InputImages.at(i));
           caster->Update();
           mitk::TrackingHandlerTensor::ItkTensorImageType::ConstPointer itkImg = caster->GetOutput();
 
           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::OdfImage*>(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 (raw dMRI tractography) selected. Did you accidentally select the raw diffusion-weighted image in the datamanager?");
       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(...)
     {
       QMessageBox::information(nullptr, "Error", "Peak tracker could not be initialized. Is your input image in the correct format (4D float image, peaks in the 4th dimension)?");
       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();
+    ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_SeedImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetSeedImage(mask);
   }
 
   m_Tracker->SetInterpolateMask(false);
   if (m_Controls->m_MaskImageBox->GetSelectedNode().IsNotNull())
   {
-    ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
+    ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_MaskImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetMaskImage(mask);
     m_Tracker->SetInterpolateMask(m_Controls->m_MaskInterpolationBox->isChecked());
   }
 
   if (m_Controls->m_StopImageBox->GetSelectedNode().IsNotNull())
   {
-    ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
+    ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_StopImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetStoppingRegions(mask);
   }
 
   if (m_Controls->m_TargetImageBox->GetSelectedNode().IsNotNull())
   {
-    ItkUintImgType::Pointer mask = ItkUintImgType::New();
+    ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_TargetImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetTargetRegions(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_ParentNode = m_InputImageNodes.at(0);
   m_TrackingThread.start(QThread::LowestPriority);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
index 83ee13c09d..ff66c862a0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
@@ -1,1169 +1,1131 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkStreamlineTrackingViewControls</class>
  <widget class="QWidget" name="QmitkStreamlineTrackingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>413</width>
     <height>1385</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QFormLayout" name="formLayout">
    <property name="horizontalSpacing">
     <number>0</number>
    </property>
    <property name="verticalSpacing">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>3</number>
    </property>
    <property name="bottomMargin">
     <number>3</number>
    </property>
    <item row="0" column="0" colspan="2">
     <widget class="QGroupBox" name="m_InputData">
      <property name="title">
       <string>Please Select Input Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
-      <item row="6" column="1">
-       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_TissueImageBox">
+      <item row="7" column="1">
+       <widget class="QmitkDataStorageComboBox" name="m_ForestBox">
         <property name="toolTip">
-         <string>Tissue label image needed for gray matter seeding (WM=3, GM=1). Use e.g. MRtrix 5ttgen to generate such a label image.</string>
+         <string>Random forest for machine learning based tractography.</string>
         </property>
         <property name="sizeAdjustPolicy">
          <enum>QComboBox::AdjustToMinimumContentsLength</enum>
         </property>
         <item>
          <property name="text">
           <string>-</string>
          </property>
         </item>
        </widget>
       </item>
-      <item row="6" column="0">
-       <widget class="QLabel" name="label_10">
+      <item row="5" column="0">
+       <widget class="QLabel" name="label_9">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
-         <string>Tissue Image:</string>
+         <string>Stop Image:</string>
         </property>
        </widget>
       </item>
-      <item row="8" column="0">
-       <widget class="QLabel" name="m_ForestLabel">
+      <item row="5" column="1">
+       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_StopImageBox">
         <property name="toolTip">
-         <string/>
+         <string>Fibers that enter a region defined in this image will stop immediately.</string>
         </property>
-        <property name="text">
-         <string>Tractography Forest:</string>
+        <property name="sizeAdjustPolicy">
+         <enum>QComboBox::AdjustToMinimumContentsLength</enum>
         </property>
+        <item>
+         <property name="text">
+          <string>-</string>
+         </property>
+        </item>
        </widget>
       </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="label_6">
+      <item row="0" column="1">
+       <widget class="QLabel" name="m_TensorImageLabel">
         <property name="toolTip">
-         <string/>
+         <string>Input Image. ODF, tensor, peak, and, in case of ML tractography, raw diffusion-weighted images are currently supported.</string>
         </property>
         <property name="text">
-         <string>Seed Image:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_2">
-        <property name="toolTip">
-         <string>Input Image. ODF, tensor and peak images are currently supported.</string>
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
-        <property name="text">
-         <string>Input Image:</string>
+        <property name="wordWrap">
+         <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_MaskImageBox">
         <property name="toolTip">
          <string>Tractography is only performed inside the mask image. Fibers that leave the mask image are stopped.</string>
         </property>
         <property name="sizeAdjustPolicy">
          <enum>QComboBox::AdjustToMinimumContentsLength</enum>
         </property>
         <item>
          <property name="text">
           <string>-</string>
          </property>
         </item>
        </widget>
       </item>
-      <item row="5" column="1">
-       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_StopImageBox">
-        <property name="toolTip">
-         <string>Fibers that enter a region defined in this image will stop immediately.</string>
-        </property>
-        <property name="sizeAdjustPolicy">
-         <enum>QComboBox::AdjustToMinimumContentsLength</enum>
-        </property>
-        <item>
-         <property name="text">
-          <string>-</string>
-         </property>
-        </item>
-       </widget>
-      </item>
-      <item row="7" column="0">
-       <widget class="QLabel" name="mFaImageLabel">
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_7">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
-         <string>FA/GFA Image:</string>
+         <string>Mask Image:</string>
         </property>
        </widget>
       </item>
-      <item row="8" column="1">
-       <widget class="QmitkDataStorageComboBox" name="m_ForestBox">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_2">
         <property name="toolTip">
-         <string>Random forest for machine learning based tractography.</string>
+         <string>Input Image. ODF, tensor and peak images are currently supported.</string>
         </property>
-        <property name="sizeAdjustPolicy">
-         <enum>QComboBox::AdjustToMinimumContentsLength</enum>
+        <property name="text">
+         <string>Input Image:</string>
         </property>
-        <item>
-         <property name="text">
-          <string>-</string>
-         </property>
-        </item>
        </widget>
       </item>
-      <item row="7" column="1">
+      <item row="6" column="1">
        <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_FaImageBox">
         <property name="toolTip">
          <string>If an image is selected, the stopping criterion is not calculated from the input image but instead the selected image is used.</string>
         </property>
         <property name="sizeAdjustPolicy">
          <enum>QComboBox::AdjustToMinimumContentsLength</enum>
         </property>
         <item>
          <property name="text">
           <string>-</string>
          </property>
         </item>
        </widget>
       </item>
-      <item row="5" column="0">
-       <widget class="QLabel" name="label_9">
+      <item row="4" column="0">
+       <widget class="QLabel" name="label_11">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
-         <string>Stop Image:</string>
+         <string>Target Image:</string>
         </property>
        </widget>
       </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="label_7">
+      <item row="6" column="0">
+       <widget class="QLabel" name="mFaImageLabel">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
-         <string>Mask Image:</string>
+         <string>FA/GFA Image:</string>
         </property>
        </widget>
       </item>
-      <item row="1" column="1">
-       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_SeedImageBox">
+      <item row="4" column="1">
+       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_TargetImageBox">
         <property name="toolTip">
-         <string>Seed points are only placed inside the mask image. If no seed mask is selected, the whole image is seeded.</string>
+         <string>Fibers that do not start and end in a region defined in this image will be discarded.</string>
         </property>
         <property name="sizeAdjustPolicy">
          <enum>QComboBox::AdjustToMinimumContentsLength</enum>
         </property>
         <item>
          <property name="text">
           <string>-</string>
          </property>
         </item>
        </widget>
       </item>
-      <item row="0" column="1">
-       <widget class="QLabel" name="m_TensorImageLabel">
-        <property name="toolTip">
-         <string>Input Image. ODF, tensor, peak, and, in case of ML tractography, raw diffusion-weighted images are currently supported.</string>
-        </property>
-        <property name="text">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="wordWrap">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="4" column="0">
-       <widget class="QLabel" name="label_11">
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_6">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
-         <string>Target Image:</string>
+         <string>Seed Image:</string>
         </property>
        </widget>
       </item>
-      <item row="4" column="1">
-       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_TargetImageBox">
+      <item row="1" column="1">
+       <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_SeedImageBox">
         <property name="toolTip">
-         <string>Fibers that do not start and end in a region defined in this image will be discarded.</string>
+         <string>Seed points are only placed inside the mask image. If no seed mask is selected, the whole image is seeded.</string>
         </property>
         <property name="sizeAdjustPolicy">
          <enum>QComboBox::AdjustToMinimumContentsLength</enum>
         </property>
         <item>
          <property name="text">
           <string>-</string>
          </property>
         </item>
        </widget>
       </item>
+      <item row="7" column="0">
+       <widget class="QLabel" name="m_ForestLabel">
+        <property name="toolTip">
+         <string/>
+        </property>
+        <property name="text">
+         <string>Tractography Forest:</string>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QCommandLinkButton" name="commandLinkButton">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="text">
       <string>Start Tractography</string>
      </property>
     </widget>
    </item>
    <item row="4" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox_3">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Interactive Tractography</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="3" column="1">
        <widget class="QSpinBox" name="m_NumSeedsBox">
         <property name="toolTip">
          <string>Number of seed points normally distributed around selected position.</string>
         </property>
         <property name="minimum">
          <number>1</number>
         </property>
         <property name="maximum">
          <number>9999999</number>
         </property>
         <property name="value">
          <number>50</number>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="m_SeedsPerVoxelLabel_4">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Num. Seeds:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QCheckBox" name="m_InteractiveBox">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="toolTip">
          <string>Dynamically pick seed location by click into image.</string>
         </property>
         <property name="text">
          <string>Enable Interactive Tractography</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QDoubleSpinBox" name="m_SeedRadiusBox">
         <property name="toolTip">
          <string>Seedpoints are normally distributed within a sphere centered at the selected position with the specified radius (in mm).</string>
         </property>
         <property name="decimals">
          <number>2</number>
         </property>
         <property name="maximum">
          <double>50.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
         <property name="value">
          <double>2.500000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="m_FaThresholdLabel_4">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Radius:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QCheckBox" name="m_ParamUpdateBox">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="toolTip">
          <string>When checked, parameter changes cause instant retracking while in interactive mode.</string>
         </property>
         <property name="text">
          <string>Update on Parameter Change</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="5" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox_2">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Parameters</string>
      </property>
      <layout class="QFormLayout" name="formLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="m_FaThresholdLabel_3">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Mode:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QComboBox" name="m_ModeBox">
         <property name="toolTip">
          <string>Toggle between deterministic and probabilistic tractography. Some modes might not be available for all types of tractography.</string>
         </property>
         <item>
          <property name="text">
           <string>Deterministic</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Probabilistic</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="m_SeedsPerVoxelLabel">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Seeds per Voxel:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QSpinBox" name="m_SeedsPerVoxelBox">
         <property name="toolTip">
          <string>Number of seed points placed in each voxel. </string>
         </property>
         <property name="minimum">
          <number>1</number>
         </property>
         <property name="maximum">
          <number>9999999</number>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="m_FaThresholdLabel_2">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Max. num. fibers:</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QSpinBox" name="m_NumFibersBox">
         <property name="toolTip">
          <string>Tractography is stopped after the desired number of fibers is reached, even before all seed points are processed.</string>
         </property>
         <property name="minimum">
          <number>-1</number>
         </property>
         <property name="maximum">
          <number>999999999</number>
         </property>
         <property name="value">
          <number>-1</number>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="m_FaThresholdLabel">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Cutoff:</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QDoubleSpinBox" name="m_ScalarThresholdBox">
         <property name="toolTip">
          <string>Threshold on peak magnitude, FA, GFA, ...</string>
         </property>
         <property name="decimals">
          <number>5</number>
         </property>
         <property name="maximum">
          <double>1.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
         <property name="value">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QLabel" name="m_OdfCutoffLabel">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>ODF Cutoff:</string>
         </property>
        </widget>
       </item>
       <item row="4" column="1">
        <widget class="QDoubleSpinBox" name="m_OdfCutoffBox">
         <property name="toolTip">
          <string>Additional threshold on the ODF magnitude. This is useful in case of CSD fODF tractography.</string>
         </property>
         <property name="decimals">
          <number>5</number>
         </property>
         <property name="maximum">
          <double>1.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
         <property name="value">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QCheckBox" name="m_SharpenOdfsBox">
         <property name="toolTip">
          <string>If you are using dODF images as input, it is advisable to sharpen the ODFs (min-max normalize and raise to the power of 4). This is not necessary for CSD fODFs, since they are naturally much sharper.</string>
         </property>
         <property name="text">
          <string>Sharpen ODFs</string>
         </property>
        </widget>
       </item>
       <item row="6" column="0">
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>200</width>
           <height>0</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
    <item row="6" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Advanced Parameters</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_5">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0" colspan="2">
        <widget class="QFrame" name="frame_2">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_3">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <item row="2" column="0">
           <widget class="QLabel" name="m_MinTractLengthLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Min. Tract Length:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_StepSizeBox">
            <property name="toolTip">
             <string>Step size (in voxels)</string>
            </property>
            <property name="decimals">
             <number>2</number>
            </property>
            <property name="minimum">
             <double>0.010000000000000</double>
            </property>
            <property name="maximum">
             <double>10.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>0.500000000000000</double>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="m_AngularThresholdLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Angular Threshold:</string>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="m_SeedsPerVoxelLabel_3">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Flip directions:</string>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QDoubleSpinBox" name="m_fBox">
            <property name="toolTip">
             <string>f=1 + g=0 means FACT (depending on the chosen interpolation). f=0 and g=1 means TEND (disable interpolation for this mode!).</string>
            </property>
            <property name="decimals">
             <number>2</number>
            </property>
            <property name="maximum">
             <double>1.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>1.000000000000000</double>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="m_fLabel">
            <property name="toolTip">
             <string>f parameter of tensor tractography. f=1 + g=0 means FACT (depending on the chosen interpolation). f=0 and g=1 means TEND (disable interpolation for this mode!).</string>
            </property>
            <property name="text">
             <string>f:</string>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="m_gLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>g:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="QDoubleSpinBox" name="m_MinTractLengthBox">
            <property name="toolTip">
             <string>Shorter fibers are discarded.</string>
            </property>
            <property name="statusTip">
             <string>Minimum fiber length (in mm)</string>
            </property>
            <property name="decimals">
             <number>1</number>
            </property>
            <property name="maximum">
             <double>999.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>1.000000000000000</double>
            </property>
            <property name="value">
             <double>20.000000000000000</double>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <widget class="QFrame" name="frame">
            <property name="frameShape">
             <enum>QFrame::NoFrame</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Raised</enum>
            </property>
            <layout class="QGridLayout" name="gridLayout_4">
             <property name="leftMargin">
              <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
             </property>
             <property name="rightMargin">
              <number>0</number>
             </property>
             <property name="bottomMargin">
              <number>0</number>
             </property>
             <item row="0" column="0">
              <widget class="QCheckBox" name="m_FlipXBox">
               <property name="toolTip">
                <string>Internally flips progression directions. This might be necessary depending on the input data.</string>
               </property>
               <property name="text">
                <string>x</string>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="QCheckBox" name="m_FlipYBox">
               <property name="toolTip">
                <string>Internally flips progression directions. This might be necessary depending on the input data.</string>
               </property>
               <property name="text">
                <string>y</string>
               </property>
              </widget>
             </item>
             <item row="0" column="2">
              <widget class="QCheckBox" name="m_FlipZBox">
               <property name="toolTip">
                <string>Internally flips progression directions. This might be necessary depending on the input data.</string>
               </property>
               <property name="text">
                <string>z</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="m_StepsizeLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Step Size:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QSpinBox" name="m_AngularThresholdBox">
            <property name="toolTip">
             <string>Default: 90° * step_size</string>
            </property>
            <property name="minimum">
             <number>-1</number>
            </property>
            <property name="maximum">
             <number>90</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>-1</number>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="QDoubleSpinBox" name="m_gBox">
            <property name="toolTip">
             <string>f=1 + g=0 means FACT (depending on the chosen interpolation). f=0 and g=1 means TEND (disable interpolation for this mode!).</string>
            </property>
            <property name="decimals">
             <number>2</number>
            </property>
            <property name="maximum">
             <double>1.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>0.000000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="2" column="0" colspan="2">
        <widget class="QFrame" name="frame_3">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_7">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="m_SeedGmBox">
-           <property name="toolTip">
-            <string>Requires tissue image.</string>
-           </property>
-           <property name="text">
-            <string>Enable Gray Matter Seeding</string>
-           </property>
-           <property name="checked">
-            <bool>false</bool>
-           </property>
-          </widget>
-         </item>
          <item row="0" column="0">
           <widget class="QCheckBox" name="m_InterpolationBox">
            <property name="toolTip">
             <string>If false, nearest neighbor interpolation is used.</string>
            </property>
            <property name="text">
             <string>Interpolate Tractography Data</string>
            </property>
            <property name="checked">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QCheckBox" name="m_MaskInterpolationBox">
            <property name="toolTip">
             <string>The tractography mask is not interpolated by default.</string>
            </property>
            <property name="text">
-            <string>Interpolate Mask Image</string>
+            <string>Interpolate ROI Images</string>
            </property>
            <property name="checked">
-            <bool>false</bool>
+            <bool>true</bool>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="7" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox_4">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Neighborhood Sampling</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_6">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0">
        <widget class="QFrame" name="frame_4">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_10">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="m_SeedsPerVoxelLabel_2">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Num. Samples:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QSpinBox" name="m_NumSamplesBox">
            <property name="toolTip">
             <string>Number of neighborhood samples that are used to determine the next fiber progression direction.</string>
            </property>
            <property name="maximum">
             <number>50</number>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="m_SamplingDistanceLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Sampling Distance:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QDoubleSpinBox" name="m_SamplingDistanceBox">
            <property name="toolTip">
             <string>Sampling distance (in voxels)</string>
            </property>
            <property name="decimals">
             <number>2</number>
            </property>
            <property name="maximum">
             <double>10.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>0.250000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QCheckBox" name="m_FrontalSamplesBox">
         <property name="toolTip">
          <string>Only neighborhood samples in front of the current streamline position are considered.</string>
         </property>
         <property name="text">
          <string>Use Only Frontal Samples</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QCheckBox" name="m_StopVotesBox">
         <property name="toolTip">
          <string>If checked, the majority of sampling points has to place a stop-vote for the streamline to terminate. If not checked, all sampling positions have to vote for a streamline termination.</string>
         </property>
         <property name="text">
          <string>Use Stop-Votes</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="9" column="0">
     <spacer name="spacer1">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>220</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="8" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox_5">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Output and Postprocessing</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_9">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0">
        <widget class="QFrame" name="frame_5">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_8">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <item row="0" column="0">
           <widget class="QCheckBox" name="m_ResampleFibersBox">
            <property name="toolTip">
             <string>Resample fibers using the specified error constraint.</string>
            </property>
            <property name="text">
             <string>Compress Fibers</string>
            </property>
            <property name="checked">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_FiberErrorBox">
            <property name="focusPolicy">
             <enum>Qt::StrongFocus</enum>
            </property>
            <property name="toolTip">
             <string>Lossy fiber compression. Recommended for large tractograms. Maximum error in mm.</string>
            </property>
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="maximum">
             <double>10.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
            <property name="value">
             <double>0.100000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QCheckBox" name="m_OutputProbMap">
         <property name="toolTip">
          <string>Output probability map instead of tractogram.</string>
         </property>
         <property name="text">
          <string>Output Probability Map</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QCommandLinkButton" name="commandLinkButton_2">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="text">
       <string>Stop Tractography</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0" colspan="2">
     <widget class="QTextEdit" name="m_StatusTextBox">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="readOnly">
       <bool>true</bool>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkDataStorageComboBoxWithSelectNone</class>
    <extends>QComboBox</extends>
    <header>QmitkDataStorageComboBoxWithSelectNone.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>