diff --git a/CMakeExternals/MITKData.cmake b/CMakeExternals/MITKData.cmake
index 2d85188dac..0e9b11d9c7 100644
--- a/CMakeExternals/MITKData.cmake
+++ b/CMakeExternals/MITKData.cmake
@@ -1,36 +1,36 @@
 #-----------------------------------------------------------------------------
 # MITK Data
 #-----------------------------------------------------------------------------
 
 # Sanity checks
 if(DEFINED MITK_DATA_DIR AND NOT EXISTS ${MITK_DATA_DIR})
   message(FATAL_ERROR "MITK_DATA_DIR variable is defined but corresponds to non-existing directory")
 endif()
 
 set(proj MITK-Data)
 set(proj_DEPENDENCIES)
 set(MITK-Data_DEPENDS ${proj})
 
 if(BUILD_TESTING)
 
-  set(revision_tag 16f27d87) # first 8 characters of hash-tag
+  set(revision_tag 2fce9992) # first 8 characters of hash-tag
 #                  ^^^^^^^^  these are just to check correct length of hash part
 
   ExternalProject_Add(${proj}
     URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/MITK-Data_${revision_tag}.tar.gz
     UPDATE_COMMAND ""
     CONFIGURE_COMMAND ""
     BUILD_COMMAND ""
     INSTALL_COMMAND ""
     DEPENDS ${proj_DEPENDENCIES}
   )
 
   set(MITK_DATA_DIR ${ep_source_dir}/${proj})
 
 else()
 
   mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
 endif(BUILD_TESTING)
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
index 82ef991340..ad60351fb8 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToVectorImageFilter.cpp
@@ -1,566 +1,565 @@
 #include "itkTractsToVectorImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 
 // ITK
 #include <itkTimeProbe.h>
 #include <itkImageRegionIterator.h>
 
 // misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 
 
 namespace itk{
 
 static bool CompareVectorLengths(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
 {
     return (v1.magnitude()>v2.magnitude());
 }
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::TractsToVectorImageFilter():
     m_AngularThreshold(0.7),
     m_Epsilon(0.999),
     m_MaskImage(NULL),
     m_NormalizeVectors(false),
     m_UseWorkingCopy(true),
     m_MaxNumDirections(3),
-    m_SizeThreshold(0.2),
+    m_SizeThreshold(0.3),
     m_NumDirectionsImage(NULL),
     m_CreateDirectionImages(true)
 {
     this->SetNumberOfRequiredOutputs(1);
 }
 
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::~TractsToVectorImageFilter()
 {
 }
 
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::GetVnlVector(double point[])
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 
 template< class PixelType >
 itk::Point<double, 3> TractsToVectorImageFilter< PixelType >::GetItkPoint(double point[])
 {
     itk::Point<double, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class PixelType >
 void TractsToVectorImageFilter< PixelType >::GenerateData()
 {
     mitk::BaseGeometry::Pointer geometry = m_FiberBundle->GetGeometry();
 
     // calculate new image parameters
     itk::Vector<double> spacing;
     itk::Point<double> origin;
     itk::Matrix<double, 3, 3> direction;
     ImageRegion<3> imageRegion;
     if (!m_MaskImage.IsNull())
     {
         spacing = m_MaskImage->GetSpacing();
         imageRegion = m_MaskImage->GetLargestPossibleRegion();
         origin = m_MaskImage->GetOrigin();
         direction = m_MaskImage->GetDirection();
     }
     else
     {
         spacing = geometry->GetSpacing();
         origin = geometry->GetOrigin();
         mitk::BaseGeometry::BoundsArrayType bounds = geometry->GetBounds();
         origin[0] += bounds.GetElement(0);
         origin[1] += bounds.GetElement(2);
         origin[2] += bounds.GetElement(4);
 
         for (int i=0; i<3; i++)
             for (int j=0; j<3; j++)
                 direction[j][i] = geometry->GetMatrixColumn(i)[j];
         imageRegion.SetSize(0, geometry->GetExtent(0));
         imageRegion.SetSize(1, geometry->GetExtent(1));
         imageRegion.SetSize(2, geometry->GetExtent(2));
 
 
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( spacing );
         m_MaskImage->SetOrigin( origin );
         m_MaskImage->SetDirection( direction );
         m_MaskImage->SetRegions( imageRegion );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
     OutputImageType::RegionType::SizeType outImageSize = imageRegion.GetSize();
     m_OutImageSpacing = m_MaskImage->GetSpacing();
     m_ClusteredDirectionsContainer = ContainerType::New();
 
     // initialize num directions image
     m_NumDirectionsImage = ItkUcharImgType::New();
     m_NumDirectionsImage->SetSpacing( spacing );
     m_NumDirectionsImage->SetOrigin( origin );
     m_NumDirectionsImage->SetDirection( direction );
     m_NumDirectionsImage->SetRegions( imageRegion );
     m_NumDirectionsImage->Allocate();
     m_NumDirectionsImage->FillBuffer(0);
 
     // initialize direction images
     m_DirectionImageContainer = DirectionImageContainerType::New();
 
     // resample fiber bundle
     double minSpacing = 1;
     if(m_OutImageSpacing[0]<m_OutImageSpacing[1] && m_OutImageSpacing[0]<m_OutImageSpacing[2])
         minSpacing = m_OutImageSpacing[0];
     else if (m_OutImageSpacing[1] < m_OutImageSpacing[2])
         minSpacing = m_OutImageSpacing[1];
     else
         minSpacing = m_OutImageSpacing[2];
 
     if (m_UseWorkingCopy)
         m_FiberBundle = m_FiberBundle->GetDeepCopy();
 
     // resample fiber bundle for sufficient voxel coverage
     m_FiberBundle->ResampleSpline(minSpacing/10);
 
     // iterate over all fibers
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     int numFibers = m_FiberBundle->GetNumFibers();
     m_DirectionsContainer = ContainerType::New();
 
     MITK_INFO << "Generating directions from tractogram";
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
         vtkCell* cell = fiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
         if (numPoints<2)
             continue;
 
         vnl_vector_fixed<double, 3> dir;
         itk::Point<double, 3> worldPos;
         vnl_vector<double> v;
 
         for( int j=0; j<numPoints-1; j++)
         {
             // get current position along fiber in world coordinates
             double* temp = points->GetPoint(j);
             worldPos = GetItkPoint(temp);
             itk::Index<3> index;
             m_MaskImage->TransformPhysicalPointToIndex(worldPos, index);
             if (!m_MaskImage->GetLargestPossibleRegion().IsInside(index) || m_MaskImage->GetPixel(index)==0)
                 continue;
 
             // get fiber tangent direction at this position
             v = GetVnlVector(temp);
             dir = GetVnlVector(points->GetPoint(j+1))-v;
             if (dir.is_zero())
                 continue;
             dir.normalize();
 
             // add direction to container
             unsigned int idx = index[0] + outImageSize[0]*(index[1] + outImageSize[1]*index[2]);
             DirectionContainerType::Pointer dirCont;
             if (m_DirectionsContainer->IndexExists(idx))
             {
                 dirCont = m_DirectionsContainer->GetElement(idx);
                 if (dirCont.IsNull())
                 {
                     dirCont = DirectionContainerType::New();
                     dirCont->push_back(dir);
                     m_DirectionsContainer->InsertElement(idx, dirCont);
                 }
                 else
                     dirCont->push_back(dir);
             }
             else
             {
                 dirCont = DirectionContainerType::New();
                 dirCont->push_back(dir);
                 m_DirectionsContainer->InsertElement(idx, dirCont);
             }
         }
     }
 
     vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints>    m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
 
     itk::ImageRegionIterator<ItkUcharImgType> dirIt(m_NumDirectionsImage, m_NumDirectionsImage->GetLargestPossibleRegion());
 
     MITK_INFO << "Clustering directions";
     boost::progress_display disp2(outImageSize[0]*outImageSize[1]*outImageSize[2]);
     while(!dirIt.IsAtEnd())
     {
         ++disp2;
         OutputImageType::IndexType index = dirIt.GetIndex();
         int idx = index[0]+(index[1]+index[2]*outImageSize[1])*outImageSize[0];
 
         if (!m_DirectionsContainer->IndexExists(idx))
         {
             ++dirIt;
             continue;
         }
         DirectionContainerType::Pointer dirCont = m_DirectionsContainer->GetElement(idx);
         if (dirCont.IsNull() || dirCont->empty())
         {
             ++dirIt;
             continue;
         }
 
         std::vector< double > lengths; lengths.resize(dirCont->size(), 1);  // all peaks have size 1
         DirectionContainerType::Pointer directions;
         if (m_MaxNumDirections>0)
         {
             directions = FastClustering(dirCont, lengths);
             std::sort( directions->begin(), directions->end(), CompareVectorLengths );
         }
         else
             directions = dirCont;
 
         unsigned int numDir = directions->size();
         if (m_MaxNumDirections>0 && numDir>m_MaxNumDirections)
             numDir = m_MaxNumDirections;
 
         int count = 0;
         for (unsigned int i=0; i<numDir; i++)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             itk::ContinuousIndex<double, 3> center;
             center[0] = index[0];
             center[1] = index[1];
             center[2] = index[2];
             itk::Point<double> worldCenter;
             m_MaskImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
             DirectionType dir = directions->at(i);
 
             if (dir.magnitude()<m_SizeThreshold)
                 continue;
+            if (m_NormalizeVectors)
+                dir.normalize();
             count++;
 
-//            if (m_NormalizeVectors)
-//                dir.normalize();
-
             if (m_CreateDirectionImages && i<10)
             {
                 if (i==m_DirectionImageContainer->size())
                 {
                     ItkDirectionImageType::Pointer directionImage = ItkDirectionImageType::New();
                     directionImage->SetSpacing( spacing );
                     directionImage->SetOrigin( origin );
                     directionImage->SetDirection( direction );
                     directionImage->SetRegions( imageRegion );
                     directionImage->Allocate();
                     Vector< float, 3 > nullVec; nullVec.Fill(0.0);
                     directionImage->FillBuffer(nullVec);
                     m_DirectionImageContainer->InsertElement(i, directionImage);
                 }
 
                 // set direction image pixel
                 ItkDirectionImageType::Pointer directionImage = m_DirectionImageContainer->GetElement(i);
                 Vector< float, 3 > pixel;
                 pixel.SetElement(0, dir[0]);
                 pixel.SetElement(1, dir[1]);
                 pixel.SetElement(2, dir[2]);
                 directionImage->SetPixel(index, pixel);
             }
 
             // add direction to vector field (with spacing compensation)
             itk::Point<double> worldStart;
             worldStart[0] = worldCenter[0]-dir[0]/2*minSpacing;
             worldStart[1] = worldCenter[1]-dir[1]/2*minSpacing;
             worldStart[2] = worldCenter[2]-dir[2]/2*minSpacing;
             vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             itk::Point<double> worldEnd;
             worldEnd[0] = worldCenter[0]+dir[0]/2*minSpacing;
             worldEnd[1] = worldCenter[1]+dir[1]/2*minSpacing;
             worldEnd[2] = worldCenter[2]+dir[2]/2*minSpacing;
             id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
             m_VtkCellArray->InsertNextCell(container);
         }
         dirIt.Set(count);
         ++dirIt;
     }
 
     vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
     directionsPolyData->SetPoints(m_VtkPoints);
     directionsPolyData->SetLines(m_VtkCellArray);
     m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
 }
 
 
 template< class PixelType >
 TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::FastClustering(DirectionContainerType::Pointer inDirs, std::vector< double > lengths)
 {
     DirectionContainerType::Pointer outDirs = DirectionContainerType::New();
     if (inDirs->size()<2)
         return inDirs;
 
     DirectionType oldMean, currentMean;
     std::vector< int > touched;
 
     // initialize
     touched.resize(inDirs->size(), 0);
     bool free = true;
     currentMean = inDirs->at(0);  // initialize first seed
     currentMean.normalize();
     double length = lengths.at(0);
     touched[0] = 1;
     std::vector< double > newLengths;
     bool meanChanged = false;
 
     double max = 0;
     while (free)
     {
         oldMean.fill(0.0);
 
         // start mean-shift clustering
         double angle = 0;
 
         while (fabs(dot_product(currentMean, oldMean))<0.99)
         {
             oldMean = currentMean;
             currentMean.fill(0.0);
             for (unsigned int i=0; i<inDirs->size(); i++)
             {
                 angle = dot_product(oldMean, inDirs->at(i));
                 if (angle>=m_AngularThreshold)
                 {
                     currentMean += inDirs->at(i);
                     if (meanChanged)
                         length += lengths.at(i);
                     touched[i] = 1;
                     meanChanged = true;
                 }
                 else if (-angle>=m_AngularThreshold)
                 {
                     currentMean -= inDirs->at(i);
                     if (meanChanged)
                         length += lengths.at(i);
                     touched[i] = 1;
                     meanChanged = true;
                 }
             }
             if(!meanChanged)
                 currentMean = oldMean;
             else
                 currentMean.normalize();
         }
 
         // found stable mean
         outDirs->push_back(currentMean);
         newLengths.push_back(length);
         if (length>max)
             max = length;
 
         // find next unused seed
         free = false;
         for (unsigned int i=0; i<touched.size(); i++)
             if (touched[i]==0)
             {
                 currentMean = inDirs->at(i);
                 free = true;
                 meanChanged = false;
                 length = lengths.at(i);
                 touched[i] = 1;
                 break;
             }
     }
 
     if (inDirs->size()==outDirs->size())
     {
-        if (!m_NormalizeVectors && max>0)
+        if (max>0)
             for (unsigned int i=0; i<outDirs->size(); i++)
                 outDirs->SetElement(i, outDirs->at(i)*newLengths.at(i)/max);
         return outDirs;
     }
     else
         return FastClustering(outDirs, newLengths);
 }
 
 
 //template< class PixelType >
 //std::vector< DirectionType > TractsToVectorImageFilter< PixelType >::Clustering(std::vector< DirectionType >& inDirs)
 //{
 //    std::vector< DirectionType > outDirs;
 //    if (inDirs.empty())
 //        return outDirs;
 //    DirectionType oldMean, currentMean, workingMean;
 
 //    std::vector< DirectionType > normalizedDirs;
 //    std::vector< int > touched;
 //    for (std::size_t i=0; i<inDirs.size(); i++)
 //    {
 //        normalizedDirs.push_back(inDirs[i]);
 //        normalizedDirs.back().normalize();
 //    }
 
 //    // initialize
 //    double max = 0.0;
 //    touched.resize(inDirs.size(), 0);
 //    for (std::size_t j=0; j<inDirs.size(); j++)
 //    {
 //        currentMean = inDirs[j];
 //        oldMean.fill(0.0);
 
 //        // start mean-shift clustering
 //        double angle = 0.0;
 //        int counter = 0;
 //        while ((currentMean-oldMean).magnitude()>0.0001)
 //        {
 //            counter = 0;
 //            oldMean = currentMean;
 //            workingMean = oldMean;
 //            workingMean.normalize();
 //            currentMean.fill(0.0);
 //            for (std::size_t i=0; i<normalizedDirs.size(); i++)
 //            {
 //                angle = dot_product(workingMean, normalizedDirs[i]);
 //                if (angle>=m_AngularThreshold)
 //                {
 //                    currentMean += inDirs[i];
 //                    counter++;
 //                }
 //                else if (-angle>=m_AngularThreshold)
 //                {
 //                    currentMean -= inDirs[i];
 //                    counter++;
 //                }
 //            }
 //        }
 
 //        // found stable mean
 //        if (counter>0)
 //        {
 //            bool add = true;
 //            DirectionType normMean = currentMean;
 //            normMean.normalize();
 //            for (std::size_t i=0; i<outDirs.size(); i++)
 //            {
 //                DirectionType dir = outDirs[i];
 //                dir.normalize();
 //                if ((normMean-dir).magnitude()<=0.0001)
 //                {
 //                    add = false;
 //                    break;
 //                }
 //            }
 
 //            currentMean /= counter;
 //            if (add)
 //            {
 //                double mag = currentMean.magnitude();
 //                if (mag>0)
 //                {
 //                    if (mag>max)
 //                        max = mag;
 
 //                    outDirs.push_back(currentMean);
 //                }
 //            }
 //        }
 //    }
 
 //    if (m_NormalizeVectors)
 //        for (std::size_t i=0; i<outDirs.size(); i++)
 //            outDirs[i].normalize();
 //    else if (max>0)
 //        for (std::size_t i=0; i<outDirs.size(); i++)
 //            outDirs[i] /= max;
 
 //    if (inDirs.size()==outDirs.size())
 //        return outDirs;
 //    else
 //        return FastClustering(outDirs);
 //}
 
 
 //template< class PixelType >
 //TractsToVectorImageFilter< PixelType >::DirectionContainerType::Pointer TractsToVectorImageFilter< PixelType >::MeanShiftClustering(DirectionContainerType::Pointer dirCont)
 //{
 //    DirectionContainerType::Pointer container = DirectionContainerType::New();
 
 //    double max = 0;
 //    for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
 //    {
 //        vnl_vector_fixed<double, 3> mean = ClusterStep(dirCont, it.Value());
 
 //        if (mean.is_zero())
 //            continue;
 //        bool addMean = true;
 
 //        for (DirectionContainerType::ConstIterator it2 = container->Begin(); it2!=container->End(); ++it2)
 //        {
 //            vnl_vector_fixed<double, 3> dir = it2.Value();
 //            double angle = fabs(dot_product(mean, dir)/(mean.magnitude()*dir.magnitude()));
 //            if (angle>=m_Epsilon)
 //            {
 //                addMean = false;
 //                break;
 //            }
 //        }
 
 //        if (addMean)
 //        {
 //            if (m_NormalizeVectors)
 //                mean.normalize();
 //            else if (mean.magnitude()>max)
 //                max = mean.magnitude();
 //            container->InsertElement(container->Size(), mean);
 //        }
 //    }
 
 //    // max normalize voxel directions
 //    if (max>0 && !m_NormalizeVectors)
 //        for (std::size_t i=0; i<container->Size(); i++)
 //            container->ElementAt(i) /= max;
 
 //    if (container->Size()<dirCont->Size())
 //        return MeanShiftClustering(container);
 //    else
 //        return container;
 //}
 
 
 //template< class PixelType >
 //vnl_vector_fixed<double, 3> TractsToVectorImageFilter< PixelType >::ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean)
 //{
 //    vnl_vector_fixed<double, 3> newMean; newMean.fill(0);
 
 //    for (DirectionContainerType::ConstIterator it = dirCont->Begin(); it!=dirCont->End(); ++it)
 //    {
 //        vnl_vector_fixed<double, 3> dir = it.Value();
 //        double angle = dot_product(currentMean, dir)/(currentMean.magnitude()*dir.magnitude());
 //        if (angle>=m_AngularThreshold)
 //            newMean += dir;
 //        else if (-angle>=m_AngularThreshold)
 //            newMean -= dir;
 //    }
 
 //    if (fabs(dot_product(currentMean, newMean)/(currentMean.magnitude()*newMean.magnitude()))>=m_Epsilon || newMean.is_zero())
 //        return newMean;
 //    else
 //        return ClusterStep(dirCont, newMean);
 //}
 }
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
index 9b49819365..1d7bd6c369 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
@@ -1,167 +1,167 @@
 /*===================================================================
 
 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 <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkTestingMacros.h>
 #include <mitkCompareImageDataFilter.h>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 using namespace std;
 
 int mitkLocalFiberPlausibilityTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkLocalFiberPlausibilityTest");
     MITK_TEST_CONDITION_REQUIRED(argc==8,"check for input data")
 
             string fibFile = argv[1];
     vector< string > referenceImages;
     referenceImages.push_back(argv[2]);
     referenceImages.push_back(argv[3]);
     string LDFP_ERROR_IMAGE = argv[4];
     string LDFP_NUM_DIRECTIONS = argv[5];
     string LDFP_VECTOR_FIELD = argv[6];
     string LDFP_ERROR_IMAGE_IGNORE = argv[7];
 
-    float angularThreshold = 25;
+    float angularThreshold = 30;
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
         itkMaskImage->SetSpacing( dirImg->GetSpacing() );
         itkMaskImage->SetOrigin( dirImg->GetOrigin() );
         itkMaskImage->SetDirection( dirImg->GetDirection() );
         itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->Allocate();
         itkMaskImage->FillBuffer(1);
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(true);
-        //fOdfFilter->SetMaxNumDirections(1);
-        fOdfFilter->SetSizeThreshold(0.0);
+        fOdfFilter->SetMaxNumDirections(3);
+        fOdfFilter->SetSizeThreshold(0.3);
 
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->SetNumberOfThreads(1);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // Get directions and num directions image
         ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
         mitk::Image::Pointer mitkNumDirImage = mitk::Image::New();
         mitkNumDirImage->InitializeByItk( numDirImage.GetPointer() );
         mitkNumDirImage->SetVolume( numDirImage->GetBufferPointer() );
         mitk::FiberBundleX::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
 
+        //mitk::IOUtil::SaveImage(mitkNumDirImage, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_NUM_DIRECTIONS.nrrd");
+        //mitk::IOUtil::SaveBaseData(testDirections, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_VECTOR_FIELD.fib");
+
         // evaluate directions with missing directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(false);
         evaluationFilter->Update();
 
         EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
         mitk::Image::Pointer mitkAngularErrorImage = mitk::Image::New();
         mitkAngularErrorImage->InitializeByItk( angularErrorImage.GetPointer() );
         mitkAngularErrorImage->SetVolume( angularErrorImage->GetBufferPointer() );
+        //mitk::IOUtil::SaveImage(mitkAngularErrorImage, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_ERROR_IMAGE.nrrd");
 
         // evaluate directions without missing directions
         evaluationFilter->SetIgnoreMissingDirections(true);
         evaluationFilter->Update();
 
         EvaluationFilterType::OutputImageType::Pointer angularErrorImageIgnore = evaluationFilter->GetOutput(0);
         mitk::Image::Pointer mitkAngularErrorImageIgnore = mitk::Image::New();
         mitkAngularErrorImageIgnore->InitializeByItk( angularErrorImageIgnore.GetPointer() );
         mitkAngularErrorImageIgnore->SetVolume( angularErrorImageIgnore->GetBufferPointer() );
+        //mitk::IOUtil::SaveImage(mitkAngularErrorImageIgnore, "/local/mitk/release-binary/MITK-superbuild/CMakeExternals/Source/MITK-Data/DiffusionImaging/LDFP_ERROR_IMAGE_IGNORE.nrrd");
 
         mitk::Image::Pointer gtAngularErrorImageIgnore = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE_IGNORE)->GetData());
         mitk::Image::Pointer gtAngularErrorImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE)->GetData());
         mitk::Image::Pointer gtNumTestDirImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_NUM_DIRECTIONS)->GetData());
         mitk::FiberBundleX::Pointer gtTestDirections = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(LDFP_VECTOR_FIELD)->GetData());
 
-//        mitk::IOUtil::SaveBaseData(mitkAngularErrorImageIgnore, mitk::IOUtil::GetTempPath()+"mitkAngularErrorImageIgnore.nrrd");
-//        mitk::IOUtil::SaveBaseData(mitkAngularErrorImage, mitk::IOUtil::GetTempPath()+"mitkAngularErrorImage.nrrd");
-//        mitk::IOUtil::SaveBaseData(mitkNumDirImage, mitk::IOUtil::GetTempPath()+"mitkNumDirImage.nrrd");
-//        mitk::IOUtil::SaveBaseData(testDirections, mitk::IOUtil::GetTempPath()+"testDirections.fib");
-
         MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImageIgnore, mitkAngularErrorImageIgnore, 0.01, true), "Check if error images are equal (ignored missing directions).");
         MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImage, mitkAngularErrorImage, 0.01, true), "Check if error images are equal.");
         MITK_TEST_CONDITION_REQUIRED(testDirections->Equals(gtTestDirections), "Check if vector fields are equal.");
         MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtNumTestDirImage, mitkNumDirImage, 0.1, true), "Check if num direction images are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     MITK_TEST_END();
 }