diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h
index 7faaf59f6c..010510ed15 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetric.h
@@ -1,61 +1,59 @@
 /*===================================================================
 
 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 <MitkFiberTrackingExports.h>
-
 namespace mitk
 {
 
 /**
 * \brief Base class for fiber clustering metrics  */
 
-class MITKFIBERTRACKING_EXPORT ClusteringMetric
+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/mitkClusteringMetricAnatomic.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricAnatomic.h
index cb8be80db4..8603078662 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricAnatomic.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricAnatomic.h
@@ -1,199 +1,199 @@
 /*===================================================================
 
 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 _ClusteringMetricAnatomic
 #define _ClusteringMetricAnatomic
 
 #include <mitkClusteringMetric.h>
 #include <itkImage.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkNumericTraits.h>
 
 namespace mitk
 {
 
 /**
 * \brief Fiber clustering metric based on white matter parcellation histograms along the tracts (Siless et al. https://www.ncbi.nlm.nih.gov/pubmed/29100937) */
 
-class MITKFIBERTRACKING_EXPORT ClusteringMetricAnatomic : public ClusteringMetric
+class ClusteringMetricAnatomic : public ClusteringMetric
 {
 
 public:
 
   typedef itk::Image<short, 3>  ItkShortImgType;
 
   ClusteringMetricAnatomic()
     : m_Radius(1)
   {}
   virtual ~ClusteringMetricAnatomic(){}
 
   float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped)
   {
     vnl_matrix<float> hist1; hist1.set_size( (2*m_Radius+1)*(2*m_Radius+1)*(2*m_Radius+1), m_NumLabels ); hist1.fill(0);
     vnl_matrix<float> hist2; hist2.set_size( (2*m_Radius+1)*(2*m_Radius+1)*(2*m_Radius+1), m_NumLabels ); hist2.fill(0);
 
 
     float d_direct = 0;
     float d_flipped = 0;
 
     vnl_vector<float> dists_d; dists_d.set_size(s.cols());
     vnl_vector<float> dists_f; dists_f.set_size(s.cols());
 
     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];
       GetHistogramAtPoint(p, hist1);
 
       p[0] = t[0][i];
       p[1] = t[1][i];
       p[2] = t[2][i];
       GetHistogramAtPoint(p, hist2);
 
       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();
     }
 
 //    float eudist = 0;
     if (d_direct>d_flipped)
     {
       flipped = true;
 //      eudist = d_flipped/s.cols();
     }
     else
     {
       flipped = false;
 //      eudist = d_direct/s.cols();
     }
 
     float label_intersection = 0;
     for (unsigned int c=0; c<hist1.cols(); ++c)
     {
       bool l1 = false;
       bool l2 = false;
       for (unsigned int r=0; r<hist1.rows(); ++r)
       {
         if (hist1[r][c]>0)
           l1 = true;
         if (hist2[r][c]>0)
           l2 = true;
         if (l1 && l2)
         {
           label_intersection += 1;
           break;
         }
       }
     }
 
     float similarity = 0;
     if (label_intersection>0)
     {
       hist1.normalize_rows();
       hist2.normalize_rows();
       label_intersection /= m_NumLabels;
 
       for (unsigned int l=0; l<hist1.rows(); ++l)
         similarity += dot_product( hist1.get_row(l), hist2.get_row(l) );
       similarity /= hist1.rows();
       similarity *= label_intersection;
     }
 
     if (similarity>0)
       return m_Scale*0.2/similarity;
     else
       return 9999;
   }
 
   void GetHistogramAtPoint(itk::Point<float, 3>& itkP, vnl_matrix<float>& hist)
   {
     int parc_idx = 0;
     for (auto parc : m_Parcellations)
     {
       int dir_idx=0;
       itk::Index<3> tmp_idx;
       itk::Index<3> idx;
       parc->TransformPhysicalPointToIndex(itkP, idx);
       if (!parc->GetLargestPossibleRegion().IsInside(idx))
         continue;
 
       short label = parc->GetPixel(idx);
       short S0 = label;
       hist[dir_idx][m_LabelMaps.at(parc_idx).at(label)] += 1;
 
       for (int x=-m_Radius; x<=m_Radius; ++x)
         for (int y=-m_Radius; y<=m_Radius; ++y)
           for (int z=-m_Radius; z<=m_Radius; ++z)
           {
             if (x==0 && y==0 && z==0)
               continue;
 
             ++dir_idx;
 
             for (int d=1; d<5; ++d)
             {
               tmp_idx[0] = idx[0] + x*d;
               tmp_idx[1] = idx[1] + y*d;
               tmp_idx[2] = idx[2] + z*d;
               if (!parc->GetLargestPossibleRegion().IsInside(tmp_idx))
                 break;
               label = parc->GetPixel(tmp_idx);
 
               if (label!=S0)
               {
                 hist[dir_idx][m_LabelMaps.at(parc_idx).at(label)] += 1;
                 break;
               }
             }
           }
       ++parc_idx;
     }
   }
 
   void SetParcellations(const std::vector<ItkShortImgType::Pointer> &Parcellations)
   {
     m_Parcellations = Parcellations;
     m_NumLabels = 0;
 
     for (auto parc : m_Parcellations)
     {
       std::map< short, short > label_map;
       itk::ImageRegionConstIterator<ItkShortImgType> it(parc, parc->GetLargestPossibleRegion());
       while (!it.IsAtEnd())
       {
         if (label_map.count(it.Get())==0)
         {
           label_map.insert( std::pair< short, short >( it.Get(), m_NumLabels) );
           ++m_NumLabels;
         }
         ++it;
       }
       m_LabelMaps.push_back(label_map);
     }
   }
 
 protected:
 
   std::vector< ItkShortImgType::Pointer > m_Parcellations;
   short m_NumLabels;
   int m_Radius;
   std::vector< std::map< short, short > > m_LabelMaps;
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMax.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMax.h
index 24f1b52e7c..ecd02c745a 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMax.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMax.h
@@ -1,71 +1,71 @@
 /*===================================================================
 
 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 _ClusteringMetricEuMax
 #define _ClusteringMetricEuMax
 
 #include <mitkClusteringMetric.h>
 
 namespace mitk
 {
 
 /**
 * \brief Fiber clustering metric based on the euclidean maximum distance between tracts */
 
-class MITKFIBERTRACKING_EXPORT ClusteringMetricEuclideanMax : public ClusteringMetric
+class ClusteringMetricEuclideanMax : public ClusteringMetric
 {
 
 public:
 
   ClusteringMetricEuclideanMax(){}
   virtual ~ClusteringMetricEuclideanMax(){}
 
   float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped)
   {
     float d_direct = 0;
     float d_flipped = 0;
 
     vnl_vector<float> dists_d; dists_d.set_size(s.cols());
     vnl_vector<float> dists_f; dists_f.set_size(s.cols());
 
     for (unsigned int i=0; i<s.cols(); ++i)
     {
       dists_d[i] = (s.get_column(i)-t.get_column(i)).magnitude();
       d_direct += dists_d[i];
 
       dists_f[i] = (s.get_column(i)-t.get_column(s.cols()-i-1)).magnitude();
       d_flipped += dists_f[i];
     }
 
     if (d_direct>d_flipped)
     {
       float d = dists_f.max_value();
       flipped = true;
       return m_Scale*d;
     }
 
     float d = dists_d.max_value();
     flipped = false;
     return m_Scale*d;
   }
 
 protected:
 
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMean.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMean.h
index 9cddeccfff..456b7bfce0 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMean.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanMean.h
@@ -1,62 +1,62 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _ClusteringMetricEuMean
 #define _ClusteringMetricEuMean
 
 #include <mitkClusteringMetric.h>
 
 namespace mitk
 {
 
 /**
 * \brief Fiber clustering metric based on the mean euclidean distance between tracts */
 
-class MITKFIBERTRACKING_EXPORT ClusteringMetricEuclideanMean : public ClusteringMetric
+class ClusteringMetricEuclideanMean : public ClusteringMetric
 {
 
 public:
 
   ClusteringMetricEuclideanMean(){}
   virtual ~ClusteringMetricEuclideanMean(){}
 
   float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped)
   {
     float d_direct = 0;
     float d_flipped = 0;
 
     for (unsigned int i=0; i<s.cols(); ++i)
     {
       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;
       return m_Scale*d_flipped/s.cols();
     }
     flipped = false;
     return m_Scale*d_direct/s.cols();
   }
 
 protected:
 
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanStd.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanStd.h
index 1f4ca84b3e..565938ece4 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanStd.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricEuclideanStd.h
@@ -1,77 +1,77 @@
 /*===================================================================
 
 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 _ClusteringMetricEuStd
 #define _ClusteringMetricEuStd
 
 #include <mitkClusteringMetric.h>
 
 namespace mitk
 {
 
 /**
 * \brief Fiber clustering metric based on the euclidean distance between tracts and the corresponding standard deviation of the distances */
 
-class MITKFIBERTRACKING_EXPORT ClusteringMetricEuclideanStd : public ClusteringMetric
+class ClusteringMetricEuclideanStd : public ClusteringMetric
 {
 
 public:
 
   ClusteringMetricEuclideanStd(){}
   virtual ~ClusteringMetricEuclideanStd(){}
 
   float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped)
   {
     float d_direct = 0;
     float d_flipped = 0;
 
     vnl_vector<float> dists_d; dists_d.set_size(s.cols());
     vnl_vector<float> dists_f; dists_f.set_size(s.cols());
 
     for (unsigned int i=0; i<s.cols(); ++i)
     {
       dists_d[i] = (s.get_column(i)-t.get_column(i)).magnitude();
       d_direct += dists_d[i];
 
       dists_f[i] = (s.get_column(i)-t.get_column(s.cols()-i-1)).magnitude();
       d_flipped += dists_f[i];
     }
 
     if (d_direct>d_flipped)
     {
       float d = d_flipped/s.cols();
       dists_f -= d;
       d += dists_f.magnitude();
 
       flipped = true;
       return m_Scale*d/2;
     }
 
     float d = d_direct/s.cols();
     dists_d -= d;
     d += dists_d.magnitude();
 
     flipped = false;
     return m_Scale*d/2;
   }
 
 protected:
 
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricInnerAngles.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricInnerAngles.h
index 90206f1163..7f243a8509 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricInnerAngles.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricInnerAngles.h
@@ -1,125 +1,125 @@
 /*===================================================================
 
 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 _ClusteringMetricInnerAngles
 #define _ClusteringMetricInnerAngles
 
 #include <mitkClusteringMetric.h>
 
 namespace mitk
 {
 
 /**
 * \brief Fiber clustering metric based on the angles between certain parts of the streamline */
 
-class MITKFIBERTRACKING_EXPORT ClusteringMetricInnerAngles : public ClusteringMetric
+class ClusteringMetricInnerAngles : public ClusteringMetric
 {
 
 public:
 
   ClusteringMetricInnerAngles(){}
   virtual ~ClusteringMetricInnerAngles(){}
 
   float CalculateDistance(vnl_matrix<float>& s, vnl_matrix<float>& t, bool &flipped)
   {
     int p1 = 0;
     int p2 = s.cols()/4;
     int p3 = s.cols()/2;
     int p4 = 3*s.cols()/4;
     int p5 = s.cols()-1;
 
     float a1_s = 0;
     float a2_s = 0;
     float a3_s = 0;
     float a1_t = 0;
     float a2_t = 0;
     float a3_t = 0;
 
     {
       vnl_vector<float> v1 = s.get_column(p1)-s.get_column(p2); v1.normalize();
       vnl_vector<float> v2 = s.get_column(p3)-s.get_column(p2); v2.normalize();
       a1_s = dot_product(v1,v2);
       a1_s = std::acos( a1_s ) * 180.0/M_PI;
     }
 
     {
       vnl_vector<float> v1 = s.get_column(p1)-s.get_column(p3); v1.normalize();
       vnl_vector<float> v2 = s.get_column(p5)-s.get_column(p3); v2.normalize();
       a2_s = dot_product(v1,v2);
       a2_s = std::acos( a2_s ) * 180.0/M_PI;
     }
 
     {
       vnl_vector<float> v1 = s.get_column(p3)-s.get_column(p4); v1.normalize();
       vnl_vector<float> v2 = s.get_column(p5)-s.get_column(p4); v2.normalize();
       a3_s = dot_product(v1,v2);
       a3_s = std::acos( a3_s ) * 180.0/M_PI;
     }
 
     //
     {
       vnl_vector<float> v1 = t.get_column(p1)-t.get_column(p2); v1.normalize();
       vnl_vector<float> v2 = t.get_column(p3)-t.get_column(p2); v2.normalize();
       a1_t = dot_product(v1,v2);
       a1_t = std::acos( a1_t ) * 180.0/M_PI;
     }
 
     {
       vnl_vector<float> v1 = t.get_column(p1)-t.get_column(p3); v1.normalize();
       vnl_vector<float> v2 = t.get_column(p5)-t.get_column(p3); v2.normalize();
       a2_t = dot_product(v1,v2);
       a2_t = std::acos( a2_t ) * 180.0/M_PI;
     }
 
     {
       vnl_vector<float> v1 = t.get_column(p3)-t.get_column(p4); v1.normalize();
       vnl_vector<float> v2 = t.get_column(p5)-t.get_column(p4); v2.normalize();
       a3_t = dot_product(v1,v2);
       a3_t = std::acos( a3_t ) * 180.0/M_PI;
     }
 
     float d_direct = 0;
     float d_flipped = 0;
 
     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;
       float d1 = std::fabs(a1_s-a3_t);
       float d2 = std::fabs(a2_s-a2_t);
       float d3 = std::fabs(a3_s-a1_t);
       return m_Scale * std::max( d1, std::max(d2,d3) );
     }
     flipped = false;
     float d1 = std::fabs(a1_s-a1_t);
     float d2 = std::fabs(a2_s-a2_t);
     float d3 = std::fabs(a3_s-a3_t);
     return m_Scale * std::max( d1, std::max(d2,d3) );
   }
 
 protected:
 
 };
 
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
index ff8108be40..5ff8dc27dc 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/ClusteringMetrics/mitkClusteringMetricScalarMap.h
@@ -1,127 +1,127 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #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 MITKFIBERTRACKING_EXPORT ClusteringMetricScalarMap : public ClusteringMetric
+class ClusteringMetricScalarMap : public ClusteringMetric
 {
 
 public:
 
   typedef itk::Image<float, 3>  ItkFloatImgType;
 
   ClusteringMetricScalarMap()
   {}
   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);
       ++c;
     }
     return vals;
   }
 
   void SetImages(const std::vector<ItkFloatImgType::Pointer> &Parcellations)
   {
     m_ScalarMaps = Parcellations;
   }
 
 protected:
 
   std::vector< ItkFloatImgType::Pointer > m_ScalarMaps;
 };
 
 }
 
 #endif