diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
index 5b25f8f59b..52c33c399b 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundle/mitkFiberBundle.cpp
@@ -1,2100 +1,2100 @@
 /*===================================================================
 
 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>
 
 const char* mitk::FiberBundle::FIBER_ID_ARRAY = "Fiber_IDs";
 
 using namespace std;
 
 mitk::FiberBundle::FiberBundle( vtkPolyData* fiberPolyData )
     : m_NumFibers(0)
     , m_FiberSampling(0)
 {
     m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     m_FiberWeights->SetName("FIBER_WEIGHTS");
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     if (fiberPolyData != nullptr)
     {
         m_FiberPolyData = fiberPolyData;
         this->ColorFibersByOrientation();
     }
 
     this->UpdateFiberGeometry();
     this->GenerateFiberIds();
 }
 
 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<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
 
     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]);
         }
 
         newLineSet->InsertNextCell(newFiber);
         ++finIt;
     }
 
     newFiberPolyData->SetPoints(newPointSet);
     newFiberPolyData->SetLines(newLineSet);
     return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundle(mitk::FiberBundle* fib)
 {
     if (fib==nullptr)
     {
         MITK_WARN << "trying to call AddBundle with NULL argument";
         return nullptr;
     }
     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;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::SubtractBundle(mitk::FiberBundle* fib)
 {
     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 (unsigned int i=0; i<points1.size(); i++)
+    for (int i=0; i<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++)
+        for (int j=0; j<points2.size(); j++)
         {
             auto v1 = points1.at(i);
             auto v2 = points2.at(j);
 
             unsigned int matches = 0;
             unsigned int reverse_matches = 0;
             for (int c=0; c<v1.size(); c++)
             {
                 if (v1[c].SquaredEuclideanDistanceTo(v2[c])<mitk::eps)
                     matches++;
                 if (v1[v1.size() - c - 1].SquaredEuclideanDistanceTo(v2[c])<mitk::eps)
                     reverse_matches++;
             }
 
             if (matches==v1.size() || reverse_matches==v1.size())
             {
                 match = true;
                 j=points2.size();
             }
         }
 
 #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 nullptr;
     // 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);
         ColorFibersByOrientation();
     }
 
     m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
     if (updateGeometry)
         UpdateFiberGeometry();
     GenerateFiberIds();
 }
 
 /*
  * 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 except 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->InsertTupleValue(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 minMaxNorm)
 {
     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);
 
     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 (minMaxNorm)
                 dev = (dev-min)/(max-min);
             //            double dev = values.at(count)*values.at(count);
             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->InsertTupleValue(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)
 {
     mitkPixelTypeMultiplex2( ColorFibersByScalarMap, FAimage->GetPixelType(), FAimage, opacity );
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 template <typename TPixel>
 void mitk::FiberBundle::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity)
 {
     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);
 
     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);
 
         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->InsertTupleValue(i, rgba);
     }
     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->InsertTupleValue(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();
 
 }
 
 mitk::FiberBundle::Pointer mitk::FiberBundle::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert, bool bothEnds, float fraction)
 {
     vtkSmartPointer<vtkPolyData> polyData = m_FiberPolyData;
     if (anyPoint)
     {
         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->ResampleSpline(minSpacing/5);
         polyData = fibCopy->GetFiberPolyData();
     }
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Extracting 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();
 
         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);
                         }
                     }
                 }
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return nullptr;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     return mitk::FiberBundle::New(newPolyData);
 }
 
 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->ResampleSpline(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<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
     return mitk::FiberBundle::New(pTmp);
 }
 
 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 (long 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->GetSize()!=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)
 {
     return m_FiberWeights->GetValue(fiber);
 }
 
 void mitk::FiberBundle::SetFiberWeights(float newWeight)
 {
     for (int i=0; i<m_FiberWeights->GetSize(); i++)
         m_FiberWeights->SetValue(i, newWeight);
 }
 
 void mitk::FiberBundle::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
 {
     if (m_NumFibers!=weights->GetSize())
     {
         MITK_INFO << "Weights array not equal to number of fibers!";
         return;
     }
 
     for (int i=0; i<weights->GetSize(); 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->GetTupleValue(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->InsertTupleValue(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";
     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;
 #pragma omp critical
         {
             length = m_FiberLengths.at(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++)
             {
                 smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
                 vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
             }
 
             vtkSmoothCells->InsertNextCell(smoothLine);
             pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
         }
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkSmoothPoints);
     m_FiberPolyData->SetLines(vtkSmoothCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     m_FiberSampling = 10/pointDistance;
 }
 
 void mitk::FiberBundle::ResampleSpline(float pointDistance)
 {
     ResampleSpline(pointDistance, 0, 0, 0 );
 }
 
 unsigned long mitk::FiberBundle::GetNumberOfPoints()
 {
     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());
 
 #pragma omp parallel for
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
 
         std::vector< vnl_vector_fixed< double, 3 > > vertices;
 
 #pragma omp critical
         {
             ++disp;
             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 (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
         {
             numRemovedPoints += remCounter;
             vtkNewCells->InsertNextCell(container);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()>0)
     {
         MITK_INFO << "Removed points: " << numRemovedPoints;
         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 NULL!";
         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;
 }
 
 /* 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/TumorInvasionAnalysis/MiniApps/TumorProgressionMapping.cpp b/Modules/TumorInvasionAnalysis/MiniApps/TumorProgressionMapping.cpp
index 48b49856f5..ef8d57dd60 100644
--- a/Modules/TumorInvasionAnalysis/MiniApps/TumorProgressionMapping.cpp
+++ b/Modules/TumorInvasionAnalysis/MiniApps/TumorProgressionMapping.cpp
@@ -1,555 +1,554 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 // MITK
 #include <mitkIOUtil.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkImageToItk.h>
-#include <mitkImageWriter.h>
 #include <mitkPixelType.h>
 #include <mitkPlaneGeometry.h>
 
 // ITK
 #include "itkImageDuplicator.h"
 #include "itkPermuteAxesImageFilter.h"
 #include "itkTileImageFilter.h"
 #include <itkExtractImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRGBPixel.h>
 #include <itkResampleImageFilter.h>
 #include <itkVTKImageImport.h>
 
 #include <itkDirectory.h>
 #include <itksys/SystemTools.hxx>
 // VTK
 #include <vtkCellArray.h>
 #include <vtkFreeTypeStringToImage.h>
 #include <vtkImageData.h>
 #include <vtkTextProperty.h>
 #include <vtkUnicodeString.h>
 
 // MITK
 #include <mitkCommandLineParser.h>
 
 #include "itkRescaleIntensityImageFilter.h"
 
 #include <typeExtension.h>
 
 using namespace std;
 
 typedef unsigned short PixelType;
 typedef double InputPixelType;
 typedef itk::Image<itk::RGBPixel<PixelType>, 2> RGB2DImage;
 typedef itk::RGBPixel<PixelType> RGBPixelType;
 
 typedef std::vector<std::string> FileList;
 typedef std::vector<mitk::Image::Pointer> ImageList;
 
 /// Create list of all files in provided folder ending with same postfix
 static FileList CreateFileList(std::string folder, std::string postfix)
 {
   itk::Directory::Pointer dir = itk::Directory::New();
   FileList fileList;
 
   if (dir->Load(folder.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     for (int r = 0; r < n; r++)
     {
       std::string filename = dir->GetFile(r);
       if (filename == "." || filename == "..")
         continue;
       filename = folder + filename;
       if (!itksys::SystemTools::FileExists(filename.c_str()))
         continue;
 
       if (postfix.compare(filename.substr(filename.length() - postfix.length())) == 0)
         fileList.push_back(filename);
     }
   }
   std::sort(fileList.begin(), fileList.end());
   return fileList;
 }
 
 class mitkProgressionVisualization
 {
 public:
   mitkProgressionVisualization() {}
   /**
    * @brief ConvertToRGBImage converts a gray image to RGB by filling all three channels with the gray intensity
    * @param grayImage
    * @return
    */
   mitk::Image::Pointer ConvertToRGBImage(mitk::Image::Pointer grayImage)
   {
     mitk::Image::Pointer rgbImage = mitk::Image::New();
     unsigned int *dim = grayImage->GetDimensions();
     rgbImage->Initialize(mitk::MakePixelType<PixelType, RGBPixelType, 3>(), 3, dim);
     rgbImage->SetGeometry(grayImage->GetGeometry());
 
     itk::Image<InputPixelType, 3>::Pointer itkGrayImage = itk::Image<InputPixelType, 3>::New();
     mitk::CastToItkImage(grayImage, itkGrayImage);
 
     mitk::ImagePixelWriteAccessor<RGBPixelType, 3> writeAcc(rgbImage);
 
     typedef itk::RescaleIntensityImageFilter<itk::Image<InputPixelType, 3>, itk::Image<PixelType, 3>> RescaleFilterType;
     RescaleFilterType::Pointer rescaleFilter = RescaleFilterType::New();
     rescaleFilter->SetInput(itkGrayImage);
     rescaleFilter->SetOutputMinimum(0);
     rescaleFilter->SetOutputMaximum(255 * 255);
     rescaleFilter->Update();
 
     itk::Index<3> idx;
     RGBPixelType value;
 
     // Fill rgb image with gray values
     for (idx[2] = 0; (unsigned int)idx[2] < dim[2]; idx[2]++)
     {
       for (idx[1] = 0; (unsigned int)idx[1] < dim[1]; idx[1]++)
       {
         for (idx[0] = 0; (unsigned int)idx[0] < dim[0]; idx[0]++)
         {
           value.Fill(rescaleFilter->GetOutput()->GetPixel(idx));
           writeAcc.SetPixelByIndex(idx, value);
         }
       }
     }
     return rgbImage;
   }
 
   RGB2DImage::Pointer TextAsImage(std::string text)
   {
     vtkSmartPointer<vtkImageData> textImage = vtkSmartPointer<vtkImageData>::New();
     vtkSmartPointer<vtkFreeTypeStringToImage> freetype = vtkSmartPointer<vtkFreeTypeStringToImage>::New();
     vtkSmartPointer<vtkTextProperty> prop = vtkSmartPointer<vtkTextProperty>::New();
     float color[3] = {1, 1, 1};
     float opacity = 1.0;
     prop->SetColor(color[0], color[1], color[2]);
     prop->SetFontSize(40);
     prop->SetOpacity(opacity);
     textImage->AllocateScalars(VTK_UNSIGNED_SHORT, 3);
     freetype->RenderString(prop, vtkUnicodeString::from_utf8(text.c_str()), 72, textImage);
     textImage->Modified();
 
     int *extent = textImage->GetExtent();
 
     RGB2DImage::Pointer itkImage = RGB2DImage::New();
 
     RGB2DImage::IndexType start;
     start.Fill(0);
     RGB2DImage::SizeType size;
     size[0] = extent[1];
     size[1] = extent[3];
     size[2] = 0;
 
     RGB2DImage::RegionType region(start, size);
     itkImage->SetRegions(region);
     itkImage->Allocate();
     RGB2DImage::IndexType idx;
 
     for (unsigned int y = 0; y < size[1]; y++)
     {
       for (unsigned int x = 0; x < size[0]; x++)
       {
         PixelType *pixel = static_cast<PixelType *>(textImage->GetScalarPointer(x, y, 0));
         RGBPixelType values;
         values.Fill(0);
         values[0] = pixel[1];
         values[1] = pixel[1];
         values[2] = pixel[1];
         idx.Fill(0);
         idx[0] = x;
         idx[1] = y;
 
         itkImage->SetPixel(idx, values);
       }
     }
 
     typedef itk::PermuteAxesImageFilter<RGB2DImage> PermuteAxesImageFilterType;
 
     itk::FixedArray<unsigned int, 2> order;
     order[0] = 1;
     order[1] = 0;
 
     PermuteAxesImageFilterType::Pointer permuteAxesFilter = PermuteAxesImageFilterType::New();
     permuteAxesFilter->SetInput(itkImage);
     permuteAxesFilter->SetOrder(order);
     permuteAxesFilter->Update();
 
     RGB2DImage::Pointer itkResultImage = RGB2DImage::New();
     itkResultImage->SetRegions(region);
     itkResultImage->Allocate();
 
     itkResultImage->Graft(permuteAxesFilter->GetOutput());
 
     return itkResultImage;
   }
 
   /**
    * @brief AddColouredOverlay - Overlays the rgbImage with an coloured overlay
    *
    * For all positions in overlayImage not zero, its value is multiplied the the colour value and added
    * to the rgbImage.
    *
    * @param rgbImage - input rgbImage to which the coloured overlay is added
    * @param overlayImage
    * @param color
    */
   void AddColouredOverlay(mitk::Image::Pointer rgbImage, mitk::Image::Pointer overlayImage, mitk::Color color)
   {
     unsigned int *dim = rgbImage->GetDimensions();
     itk::Image<PixelType, 3>::Pointer itkOverlayImage = itk::Image<PixelType, 3>::New();
     mitk::CastToItkImage(overlayImage.GetPointer(), itkOverlayImage);
     mitk::ImagePixelWriteAccessor<RGBPixelType, 3> writeAcc(rgbImage);
 
     itk::Index<3> idx;
     itk::RGBPixel<PixelType> value;
     unsigned short overlayVal = 0;
     // Fill rgb image with gray values
     for (idx[2] = 0; (unsigned int)idx[2] < dim[2]; idx[2]++)
     {
       for (idx[1] = 0; (unsigned int)idx[1] < dim[1]; idx[1]++)
       {
         for (idx[0] = 0; (unsigned int)idx[0] < dim[0]; idx[0]++)
         {
           overlayVal = 255 * itkOverlayImage->GetPixel(idx);
           value = writeAcc.GetPixelByIndex(idx);
           value[0] = std::min((int)(value[0] + overlayVal * color[0]), 254 * 255);
           value[1] = std::min((int)(value[1] + overlayVal * color[1]), 254 * 255);
           value[2] = std::min((int)(value[2] + overlayVal * color[2]), 254 * 255);
           writeAcc.SetPixelByIndex(idx, value);
         }
       }
     }
   }
 
   itk::Image<itk::RGBPixel<PixelType>, 2>::Pointer ExtractSlice(
     itk::Image<itk::RGBPixel<PixelType>, 3>::Pointer itkImage, unsigned int sliceNo)
   {
     typedef itk::Image<RGBPixelType, 3> InputImageType;
     typedef itk::Image<RGBPixelType, 2> OutputImageType;
 
     int dim[3];
     dim[0] = itkImage->GetLargestPossibleRegion().GetSize()[0];
     dim[1] = itkImage->GetLargestPossibleRegion().GetSize()[1];
     dim[2] = itkImage->GetLargestPossibleRegion().GetSize()[2];
 
     itk::Index<3> desiredStart;
     itk::Size<3> desiredSize;
 
     // case AXIAL: // 3rd dimension fixed
     desiredStart.Fill(0);
     desiredStart[2] = sliceNo;
     desiredSize.Fill(0);
     desiredSize[0] = dim[0];
     desiredSize[1] = dim[1];
     desiredSize[2] = 0;
 
     itk::ImageRegion<3> desiredRegion(desiredStart, desiredSize);
 
     // Extract slice
     itk::ExtractImageFilter<InputImageType, OutputImageType>::Pointer extractSlice =
       itk::ExtractImageFilter<InputImageType, OutputImageType>::New();
     extractSlice->SetInput(itkImage);
     extractSlice->SetExtractionRegion(desiredRegion);
     extractSlice->SetDirectionCollapseToIdentity();
     extractSlice->Update();
 
     return extractSlice->GetOutput();
   }
 };
 
 static std::string GetName(std::string fileName, std::string suffix = "_T2.nrrd")
 {
   fileName = itksys::SystemTools::GetFilenameName(fileName);
   return fileName.substr(0, fileName.length() - suffix.length() - 11); // 10 = date length
 }
 
 static std::string GetDate(std::string fileName, std::string suffix = "_T2.nrrd")
 {
   fileName = itksys::SystemTools::GetFilenameName(fileName);
   fileName = fileName.substr(fileName.length() - suffix.length() - 10, 10); // 10 = date length
   return fileName;
 }
 
 static ImageList LoadPreprocessedFiles(FileList files)
 {
   ImageList images;
   for (unsigned int i = 0; i < files.size(); ++i)
   {
     images.push_back(mitk::IOUtil::LoadImage(files.at(i)));
   }
   return images;
 }
 
 int main(int argc, char *argv[])
 {
   // Parse Command-Line Arguments
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
 
   parser.setTitle("Tumor Progression Mapping");
   parser.setCategory("Preprocessing Tools");
   parser.setContributor("MBI");
   parser.setDescription("Convert a set of co-registered and resampled follow-up images into a 2D png overview (and "
                         "optionally in a 4D NRRD Volume).\nNaming convecntion of files is "
                         "IDENTIFIER_YYYY-MM-DD_MODALITY.nrrd");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input folder containing all follow ups");
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file (PNG)");
   parser.addArgument("blanked", "b", mitkCommandLineParser::Bool, "Only Display Morphology");
   parser.addArgument("morphology", "m", mitkCommandLineParser::String, "Morphology postfix.", "_T2.nrrd");
   parser.addArgument(
     "segmentation", "s", mitkCommandLineParser::String, "Segmentation postfix. Default: _GTV.nrrd", "_GTV.nrrd");
   parser.addArgument("4dVolume", "v", mitkCommandLineParser::OutputFile, "Filepath to merged 4d NRRD Volume.");
   parser.addArgument(
     "skip", "k", mitkCommandLineParser::Int, "Number of slices to be skipped from top and from button (Default 0)");
   parser.addArgument(
     "interval", "n", mitkCommandLineParser::Int, "1 - for all slices, 2 - every second, 3 - every third ...");
   parser.addArgument("opacity", "c", mitkCommandLineParser::Float, "Opacity of overlay [0,1] invisible -> visible");
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size() == 0)
     return EXIT_SUCCESS;
 
   // Show a help message
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   std::string outputFile;
   std::string inputFolder;
 
   if (parsedArgs.count("input") || parsedArgs.count("i"))
   {
     inputFolder = us::any_cast<string>(parsedArgs["input"]) + "/";
   }
 
   if (parsedArgs.count("output") || parsedArgs.count("o"))
   {
     outputFile = us::any_cast<string>(parsedArgs["output"]);
   }
 
   int skip = 0;
   int interval = 1;
   float opacity = .3;
 
   if (parsedArgs.count("skip") || parsedArgs.count("k"))
   {
     skip = us::any_cast<int>(parsedArgs["skip"]);
   }
 
   if (parsedArgs.count("interval") || parsedArgs.count("n"))
   {
     interval = us::any_cast<int>(parsedArgs["interval"]);
   }
 
   if (parsedArgs.count("opacity") || parsedArgs.count("c"))
   {
     opacity = us::any_cast<float>(parsedArgs["opacity"]);
   }
 
   FileList morphFiles;
   FileList segFiles;
 
   std::string refPattern;
   std::string segPattern;
 
   if (parsedArgs.count("morphology") || parsedArgs.count("m"))
   {
     refPattern = us::any_cast<std::string>(parsedArgs["morphology"]);
   }
   else
     return EXIT_FAILURE;
 
   if (parsedArgs.count("segmentation") || parsedArgs.count("s"))
   {
     segPattern = us::any_cast<std::string>(parsedArgs["segmentation"]);
   }
 
   bool blank = false;
   if (parsedArgs.count("blanked") || parsedArgs.count("b"))
   {
     blank = true;
   }
   /// END Parsing CL Options
   typedef itk::Image<RGBPixelType, 2> OutputImageType;
   typedef itk::Image<RGBPixelType, 3> InputImageType;
 
   mitkProgressionVisualization progressVis;
 
   morphFiles = CreateFileList(inputFolder, refPattern);
   segFiles = CreateFileList(inputFolder, segPattern);
 
   ImageList morphImages = LoadPreprocessedFiles(morphFiles);
   ImageList segImages;
   if (segFiles.size() > 0 && blank == false)
     segImages = LoadPreprocessedFiles(segFiles);
 
   mitk::Image::Pointer rgbImage;
 
   // define color for overlay image
   mitk::Color color;
   color.Fill(0);
   color[0] = 200 * opacity;
   color[1] = 0;
 
   //  Set up itk time image filter to contain 0..N-1 images
   itk::TileImageFilter<OutputImageType, OutputImageType>::Pointer tileFilter =
     itk::TileImageFilter<OutputImageType, OutputImageType>::New();
   itk::FixedArray<unsigned int, 2> layout;
   unsigned int noOfTimeSteps = morphImages.size();
   layout[0] = noOfTimeSteps;
   layout[1] = 0; // automatic number of neccessary rows
   tileFilter->SetLayout(layout);
 
   // Get Reference image (all images are expected to have exact same dimensions!)
 
   std::string fileName = morphFiles.at(0);
   mitk::Image *referenceImg = morphImages.at(0);
 
   mitk::Image::Pointer merged4D;
   std::string volumeFile;
 
   if (parsedArgs.count("4dVolume") || parsedArgs.count("v"))
   {
     volumeFile = us::any_cast<string>(parsedArgs["4dVolume"]);
     if (volumeFile != "")
     {
       unsigned int *dims = new unsigned int[4];
       dims[0] = referenceImg->GetDimensions()[0];
       dims[1] = referenceImg->GetDimensions()[1];
       dims[2] = referenceImg->GetDimensions()[2];
       dims[3] = morphImages.size();
       merged4D = mitk::Image::New();
       merged4D->Initialize(referenceImg->GetPixelType(), 4, dims);
       merged4D->GetTimeGeometry()->Expand(noOfTimeSteps);
     }
   }
 
   unsigned int *dim = referenceImg->GetDimensions();
   unsigned int sliceMaxAxial = dim[2];
 
   // Now iterate over all data sets, extract overlay and add it to reference image
   mitk::Image *morphImage;
   mitk::Image *segmentationImage = NULL;
 
   for (unsigned int i = 0; i < noOfTimeSteps; i++)
   {
     MITK_INFO << "File : " << i << " of /" << noOfTimeSteps;
     int currentSliceNo = 0;
 
     // Retrieve images of current time step
     fileName = morphFiles.at(i);
     morphImage = morphImages.at(i);
 
     // Create 4D Volume image
     if (volumeFile != "")
     {
       mitk::ImagePixelReadAccessor<InputPixelType, 3> readAc(morphImage);
 
       merged4D->GetGeometry(i)->SetSpacing(referenceImg->GetGeometry()->GetSpacing());
       merged4D->GetGeometry(i)->SetOrigin(referenceImg->GetGeometry()->GetOrigin());
       merged4D->GetGeometry(i)->SetIndexToWorldTransform(referenceImg->GetGeometry()->GetIndexToWorldTransform());
       merged4D->SetVolume(readAc.GetData(), i);
     }
 
     MITK_INFO << "-- Convert to RGB";
     rgbImage = progressVis.ConvertToRGBImage(morphImage);
 
     // Add current seg in red
     color.Fill(0);
     color[0] = 200 * opacity;
 
     if (!blank)
     {
       segmentationImage = segImages.at(i);
       if (segmentationImage != NULL)
       {
         MITK_INFO << "-- Add Overlay";
         progressVis.AddColouredOverlay(rgbImage, segmentationImage, color);
       }
     }
     // Add Segmentation of next time step in red
     if (i == 0)
     {
       MITK_INFO << "Skipping retro view in first time step";
     }
     else
     {
       color.Fill(0);
       // Add previous in green
       color[1] = 200 * opacity;
       if (!blank)
       {
         mitk::Image *nextSeg = segImages.at(i - 1);
         MITK_INFO << "-- Add Overlay of next Step";
         progressVis.AddColouredOverlay(rgbImage, nextSeg, color);
       }
     }
 
     // Now save all slices from overlay in output folder
     MITK_INFO << "-- Extract Slices";
     for (int slice = sliceMaxAxial - skip - 1; slice > skip; slice -= interval) // sliceMaxAxial/40.0f))
     {
       InputImageType::Pointer itkImage = InputImageType::New();
       InputImageType::Pointer itkImage2;
 
       mitk::CastToItkImage(rgbImage, itkImage);
       typedef itk::ImageDuplicator<InputImageType> DuplicatorType;
       DuplicatorType::Pointer duplicator = DuplicatorType::New();
       duplicator->SetInputImage(itkImage);
       duplicator->Update();
       itkImage2 = duplicator->GetOutput();
 
       itk::Image<RGBPixelType, 2>::Pointer extractedSlice = itk::Image<RGBPixelType, 2>::New();
       extractedSlice->Graft(progressVis.ExtractSlice(itkImage2, slice));
       tileFilter->SetInput(((currentSliceNo + 1) * (noOfTimeSteps) + i), extractedSlice);
 
       tileFilter->SetInput(i, progressVis.TextAsImage(GetDate(fileName)));
 
       currentSliceNo++;
     }
   }
 
   MITK_INFO << "Tile Filter Update";
   tileFilter->Update();
 
   // Write the output image
   typedef itk::ImageFileWriter<OutputImageType> WriterType;
   WriterType::Pointer writer = WriterType::New();
   writer->SetInput(tileFilter->GetOutput());
   std::string patientName;
 
   patientName = GetName(fileName);
 
   if (blank)
     writer->SetFileName(outputFile);
   else
     writer->SetFileName(outputFile);
 
   writer->Update();
   if (volumeFile != "")
     mitk::IOUtil::Save(merged4D, volumeFile);
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/TumorInvasionAnalysis/include/mitkDiffusionCollectionWriter.h b/Modules/TumorInvasionAnalysis/include/mitkDiffusionCollectionWriter.h
index 1ea5345e12..3752b6c800 100755
--- a/Modules/TumorInvasionAnalysis/include/mitkDiffusionCollectionWriter.h
+++ b/Modules/TumorInvasionAnalysis/include/mitkDiffusionCollectionWriter.h
@@ -1,80 +1,81 @@
 /*===================================================================
 
 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_DIFFUSIONCOLLECTION_WRITER_H
 #define MITK_DIFFUSIONCOLLECTION_WRITER_H
 
 #include "mitkCommon.h"
 #include "mitkDataCollection.h"
 #include "mitkDiffusionCollectionReader.h"
+#include <MitkTumorInvasionAnalysisExports.h>
 
 namespace mitk {
-  class DiffusionCollectionWriter
+  class MITKTUMORINVASIONANALYSIS_EXPORT DiffusionCollectionWriter
   {
   public:
 
     typedef float TensorScalar;
     /**
     * @brief ExportCollectionToFolder
     *
     * Creates an XML file and stores all data in the same folder as the xml file (creating sub-folders for sub-collections)
     *
     *
     * Naming Conventions (Neccessary for proper saving of these images):
     * DWI - Diffusion Weighted Images
     * DTI - Diffusion Tensor Images
     * FIB - Fiber Bundles
     *
     * @param dataCollection
     * @param xmlFile
     * @param filter - (optional) only items with names contained in this list are written, if list is empty all items are written
     * @return
     */
     static bool ExportCollectionToFolder(DataCollection* dataCollection, std::string xmlFile , std::vector<std::string> filter);
 
     static bool ExportCollectionToFolder(DataCollection* dataCollection, std::string xmlFile);
 
     /**
     * @brief SaveCollection - Stores data collection at original location
     *
     * Writes the collection back to the files given in the original XML file.
     * New data items are stored into the default location, which is relative to the XML file.
     *
     * If a XML file is provided the files are stored as stated above with the differences that a new XML file is generated and new files are saved
     * relative to the newly generated xml.
     *
     * @param dataCollection
     * @param filter
     * @param xmlFile
     * @return
     */
 
     static bool SaveCollection(DataCollection* dataCollection, std::vector<std::string> filter, std::string xmlFile  = "");
 
     static bool FolderToXml(std::string folder, std::string collectionType, std::string xmlFile, std::vector<std::string> filter, std::vector<std::string> seriesNames);
 
     // GTV last entry in filter list, this item will be made to TARGET
     static bool SingleFolderToXml(std::string folder, std::string xmlFile, std::vector<std::string> filter, std::vector<std::string> seriesNames, bool longDate = true, int skipUntil = 0, float months = 0);
 
   protected:
 
   private:
 
     static size_t GetIndexForinXMonths(DiffusionCollectionReader::FileListType fileList, float months, size_t curIndex, std::vector<std::string> filter);
   };
 } // namespace mitk
 
 #endif /* MITK_COLLECTION_WRITER_H */