diff --git a/Modules/DiffusionCore/IODataStructures/mitkFiberBundle.cpp b/Modules/DiffusionCore/IODataStructures/mitkFiberBundle.cpp
index 30b7de5..70f3858 100644
--- a/Modules/DiffusionCore/IODataStructures/mitkFiberBundle.cpp
+++ b/Modules/DiffusionCore/IODataStructures/mitkFiberBundle.cpp
@@ -1,2903 +1,2902 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkFiberBundle.h"
 
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkDiffusionFunctionCollection.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 <boost/progress.hpp>
 #include <vtkTransformPolyDataFilter.h>
 #include <mitkTransferFunction.h>
 #include <vtkLookupTable.h>
 #include <mitkLookupTable.h>
 #include <vtkCardinalSpline.h>
 #include <vtkAppendPolyData.h>
 
 const char* mitk::FiberBundle::FIBER_ID_ARRAY = "Fiber_IDs";
 
 mitk::FiberBundle::FiberBundle( vtkPolyData* fiberPolyData )
   : m_NumFibers(0)
 {
   m_TrackVisHeader.hdr_size = 0;
   m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   m_FiberWeights->SetName("FIBER_WEIGHTS");
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   if (fiberPolyData != nullptr)
     m_FiberPolyData = fiberPolyData;
   else
   {
     this->m_FiberPolyData->SetPoints(vtkSmartPointer<vtkPoints>::New());
     this->m_FiberPolyData->SetLines(vtkSmartPointer<vtkCellArray>::New());
   }
 
   this->UpdateFiberGeometry();
   this->GenerateFiberIds();
   this->ColorFibersByOrientation();
 }
 
 mitk::FiberBundle::~FiberBundle()
 {
 
 }
 
 mitk::FiberBundle::Pointer mitk::FiberBundle::GetDeepCopy()
 {
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(m_FiberPolyData);
   newFib->SetFiberColors(this->m_FiberColors);
   newFib->SetFiberWeights(this->m_FiberWeights);
   newFib->SetTrackVisHeader(this->GetTrackVisHeader());
   return newFib;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GeneratePolyDataByIds(std::vector<unsigned int> fiberIds, vtkSmartPointer<vtkFloatArray> weights)
 {
   vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
   weights->SetNumberOfValues(fiberIds.size());
 
   int counter = 0;
   auto finIt = fiberIds.begin();
   while ( finIt != fiberIds.end() )
   {
     if (*finIt>GetNumFibers()){
       MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
       break;
     }
 
     vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
     vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
     vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
     newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
 
     for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
     {
       newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
       newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
     }
 
     weights->InsertValue(counter, this->GetFiberWeight(*finIt));
     newLineSet->InsertNextCell(newFiber);
     ++finIt;
     ++counter;
   }
 
   newFiberPolyData->SetPoints(newPointSet);
   newFiberPolyData->SetLines(newLineSet);
   return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundles(std::vector< mitk::FiberBundle::Pointer > fibs)
 {
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   // add current fiber bundle
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 
   auto num_weights = this->GetNumFibers();
   for (auto fib : fibs)
     num_weights += fib->GetNumFibers();
   weights->SetNumberOfValues(num_weights);
 
   unsigned int counter = 0;
   for (unsigned int i=0; i<m_FiberPolyData->GetNumberOfCells(); ++i)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (unsigned int j=0; j<numPoints; ++j)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, this->GetFiberWeight(i));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   for (auto fib : fibs)
   {
     // add new fiber bundle
     for (unsigned int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
     {
       vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
       auto numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       for (unsigned int j=0; j<numPoints; j++)
       {
         double p[3];
         points->GetPoint(j, p);
 
         vtkIdType id = vNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       weights->InsertValue(counter, fib->GetFiberWeight(i));
       vNewLines->InsertNextCell(container);
       counter++;
     }
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   newFib->SetFiberWeights(weights);
   return newFib;
 }
 
 // merge two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::AddBundle(mitk::FiberBundle* fib)
 {
   if (fib==nullptr)
     return this->GetDeepCopy();
 
   MITK_INFO << "Adding fibers";
 
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   // add current fiber bundle
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
 
   unsigned int counter = 0;
   for (unsigned int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (unsigned 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 (unsigned int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
     vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (unsigned int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, fib->GetFiberWeight(i));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   newFib->SetFiberWeights(weights);
   return newFib;
 }
 
 // Only retain fibers with a weight larger than the specified threshold
 mitk::FiberBundle::Pointer mitk::FiberBundle::FilterByWeights(float weight_thr, bool invert)
 {
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   std::vector<float> weights;
 
   for (unsigned int i=0; i<this->GetNumFibers(); i++)
   {
     if ( (invert && this->GetFiberWeight(i)>weight_thr) || (!invert && this->GetFiberWeight(i)<=weight_thr))
       continue;
 
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
     weights.push_back(this->GetFiberWeight(i));
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   for (unsigned int i=0; i<weights.size(); ++i)
     newFib->SetFiberWeight(i, weights.at(i));
   newFib->SetTrackVisHeader(this->GetTrackVisHeader());
   return newFib;
 }
 
 // Only retain a subsample of the fibers
 mitk::FiberBundle::Pointer mitk::FiberBundle::SubsampleFibers(float factor, bool random_seed)
 {
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   unsigned int new_num_fibs = static_cast<unsigned int>(std::round(this->GetNumFibers()*factor));
   MITK_INFO << "Subsampling fibers with factor " << factor << "(" << new_num_fibs << "/" << this->GetNumFibers() << ")";
 
   // add current fiber bundle
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   weights->SetNumberOfValues(new_num_fibs);
 
   std::vector< unsigned int > ids;
   for (unsigned int i=0; i<this->GetNumFibers(); i++)
     ids.push_back(i);
   if (random_seed)
     std::srand(static_cast<unsigned int>(std::time(nullptr)));
   else
     std::srand(0);
   std::random_shuffle(ids.begin(), ids.end());
 
   unsigned int counter = 0;
   for (unsigned int i=0; i<new_num_fibs; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(ids.at(i));
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
 
       vtkIdType id = vNewPoints->InsertNextPoint(p);
       container->GetPointIds()->InsertNextId(id);
     }
     weights->InsertValue(counter, this->GetFiberWeight(ids.at(i)));
     vNewLines->InsertNextCell(container);
     counter++;
   }
 
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(vNewPolyData);
   newFib->SetFiberWeights(weights);
   newFib->SetTrackVisHeader(this->GetTrackVisHeader());
   return newFib;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundle::Pointer mitk::FiberBundle::SubtractBundle(mitk::FiberBundle* fib)
 {
   if (fib==nullptr)
     return this->GetDeepCopy();
 
   MITK_INFO << "Subtracting fibers";
   vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   std::vector< std::vector< itk::Point<float, 3> > > points1;
   for(unsigned int i=0; i<m_NumFibers; i++ )
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (points==nullptr || numPoints<=0)
       continue;
 
     itk::Point<float, 3> start = mitk::imv::GetItkPoint(points->GetPoint(0));
     itk::Point<float, 3> end = mitk::imv::GetItkPoint(points->GetPoint(numPoints-1));
 
     points1.push_back( {start, end} );
   }
 
   std::vector< std::vector< itk::Point<float, 3> > > points2;
   for(unsigned int i=0; i<fib->GetNumFibers(); i++ )
   {
     vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (points==nullptr || numPoints<=0)
       continue;
 
     itk::Point<float, 3> start =mitk::imv::GetItkPoint(points->GetPoint(0));
     itk::Point<float, 3> end =mitk::imv::GetItkPoint(points->GetPoint(numPoints-1));
 
     points2.push_back( {start, end} );
   }
 
   //  int progress = 0;
   std::vector< int > ids;
 #pragma omp parallel for
   for (int i=0; i<static_cast<int>(points1.size()); i++)
   {
     bool match = false;
     for (unsigned int j=0; j<points2.size(); j++)
     {
       auto v1 = points1.at(static_cast<unsigned int>(i));
       auto v2 = points2.at(j);
 
       float dist=0;
       for (unsigned int c=0; c<v1.size(); c++)
       {
         float d = v1[c][0]-v2[c][0];
         dist += d*d;
 
         d = v1[c][1]-v2[c][1];
         dist += d*d;
 
         d = v1[c][2]-v2[c][2];
         dist += d*d;
       }
       dist /= v1.size();
 
       if (dist<0.000001f)
       {
         match = true;
         break;
       }
 
       dist=0;
       for (unsigned int c=0; c<v1.size(); c++)
       {
         float d = v1[v1.size()-1-c][0]-v2[c][0];
         dist += d*d;
 
         d = v1[v1.size()-1-c][1]-v2[c][1];
         dist += d*d;
 
         d = v1[v1.size()-1-c][2]-v2[c][2];
         dist += d*d;
       }
       dist /= v1.size();
 
       if (dist<0.000001f)
       {
         match = true;
         break;
       }
     }
 
 #pragma omp critical
     if (!match)
       ids.push_back(i);
   }
 
   for( int i : ids )
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (points==nullptr || numPoints<=0)
       continue;
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for( int j=0; j<numPoints; j++)
     {
       vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
   if(vNewLines->GetNumberOfCells()==0)
     return mitk::FiberBundle::New();
   // initialize PolyData
   vNewPolyData->SetPoints(vNewPoints);
   vNewPolyData->SetLines(vNewLines);
 
   // initialize fiber bundle
   return mitk::FiberBundle::New(vNewPolyData);
 }
 
 /*
  * 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->CopyStructure(fiberPD);
 //    m_FiberPolyData->DeepCopy(fiberPD);
   }
 
   m_NumFibers = static_cast<unsigned int>(m_FiberPolyData->GetNumberOfLines());
 
   if (updateGeometry)
     UpdateFiberGeometry();
   GenerateFiberIds();
   ColorFibersByOrientation();
 }
 
 /*
  * return vtkPolyData
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundle::GetFiberPolyData() const
 {
   return m_FiberPolyData;
 }
 
 void mitk::FiberBundle::ColorFibersByLength(bool opacity, bool weight_fibers, mitk::LookupTable::LookupTableType type)
 {
   if (m_MaxFiberLength<=0)
     return;
 
   auto numOfPoints = this->GetNumberOfPoints();
 
   //colors and alpha value for each single point, RGBA = 4 components
   unsigned char rgba[4] = {0,0,0,0};
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(numOfPoints * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
   auto numOfFibers = m_FiberPolyData->GetNumberOfLines();
   if (numOfFibers < 1)
     return;
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   mitkLookup->SetType(type);
   if (type!=mitk::LookupTable::MULTILABEL)
     mitkLookup->GetVtkLookupTable()->SetTableRange(m_MinFiberLength, m_MaxFiberLength);
 
   unsigned int count = 0;
   for (unsigned int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
 
     float l = m_FiberLengths.at(i)/m_MaxFiberLength;
     double color[3];
     mitkLookup->GetColor(m_FiberLengths.at(i), color);
 
     for (int j=0; j<numPoints; j++)
     {
 
       rgba[0] = static_cast<unsigned char>(255.0 * color[0]);
       rgba[1] = static_cast<unsigned char>(255.0 * color[1]);
       rgba[2] = static_cast<unsigned char>(255.0 * color[2]);
       if (opacity)
         rgba[3] = static_cast<unsigned char>(255.0f * l);
       else
         rgba[3] = static_cast<unsigned char>(255.0);
       m_FiberColors->InsertTypedTuple(cell->GetPointId(j), rgba);
       count++;
     }
 
     if (weight_fibers)
       this->SetFiberWeight(i, m_FiberLengths.at(i));
   }
 
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ColorSinglePoint(int f_idx, int p_idx, double rgb[3])
 {
 //  vtkPoints* extrPoints = m_FiberPolyData->GetPoints();
 //  vtkIdType 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};
 //  m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
 //  m_FiberColors->Allocate(numOfPoints * 4);
 //  m_FiberColors->SetNumberOfComponents(4);
 //  m_FiberColors->SetName("FIBER_COLORS");
 
 //  auto 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 num_points; // number of points for current line
 ////    fiberList->GetNextCell(num_points, idList);
 //    fiberList->GetCell(f_idx, num_points, idList);
 
     vtkCell* cell = m_FiberPolyData->GetCell(f_idx);
 
 
 //    /* single fiber checkpoints: is number of points valid */
 //    if (p_idx < num_points)
 //    {
       rgba[0] = static_cast<unsigned char>(255.0 * rgb[0]);
       rgba[1] = static_cast<unsigned char>(255.0 * rgb[1]);
       rgba[2] = static_cast<unsigned char>(255.0 * rgb[2]);
       rgba[3] = 255;
 
       m_FiberColors->InsertTypedTuple(cell->GetPointId(p_idx), rgba);
 //    }
 //  }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 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 = m_FiberPolyData->GetPoints();
   vtkIdType 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};
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(numOfPoints * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
   auto 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 const* idList; // contains the point id's of the line
     vtkIdType pointsPerFiber; // number of points for current line
     fiberList->GetNextCell(pointsPerFiber, idList);
 
     /* single fiber checkpoints: is number of points valid */
     if (pointsPerFiber > 1)
     {
       /* operate on points of single fiber */
       for (int i=0; i <pointsPerFiber; ++i)
       {
         /* process all points elastV[0]ept starting and endpoint for calculating color value take current point, previous point and next point */
         if (i<pointsPerFiber-1 && i > 0)
         {
           /* The color value of the current point is influenced by the previous point and next point. */
           vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
           vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
           vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
           vnl_vector_fixed< double, 3 > diff1;
           diff1 = currentPntvtk - nextPntvtk;
 
           vnl_vector_fixed< double, 3 > diff2;
           diff2 = currentPntvtk - prevPntvtk;
 
           vnl_vector_fixed< double, 3 > diff;
           diff = (diff1 - diff2) / 2.0;
           diff.normalize();
 
           rgba[0] = static_cast<unsigned char>(255.0 * std::fabs(diff[0]));
           rgba[1] = static_cast<unsigned char>(255.0 * std::fabs(diff[1]));
           rgba[2] = static_cast<unsigned char>(255.0 * std::fabs(diff[2]));
           rgba[3] = static_cast<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] = static_cast<unsigned char>(255.0 * std::fabs(diff1[0]));
           rgba[1] = static_cast<unsigned char>(255.0 * std::fabs(diff1[1]));
           rgba[2] = static_cast<unsigned char>(255.0 * std::fabs(diff1[2]));
           rgba[3] = static_cast<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] = static_cast<unsigned char>(255.0 * std::fabs(diff2[0]));
           rgba[1] = static_cast<unsigned char>(255.0 * std::fabs(diff2[1]));
           rgba[2] = static_cast<unsigned char>(255.0 * std::fabs(diff2[2]));
           rgba[3] = static_cast<unsigned char>(255.0);
         }
         m_FiberColors->InsertTypedTuple(idList[i], rgba);
       }
     }
     else if (pointsPerFiber == 1)
     {
       /* a single point does not define a fiber (use vertex mechanisms instead */
       continue;
     }
     else
     {
       MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
       continue;
     }
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ColorFibersByCurvature(bool opacity, bool weight_fibers, mitk::LookupTable::LookupTableType type)
 {
   double window = 5;
 
   //colors and alpha value for each single point, RGBA = 4 components
   unsigned char rgba[4] = {0,0,0,0};
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
   std::vector< double > values;
   double min = 1;
   double max = 0;
   MITK_INFO << "Coloring fibers by curvature";
   boost::progress_display disp(static_cast<unsigned long>(m_FiberPolyData->GetNumberOfCells()));
 
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
     double mean_curv = 0;
 
     // calculate curvatures
     for (int j=0; j<numPoints; j++)
     {
       double dist = 0;
       int c = j;
       std::vector< vnl_vector_fixed< double, 3 > > vectors;
       vnl_vector_fixed< double, 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< double, 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);
         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< double, 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);
         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/itk::Math::pi;
       }
       if (vectors.size()>0)
         dev /= vectors.size();
 
       if (weight_fibers)
         mean_curv += dev;
       dev = 1.0-dev/180.0;
       values.push_back(dev);
       if (dev<min)
         min = dev;
       if (dev>max)
         max = dev;
     }
 
     if (weight_fibers)
       this->SetFiberWeight(i, mean_curv/numPoints);
   }
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   mitkLookup->SetType(type);
   if (type!=mitk::LookupTable::MULTILABEL)
     mitkLookup->GetVtkLookupTable()->SetTableRange(min, max);
 
   unsigned int count = 0;
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     for (int j=0; j<numPoints; j++)
     {
       double color[3];
       double dev = values.at(count);
       mitkLookup->GetColor(dev, color);
 
       rgba[0] = static_cast<unsigned char>(255.0 * color[0]);
       rgba[1] = static_cast<unsigned char>(255.0 * color[1]);
       rgba[2] = static_cast<unsigned char>(255.0 * color[2]);
 
       if (opacity)
         rgba[3] = static_cast<unsigned char>(255.0f * dev/max);
       else
         rgba[3] = static_cast<unsigned char>(255.0);
 
       m_FiberColors->InsertTypedTuple(cell->GetPointId(j), rgba);
       count++;
     }
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::SetFiberOpacity(vtkDoubleArray* FAValArray)
 {
   for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
   {
     double faValue = FAValArray->GetValue(i);
     faValue = faValue * 255.0;
     m_FiberColors->SetComponent(i,3, static_cast<unsigned char>(faValue) );
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ResetFiberOpacity()
 {
   for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
     m_FiberColors->SetComponent(i,3, 255.0 );
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity, bool weight_fibers, mitk::LookupTable::LookupTableType type, double max_cap, bool interpolate)
 {
   if (FAimage->GetPixelType().GetComponentTypeAsString()=="unsigned char" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="char" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="long" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="unsigned long" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="short" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="unsigned short" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="unsigned int" ||
            FAimage->GetPixelType().GetComponentTypeAsString()=="int")
   {
     typedef itk::Image<int, 3> ImageType;
     ImageType::Pointer itkImage = ImageType::New();
     CastToItkImage(FAimage, itkImage);
 
     ColorFibersByScalarMap<int>(itkImage, opacity, weight_fibers, type, max_cap, interpolate );
   }
   else
   {
     typedef itk::Image<float, 3> ImageType;
     ImageType::Pointer itkImage = ImageType::New();
     CastToItkImage(FAimage, itkImage);
 
     ColorFibersByScalarMap<float>(itkImage, opacity, weight_fibers, type, max_cap, interpolate );
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 template <typename TPixel>
 void mitk::FiberBundle::ColorFibersByScalarMap(typename itk::Image<TPixel, 3>::Pointer image, bool opacity, bool weight_fibers, mitk::LookupTable::LookupTableType type, double max_cap, bool interpolate)
 {
   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};
   vtkPoints* pointSet = m_FiberPolyData->GetPoints();
 
   if (type==mitk::LookupTable::MULTILABEL)
     interpolate = false;
 
   auto interpolator = itk::LinearInterpolateImageFunction< itk::Image<TPixel, 3>, float >::New();
   interpolator->SetInputImage(image);
 
   double min = 999999;
   double max = -999999;
 
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
     double mean_val = 0;
 
     for (int j=0; j<numPoints; j++)
     {
       double p[3];
       points->GetPoint(j, p);
       auto pixelValue = mitk::imv::GetImageValue<TPixel>(mitk::imv::GetItkPoint(p), interpolate, interpolator);
 
       if (pixelValue>max)
         max = pixelValue;
       if (pixelValue<min)
         min = pixelValue;
 
       if (weight_fibers)
         mean_val += pixelValue;
     }
 
     if (weight_fibers)
       this->SetFiberWeight(i, mean_val/numPoints);
   }
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   mitkLookup->SetType(type);
   if (type!=mitk::LookupTable::MULTILABEL)
     mitkLookup->GetVtkLookupTable()->SetTableRange(min, max*max_cap);
 
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
     itk::Point<float, 3> px;
     px[0] = pointSet->GetPoint(i)[0];
     px[1] = pointSet->GetPoint(i)[1];
     px[2] = pointSet->GetPoint(i)[2];
     auto pixelValue = mitk::imv::GetImageValue<TPixel>(px, interpolate, interpolator);
 
     double color[3];
     mitkLookup->GetColor(pixelValue, color);
 
     rgba[0] = static_cast<unsigned char>(255.0 * color[0]);
     rgba[1] = static_cast<unsigned char>(255.0 * color[1]);
     rgba[2] = static_cast<unsigned char>(255.0 * color[2]);
     if (opacity)
       rgba[3] = static_cast<unsigned char>(255.0 * pixelValue);
     else
       rgba[3] = static_cast<unsigned char>(255.0);
     m_FiberColors->InsertTypedTuple(i, rgba);
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 
 void mitk::FiberBundle::ColorFibersByFiberWeights(bool opacity, mitk::LookupTable::LookupTableType type)
 {
   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};
   unsigned int counter = 0;
 
   float max = -999999;
   float min = 999999;
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     float weight = this->GetFiberWeight(i);
     if (weight>max)
       max = weight;
     if (weight<min)
       min = weight;
   }
   if (fabs(max-min)<0.00001f)
   {
     max = 1;
     min = 0;
   }
 
   mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
   mitkLookup->SetType(type);
   if (type!=mitk::LookupTable::MULTILABEL)
     mitkLookup->GetVtkLookupTable()->SetTableRange(min, max);
 
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     auto weight = this->GetFiberWeight(i);
 
     double color[3];
     mitkLookup->GetColor(weight, color);
 
     for (int j=0; j<numPoints; j++)
     {
       rgba[0] = static_cast<unsigned char>(255.0 * color[0]);
       rgba[1] = static_cast<unsigned char>(255.0 * color[1]);
       rgba[2] = static_cast<unsigned char>(255.0 * color[2]);
       if (opacity)
         rgba[3] = static_cast<unsigned char>(255.0f * weight/max);
       else
         rgba[3] = static_cast<unsigned char>(255.0);
 
       m_FiberColors->InsertTypedTuple(counter, rgba);
       counter++;
     }
   }
 
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::SetSingleFiberColor(float r, float g, float b, unsigned int cellId, float alpha)
 {
 //    if (m_FiberColors==nullptr)
   m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
   m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
   m_FiberColors->SetNumberOfComponents(4);
   m_FiberColors->SetName("FIBER_COLORS");
 
 //  MITK_INFO << color->GetNumberOfTuples();
 //  MITK_INFO << m_FiberColors->GetNumberOfTuples();
 
   unsigned char rgba[4] = {0,0,0,0};
   unsigned int counter = 0;
 
 
   for (unsigned int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
   vtkCell* cell = m_FiberPolyData->GetCell(i);
   auto numPoints = cell->GetNumberOfPoints();
 
   if (i==cellId)
   {
-      MITK_INFO << i;
       for (int j=0; j<numPoints; j++)
       {
           rgba[0] = static_cast<unsigned char>(r);
           rgba[1] = static_cast<unsigned char>(b);
           rgba[2] = static_cast<unsigned char>(g);
           rgba[3] = static_cast<unsigned char>(alpha);
 //          m_FiberColors->InsertTypedTuple(j, rgba);
 
           m_FiberColors->InsertTypedTuple(counter, rgba);
           counter++;
        }
   }
   else {
       for (int j=0; j<numPoints; j++)
       {
           rgba[0] = static_cast<unsigned char>(255);
           rgba[1] = static_cast<unsigned char>(255);
           rgba[2] = static_cast<unsigned char>(255);
           rgba[3] = static_cast<unsigned char>(alpha);
 //          m_FiberColors->InsertTypedTuple(j, rgba);
 
           m_FiberColors->InsertTypedTuple(counter, rgba);
           counter++;
        }
   }
 
   }
 
 //  MITK_INFO << m_FiberColors->GetNumberOfTuples();
   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] = static_cast<unsigned char>(r);
     rgba[1] = static_cast<unsigned char>(g);
     rgba[2] = static_cast<unsigned char>(b);
     rgba[3] = static_cast<unsigned char>(alpha);
     m_FiberColors->InsertTypedTuple(i, rgba);
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundle::GenerateFiberIds()
 {
   if (m_FiberPolyData == nullptr)
     return;
 
   vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
   idFiberFilter->SetInputData(m_FiberPolyData);
   idFiberFilter->CellIdsOn();
   //  idFiberFilter->PointIdsOn(); // point id's are not needed
   idFiberFilter->SetCellIdsArrayName(FIBER_ID_ARRAY);
   idFiberFilter->FieldDataOn();
   idFiberFilter->Update();
 
   m_FiberIdDataSet = idFiberFilter->GetOutput();
 }
 
 float mitk::FiberBundle::GetNumEpFractionInMask(ItkUcharImgType* mask, bool different_label)
 {
   vtkSmartPointer<vtkPolyData> PolyData = m_FiberPolyData;
 
   MITK_INFO << "Calculating EP-Fraction";
 
   boost::progress_display disp(m_NumFibers);
   unsigned int in_mask = 0;
 
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = PolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     itk::Point<float, 3> startVertex =mitk::imv::GetItkPoint(points->GetPoint(0));
     itk::Index<3> startIndex;
     mask->TransformPhysicalPointToIndex(startVertex, startIndex);
 
     itk::Point<float, 3> endVertex =mitk::imv::GetItkPoint(points->GetPoint(numPoints-1));
     itk::Index<3> endIndex;
     mask->TransformPhysicalPointToIndex(endVertex, endIndex);
 
     if (mask->GetLargestPossibleRegion().IsInside(startIndex) && mask->GetLargestPossibleRegion().IsInside(endIndex))
     {
       float v1 = mask->GetPixel(startIndex);
       if (v1 < 0.5f)
         continue;
       float v2 = mask->GetPixel(startIndex);
       if (v2 < 0.5f)
         continue;
 
       if (!different_label)
         ++in_mask;
       else if (fabs(v1-v2)>0.00001f)
         ++in_mask;
     }
   }
   return float(in_mask)/m_NumFibers;
 }
 
 std::tuple<float, float> mitk::FiberBundle::GetDirectionalOverlap(ItkUcharImgType* mask, mitk::PeakImage::ItkPeakImageType* peak_image)
 {
   vtkSmartPointer<vtkPolyData> PolyData = m_FiberPolyData;
 
   MITK_INFO << "Calculating overlap";
   auto spacing = mask->GetSpacing();
   boost::progress_display disp(m_NumFibers);
   double length_sum = 0;
   double in_mask_length = 0;
   double aligned_length = 0;
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = PolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     for (int j=0; j<numPoints-1; j++)
     {
       itk::Point<float, 3> startVertex =mitk::imv::GetItkPoint(points->GetPoint(j));
       itk::Index<3> startIndex;
       itk::ContinuousIndex<float, 3> startIndexCont;
       mask->TransformPhysicalPointToIndex(startVertex, startIndex);
       mask->TransformPhysicalPointToContinuousIndex(startVertex, startIndexCont);
 
       itk::Point<float, 3> endVertex =mitk::imv::GetItkPoint(points->GetPoint(j + 1));
       itk::Index<3> endIndex;
       itk::ContinuousIndex<float, 3> endIndexCont;
       mask->TransformPhysicalPointToIndex(endVertex, endIndex);
       mask->TransformPhysicalPointToContinuousIndex(endVertex, endIndexCont);
       
       vnl_vector_fixed< float, 3 > fdir;
       fdir[0] = endVertex[0] - startVertex[0];
       fdir[1] = endVertex[1] - startVertex[1];
       fdir[2] = endVertex[2] - startVertex[2];
       fdir.normalize();
 
       std::vector< std::pair< itk::Index<3>, double > > segments = mitk::imv::IntersectImage(spacing, startIndex, endIndex, startIndexCont, endIndexCont);
       for (std::pair< itk::Index<3>, double > segment : segments)
       {
         if ( mask->GetLargestPossibleRegion().IsInside(segment.first) && mask->GetPixel(segment.first) > 0 )
         {
           in_mask_length += segment.second;
           
           mitk::PeakImage::ItkPeakImageType::IndexType idx4; 
           idx4[0] = segment.first[0]; 
           idx4[1] = segment.first[1]; 
           idx4[2] = segment.first[2];
           
           vnl_vector_fixed< float, 3 > peak;
           idx4[3] = 0;
           peak[0] = peak_image->GetPixel(idx4);
           idx4[3] = 1;
           peak[1] = peak_image->GetPixel(idx4);
           idx4[3] = 2;
           peak[2] = peak_image->GetPixel(idx4);
           if (std::isnan(peak[0]) || std::isnan(peak[1]) || std::isnan(peak[2]) || peak.magnitude()<0.0001f)
             continue;
           peak.normalize();
           
           double f = 1.0 - std::acos(std::fabs(static_cast<double>(dot_product(fdir, peak)))) * 2.0/itk::Math::pi;
           aligned_length += segment.second * f;
         }
         length_sum += segment.second;
       }
     }
   }
 
   if (length_sum<=0.0001)
   {
     MITK_INFO << "Fiber length sum is zero!";
     return std::make_tuple(0,0);
   }
   return std::make_tuple(aligned_length/length_sum, in_mask_length/length_sum);
 }
 
 float mitk::FiberBundle::GetOverlap(ItkUcharImgType* mask)
 {
   vtkSmartPointer<vtkPolyData> PolyData = m_FiberPolyData;
 
   MITK_INFO << "Calculating overlap";
   auto spacing = mask->GetSpacing();
   boost::progress_display disp(m_NumFibers);
   double length_sum = 0;
   double in_mask_length = 0;
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = PolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     for (int j=0; j<numPoints-1; j++)
     {
       itk::Point<float, 3> startVertex =mitk::imv::GetItkPoint(points->GetPoint(j));
       itk::Index<3> startIndex;
       itk::ContinuousIndex<float, 3> startIndexCont;
       mask->TransformPhysicalPointToIndex(startVertex, startIndex);
       mask->TransformPhysicalPointToContinuousIndex(startVertex, startIndexCont);
 
       itk::Point<float, 3> endVertex =mitk::imv::GetItkPoint(points->GetPoint(j + 1));
       itk::Index<3> endIndex;
       itk::ContinuousIndex<float, 3> endIndexCont;
       mask->TransformPhysicalPointToIndex(endVertex, endIndex);
       mask->TransformPhysicalPointToContinuousIndex(endVertex, endIndexCont);
 
       std::vector< std::pair< itk::Index<3>, double > > segments = mitk::imv::IntersectImage(spacing, startIndex, endIndex, startIndexCont, endIndexCont);
       for (std::pair< itk::Index<3>, double > segment : segments)
       {
         if ( mask->GetLargestPossibleRegion().IsInside(segment.first) && mask->GetPixel(segment.first) > 0 )
           in_mask_length += segment.second;
         length_sum += segment.second;
       }
     }
   }
 
   if (length_sum<=0.000001)
   {
     MITK_INFO << "Fiber length sum is zero!";
     return 0;
   }
   return static_cast<float>(in_mask_length/length_sum);
 }
 
 mitk::FiberBundle::Pointer mitk::FiberBundle::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
 {
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   std::vector< float > fib_weights;
 
   MITK_INFO << "Cutting fibers";
   boost::progress_display disp(m_NumFibers);
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
 
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     int newNumPoints = 0;
     if (numPoints>1)
     {
       for (int j=0; j<numPoints; j++)
       {
         itk::Point<float, 3> itkP =mitk::imv::GetItkPoint(points->GetPoint(j));
         itk::Index<3> idx;
         mask->TransformPhysicalPointToIndex(itkP, idx);
 
         bool inside = false;
         if ( mask->GetLargestPossibleRegion().IsInside(idx) && mask->GetPixel(idx)!=0 )
           inside = true;
 
         if (inside && !invert)
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(itkP.GetDataPointer());
           container->GetPointIds()->InsertNextId(id);
           newNumPoints++;
         }
         else if ( !inside && invert )
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(itkP.GetDataPointer());
           container->GetPointIds()->InsertNextId(id);
           newNumPoints++;
         }
         else if (newNumPoints>1)
         {
           fib_weights.push_back(this->GetFiberWeight(i));
           vtkNewCells->InsertNextCell(container);
           newNumPoints = 0;
           container = vtkSmartPointer<vtkPolyLine>::New();
         }
         else
         {
           newNumPoints = 0;
           container = vtkSmartPointer<vtkPolyLine>::New();
         }
       }
 
       if (newNumPoints>1)
       {
         fib_weights.push_back(this->GetFiberWeight(i));
         vtkNewCells->InsertNextCell(container);
       }
     }
 
   }
 
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(static_cast<vtkIdType>(fib_weights.size()));
 
   if (vtkNewCells->GetNumberOfCells()<=0)
     return nullptr;
 
   for (unsigned int i=0; i<newFiberWeights->GetNumberOfValues(); i++)
     newFiberWeights->SetValue(i, fib_weights.at(i));
 
 //  vtkSmartPointer<vtkUnsignedCharArray> newFiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
 //  newFiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
 //  newFiberColors->SetNumberOfComponents(4);
 //  newFiberColors->SetName("FIBER_COLORS");
 
 //  unsigned char rgba[4] = {0,0,0,0};
 //  for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
 //  {
 //    rgba[0] = (unsigned char) r;
 //    rgba[1] = (unsigned char) g;
 //    rgba[2] = (unsigned char) b;
 //    rgba[3] = (unsigned char) alpha;
 //    m_FiberColors->InsertTypedTuple(i, rgba);
 //  }
 
   vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
   newPolyData->SetPoints(vtkNewPoints);
   newPolyData->SetLines(vtkNewCells);
   mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(newPolyData);
   newFib->SetFiberWeights(newFiberWeights);
 //  newFib->Compress(0.1);
   newFib->SetTrackVisHeader(this->GetTrackVisHeader());
   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<unsigned int> tmp = ExtractFiberIdSubset(roi, storage);
 
   if (tmp.size()<=0)
     return mitk::FiberBundle::New();
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp, weights);
   mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
   fib->SetFiberWeights(weights);
   fib->SetTrackVisHeader(this->GetTrackVisHeader());
   return fib;
 }
 
 std::vector<unsigned int> mitk::FiberBundle::ExtractFiberIdSubset(DataNode *roi, DataStorage* storage)
 {
   std::vector<unsigned int> 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<unsigned int>::iterator it;
       for (unsigned int i=1; i<children->Size(); ++i)
       {
         std::vector<unsigned int> inRoi = this->ExtractFiberIdSubset(children->ElementAt(i), storage);
 
         std::vector<unsigned int> rest(std::min(result.size(),inRoi.size()));
         it = std::set_intersection(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
         rest.resize( static_cast<unsigned int>(it - rest.begin()) );
         result = rest;
       }
       break;
     }
     case 1: // OR
     {
       MITK_INFO << "OR";
       result = ExtractFiberIdSubset(children->ElementAt(0), storage);
       std::vector<unsigned int>::iterator it;
       for (unsigned int i=1; i<children->Size(); ++i)
       {
         it = result.end();
         std::vector<unsigned int> 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( static_cast<unsigned int>(it - result.begin()) );
       break;
     }
     case 2: // NOT
     {
       MITK_INFO << "NOT";
       for(unsigned int i=0; i<this->GetNumFibers(); i++)
         result.push_back(i);
 
       std::vector<unsigned int>::iterator it;
       for (unsigned int i=0; i<children->Size(); ++i)
       {
         std::vector<unsigned int> inRoi = ExtractFiberIdSubset(children->ElementAt(i), storage);
 
         std::vector<unsigned int> rest(result.size()-inRoi.size());
         it = std::set_difference(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
         rest.resize( static_cast<unsigned int>(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 (unsigned int i=0; i<m_NumFibers; i++)
       {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         auto 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 (unsigned int i=0; i<m_NumFibers; i++)
       {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         auto 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 = static_cast<unsigned int>(m_FiberPolyData->GetNumberOfCells());
 
   if (m_FiberColors==nullptr || m_FiberColors->GetNumberOfTuples()!=m_FiberPolyData->GetNumberOfPoints())
     this->ColorFibersByOrientation();
 
   if (m_FiberWeights->GetNumberOfValues()!=m_NumFibers)
   {
     m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     m_FiberWeights->SetName("FIBER_WEIGHTS");
     m_FiberWeights->SetNumberOfValues(m_NumFibers);
     this->SetFiberWeights(1);
   }
 
   if (m_NumFibers<=0) // no fibers present; apply default geometry
   {
     m_MinFiberLength = 0;
     m_MaxFiberLength = 0;
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetImageGeometry(false);
     float b[] = {0, 1, 0, 1, 0, 1};
     geometry->SetFloatBounds(b);
     SetGeometry(geometry);
     return;
   }
   double b[6];
   m_FiberPolyData->GetBounds(b);
 
   // calculate statistics
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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);
 
       double 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 += static_cast<float>(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 (unsigned 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);
 
   GetTrackVisHeader();
 
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 float mitk::FiberBundle::GetFiberWeight(unsigned int fiber) const
 {
   return m_FiberWeights->GetValue(fiber);
 }
 
 void mitk::FiberBundle::SetFiberWeights(float newWeight)
 {
   for (int i=0; i<m_FiberWeights->GetNumberOfValues(); i++)
     m_FiberWeights->SetValue(i, newWeight);
 }
 
 void mitk::FiberBundle::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
 {
   if (m_NumFibers!=weights->GetNumberOfValues())
   {
     MITK_INFO << "Weights array not equal to number of fibers! " << weights->GetNumberOfValues() << " vs " << m_NumFibers;
     return;
   }
 
   for (int i=0; i<weights->GetNumberOfValues(); i++)
     m_FiberWeights->SetValue(i, weights->GetValue(i));
 
   m_FiberWeights->SetName("FIBER_WEIGHTS");
 }
 
 void mitk::FiberBundle::SetFiberWeight(unsigned int fiber, float weight)
 {
   m_FiberWeights->SetValue(fiber, weight);
 }
 
 void mitk::FiberBundle::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
 {
   for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
   {
     unsigned char source[4] = {0,0,0,0};
     fiberColors->GetTypedTuple(i, source);
 
     unsigned char target[4] = {0,0,0,0};
     target[0] = source[0];
     target[1] = source[1];
     target[2] = source[2];
     target[3] = source[3];
     m_FiberColors->InsertTypedTuple(i, target);
   }
   m_UpdateTime3D.Modified();
   m_UpdateTime2D.Modified();
 }
 
 itk::Matrix< double, 3, 3 > mitk::FiberBundle::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
 {
   rx = rx*itk::Math::pi/180;
   ry = ry*itk::Math::pi/180;
   rz = rz*itk::Math::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;
 }
 
 void mitk::FiberBundle::TransformFibers(itk::ScalableAffineTransform< mitk::ScalarType >::Pointer transform)
 {
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     for (int j=0; j<numPoints; j++)
     {
       itk::Point<float, 3> p =mitk::imv::GetItkPoint(points->GetPoint(j));
       p = transform->TransformPoint(p);
       vtkIdType id = vtkNewPoints->InsertNextPoint(p.GetDataPointer());
       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::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
 {
   vnl_matrix_fixed< double, 3, 3 > rot = mitk::imv::GetRotationMatrixVnl(rx, ry, rz);
 
   mitk::BaseGeometry::Pointer geom = this->GetGeometry();
   mitk::Point3D center = geom->GetCenter();
 
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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*itk::Math::pi/180;
   y = y*itk::Math::pi/180;
   z = z*itk::Math::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 (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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 (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp ;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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 (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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 (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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(static_cast<unsigned long>(m_FiberPolyData->GetNumberOfCells()));
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     ++disp ;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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(static_cast<unsigned long>(m_FiberPolyData->GetNumberOfCells()));
   for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
   {
     ++disp ;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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] = static_cast<float>(p2[0]-p1[0]);
       v1[1] = static_cast<float>(p2[1]-p1[1]);
       v1[2] = static_cast<float>(p2[2]-p1[2]);
 
       v2[0] = static_cast<float>(p3[0]-p2[0]);
       v2[1] = static_cast<float>(p3[1]-p2[1]);
       v2[2] = static_cast<float>(p3[2]-p2[2]);
 
       v3[0] = static_cast<float>(p1[0]-p3[0]);
       v3[1] = static_cast<float>(p1[1]-p3[1]);
       v3[2] = static_cast<float>(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 (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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 (unsigned int i=0; i<m_NumFibers; i++)
   {
     ++disp;
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto 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
 
   MITK_INFO << "Smoothing fibers";
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(m_NumFibers);
 
   std::vector< vtkSmartPointer<vtkPolyLine> > resampled_streamlines;
   resampled_streamlines.resize(m_NumFibers);
 
   boost::progress_display disp(m_NumFibers);
 #pragma omp parallel for
   for (int i=0; i<static_cast<int>(m_NumFibers); i++)
   {
     vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
     float length = 0;
 #pragma omp critical
     {
       length = m_FiberLengths.at(static_cast<unsigned int>(i));
       ++disp;
       vtkCell* cell = m_FiberPolyData->GetCell(i);
       auto numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
       for (int j=0; j<numPoints; j++)
         newPoints->InsertNextPoint(points->GetPoint(j));
     }
 
     int sampling = static_cast<int>(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();
 
 #pragma omp critical
     {
       for (int j=0; j<tmpSmoothPnts->GetNumberOfPoints(); j++)
       {
         vtkIdType id = vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
         smoothLine->GetPointIds()->InsertNextId(id);
       }
 
       resampled_streamlines[static_cast<unsigned long>(i)] = smoothLine;
     }
   }
 
   for (auto container : resampled_streamlines)
   {
     vtkSmoothCells->InsertNextCell(container);
   }
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_FiberPolyData->SetPoints(vtkSmoothPoints);
   m_FiberPolyData->SetLines(vtkSmoothCells);
   this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundle::ResampleSpline(float pointDistance)
 {
   ResampleSpline(pointDistance, 0, 0, 0 );
 }
 
 unsigned int mitk::FiberBundle::GetNumberOfPoints() const
 {
   unsigned int 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 with max. error " << error << "mm";
   unsigned int numRemovedPoints = 0;
   boost::progress_display disp(static_cast<unsigned long>(m_FiberPolyData->GetNumberOfCells()));
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(m_NumFibers);
 
 #pragma omp parallel for
   for (int i=0; i<static_cast<int>(m_FiberPolyData->GetNumberOfCells()); i++)
   {
 
     std::vector< vnl_vector_fixed< double, 3 > > vertices;
     float weight = 1;
 
 #pragma omp critical
     {
       ++disp;
       weight = m_FiberWeights->GetValue(i);
       vtkCell* cell = m_FiberPolyData->GetCell(i);
       auto 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
     auto numPoints = vertices.size();
     std::vector< int > removedPoints; removedPoints.resize(numPoints, 0);
     removedPoints[0]=-1; removedPoints[numPoints-1]=-1;
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     unsigned int remCounter = 0;
 
     bool pointFound = true;
     while (pointFound)
     {
       pointFound = false;
       double minError = static_cast<double>(error);
       unsigned int removeIndex = 0;
 
       for (unsigned int j=0; j<vertices.size(); j++)
       {
         if (removedPoints[j]==0)
         {
           vnl_vector_fixed< double, 3 > candV = vertices.at(j);
 
           int validP = -1;
           vnl_vector_fixed< double, 3 > pred;
           for (int k=static_cast<int>(j)-1; k>=0; k--)
             if (removedPoints[static_cast<unsigned int>(k)]<=0)
             {
               pred = vertices.at(static_cast<unsigned int>(k));
               validP = k;
               break;
             }
           int validS = -1;
           vnl_vector_fixed< double, 3 > succ;
           for (unsigned int k=j+1; k<numPoints; k++)
             if (removedPoints[k]<=0)
             {
               succ = vertices.at(k);
               validS = static_cast<int>(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 (unsigned int j=0; j<numPoints; j++)
     {
       if (removedPoints[j]<=0)
       {
 #pragma omp critical
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(vertices.at(j).data_block());
           container->GetPointIds()->InsertNextId(id);
         }
       }
     }
 
 #pragma omp critical
     {
       newFiberWeights->SetValue(vtkNewCells->GetNumberOfCells(), weight);
       numRemovedPoints += remCounter;
       vtkNewCells->InsertNextCell(container);
     }
   }
 
   if (vtkNewCells->GetNumberOfCells()>0)
   {
     MITK_INFO << "Removed points: " << numRemovedPoints;
     SetFiberWeights(newFiberWeights);
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
   }
 }
 
 void mitk::FiberBundle::ResampleToNumPoints(unsigned int targetPoints)
 {
   if (targetPoints<2)
     mitkThrow() << "Minimum two points required for resampling!";
 
   MITK_INFO << "Resampling fibers (number of points " << targetPoints << ")";
 
   bool unequal_fibs = true;
   while (unequal_fibs)
   {
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     newFiberWeights->SetName("FIBER_WEIGHTS");
     newFiberWeights->SetNumberOfValues(m_NumFibers);
 
     unequal_fibs = false;
     MITK_INFO << "Start";
 //    cv::parallel_for_(cv::Range(0, m_FiberPolyData->GetNumberOfCells()), [&](const cv::Range &range)
 //    {
 //        for (int i = range.start; i < range.end; i++)
     for (unsigned int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
 
       std::vector< vnl_vector_fixed< double, 3 > > vertices;
       float weight = 1;
       double seg_len = 0;
 
       {
         weight = m_FiberWeights->GetValue(i);
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         auto numPoints = cell->GetNumberOfPoints();
         if (numPoints!=targetPoints)
           seg_len = static_cast<double>(this->GetFiberLength(i)/(targetPoints-1));
         vtkPoints* points = cell->GetPoints();
 
         for (int j=0; j<numPoints; j++)
         {
           double cand[3];
           points->GetPoint(j, cand);
           vnl_vector_fixed< double, 3 > candV;
           candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
           vertices.push_back(candV);
         }
       }
 
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       vnl_vector_fixed< double, 3 > lastV = vertices.at(0);
 
       {
         vtkIdType id = vtkNewPoints->InsertNextPoint(lastV.data_block());
         container->GetPointIds()->InsertNextId(id);
       }
       for (unsigned int j=1; j<vertices.size(); j++)
       {
         vnl_vector_fixed< double, 3 > vec = vertices.at(j) - lastV;
         double new_dist = vec.magnitude();
 
         if (new_dist >= seg_len && seg_len>0)
         {
           vnl_vector_fixed< double, 3 > newV = lastV;
           if ( new_dist-seg_len <= mitk::eps )
           {
             vec.normalize();
             newV += vec * seg_len;
           }
           else
           {
             // intersection between sphere (radius 'pointDistance', center 'lastV') and line (direction 'd' and point 'p')
             vnl_vector_fixed< double, 3 > p = vertices.at(j-1);
             vnl_vector_fixed< double, 3 > d = vertices.at(j) - p;
 
             double a = d[0]*d[0] + d[1]*d[1] + d[2]*d[2];
             double b = 2 * (d[0] * (p[0] - lastV[0]) + d[1] * (p[1] - lastV[1]) + d[2] * (p[2] - lastV[2]));
             double c = (p[0] - lastV[0])*(p[0] - lastV[0]) + (p[1] - lastV[1])*(p[1] - lastV[1]) + (p[2] - lastV[2])*(p[2] - lastV[2]) - seg_len*seg_len;
 
             double v1 =(-b + std::sqrt(b*b-4*a*c))/(2*a);
             double v2 =(-b - std::sqrt(b*b-4*a*c))/(2*a);
 
             if (v1>0)
               newV = p + d * v1;
             else if (v2>0)
               newV = p + d * v2;
             else
               MITK_INFO << "ERROR1 - linear resampling";
 
             j--;
           }
 
 //#pragma omp critical
           {
             vtkIdType id = vtkNewPoints->InsertNextPoint(newV.data_block());
             container->GetPointIds()->InsertNextId(id);
           }
           lastV = newV;
         }
         else if ( (j==vertices.size()-1 && new_dist>0.0001) || seg_len<=0.0000001)
         {
 //#pragma omp critical
           {
             vtkIdType id = vtkNewPoints->InsertNextPoint(vertices.at(j).data_block());
             container->GetPointIds()->InsertNextId(id);
           }
         }
       }
 
 //#pragma omp critical
       {
         newFiberWeights->SetValue(vtkNewCells->GetNumberOfCells(), weight);
         vtkNewCells->InsertNextCell(container);
         if (container->GetNumberOfPoints()!=targetPoints)
           unequal_fibs = true;
       }
     }
 //    });
 //    MITK_INFO << "Done";
 
     if (vtkNewCells->GetNumberOfCells()>0)
     {
       SetFiberWeights(newFiberWeights);
       m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
       m_FiberPolyData->SetPoints(vtkNewPoints);
       m_FiberPolyData->SetLines(vtkNewCells);
       this->SetFiberPolyData(m_FiberPolyData, true);
     }
   }
 }
 
 void mitk::FiberBundle::ResampleLinear(double pointDistance)
 {
   vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
   MITK_INFO << "Resampling fibers (linear)";
   boost::progress_display disp(static_cast<unsigned long>(m_FiberPolyData->GetNumberOfCells()));
   vtkSmartPointer<vtkFloatArray> newFiberWeights = vtkSmartPointer<vtkFloatArray>::New();
   newFiberWeights->SetName("FIBER_WEIGHTS");
   newFiberWeights->SetNumberOfValues(m_NumFibers);
 
   std::vector< vtkSmartPointer<vtkPolyLine> > resampled_streamlines;
   resampled_streamlines.resize(static_cast<unsigned long>(m_FiberPolyData->GetNumberOfCells()));
 
 #pragma omp parallel for
   for (int i=0; i<static_cast<int>(m_FiberPolyData->GetNumberOfCells()); i++)
   {
 
     std::vector< vnl_vector_fixed< double, 3 > > vertices;
 
 #pragma omp critical
     {
       ++disp;
       vtkCell* cell = m_FiberPolyData->GetCell(i);
       auto numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       for (int j=0; j<numPoints; j++)
       {
         double cand[3];
         points->GetPoint(j, cand);
         vnl_vector_fixed< double, 3 > candV;
         candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
         vertices.push_back(candV);
       }
     }
 
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     vnl_vector_fixed< double, 3 > lastV = vertices.at(0);
 
 #pragma omp critical
     {
       vtkIdType id = vtkNewPoints->InsertNextPoint(lastV.data_block());
       container->GetPointIds()->InsertNextId(id);
     }
     for (unsigned int j=1; j<vertices.size(); j++)
     {
       vnl_vector_fixed< double, 3 > vec = vertices.at(j) - lastV;
       double new_dist = vec.magnitude();
 
       if (new_dist >= pointDistance)
       {
         vnl_vector_fixed< double, 3 > newV = lastV;
         if ( new_dist-pointDistance <= mitk::eps )
         {
           vec.normalize();
           newV += vec * pointDistance;
         }
         else
         {
           // intersection between sphere (radius 'pointDistance', center 'lastV') and line (direction 'd' and point 'p')
           vnl_vector_fixed< double, 3 > p = vertices.at(j-1);
           vnl_vector_fixed< double, 3 > d = vertices.at(j) - p;
 
           double a = d[0]*d[0] + d[1]*d[1] + d[2]*d[2];
           double b = 2 * (d[0] * (p[0] - lastV[0]) + d[1] * (p[1] - lastV[1]) + d[2] * (p[2] - lastV[2]));
           double c = (p[0] - lastV[0])*(p[0] - lastV[0]) + (p[1] - lastV[1])*(p[1] - lastV[1]) + (p[2] - lastV[2])*(p[2] - lastV[2]) - pointDistance*pointDistance;
 
           double v1 =(-b + std::sqrt(b*b-4*a*c))/(2*a);
           double v2 =(-b - std::sqrt(b*b-4*a*c))/(2*a);
 
           if (v1>0)
             newV = p + d * v1;
           else if (v2>0)
             newV = p + d * v2;
           else
             MITK_INFO << "ERROR1 - linear resampling";
 
           j--;
         }
 
 #pragma omp critical
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(newV.data_block());
           container->GetPointIds()->InsertNextId(id);
         }
         lastV = newV;
       }
       else if (j==vertices.size()-1 && new_dist>0.0001)
       {
 #pragma omp critical
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(vertices.at(j).data_block());
           container->GetPointIds()->InsertNextId(id);
         }
       }
     }
 
 #pragma omp critical
     {
       resampled_streamlines[static_cast<unsigned int>(i)] = container;
     }
   }
 
   for (auto container : resampled_streamlines)
   {
     vtkNewCells->InsertNextCell(container);
   }
 
   if (vtkNewCells->GetNumberOfCells()>0)
   {
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
   }
 }
 
 // reapply selected colorcoding in case PolyData structure has changed
 bool mitk::FiberBundle::Equals(mitk::FiberBundle* fib, double eps)
 {
   if (fib==nullptr)
   {
     MITK_INFO << "Reference bundle is nullptr!";
     return false;
   }
 
   if (m_NumFibers!=fib->GetNumFibers())
   {
     MITK_INFO << "Unequal number of fibers!";
     MITK_INFO << m_NumFibers << " vs. " << fib->GetNumFibers();
     return false;
   }
 
   for (unsigned int i=0; i<m_NumFibers; i++)
   {
     vtkCell* cell = m_FiberPolyData->GetCell(i);
     auto numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i);
     auto numPoints2 = cell2->GetNumberOfPoints();
     vtkPoints* points2 = cell2->GetPoints();
 
     if (numPoints2!=numPoints)
     {
       MITK_INFO << "Unequal number of points in fiber " << i << "!";
       MITK_INFO << numPoints2 << " vs. " << numPoints;
       return false;
     }
 
     for (int j=0; j<numPoints; j++)
     {
       double* p1 = points->GetPoint(j);
       double* p2 = points2->GetPoint(j);
       if (fabs(p1[0]-p2[0])>eps || fabs(p1[1]-p2[1])>eps || fabs(p1[2]-p2[2])>eps)
       {
         MITK_INFO << "Unequal points in fiber " << i << " at position " << j << "!";
         MITK_INFO << "p1: " << p1[0] << ", " << p1[1] << ", " << p1[2];
         MITK_INFO << "p2: " << p2[0] << ", " << p2[1] << ", " << p2[2];
         return false;
       }
     }
   }
 
   return true;
 }
 
 void mitk::FiberBundle::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << indent << "Number of fibers: " << this->GetNumFibers() << std::endl;
   os << indent << "Min. fiber length: " << this->GetMinFiberLength() << std::endl;
   os << indent << "Max. fiber length: " << this->GetMaxFiberLength() << std::endl;
   os << indent << "Mean fiber length: " << this->GetMeanFiberLength() << std::endl;
   os << indent << "Median fiber length: " << this->GetMedianFiberLength() << std::endl;
   os << indent << "STDEV fiber length: " << this->GetLengthStDev() << std::endl;
   os << indent << "Number of points: " << this->GetNumberOfPoints() << std::endl;
 
   os << indent << "Extent x: " << this->GetGeometry()->GetExtentInMM(0) << "mm" << std::endl;
   os << indent << "Extent y: " << this->GetGeometry()->GetExtentInMM(1) << "mm" << std::endl;
   os << indent << "Extent z: " << this->GetGeometry()->GetExtentInMM(2) << "mm" << std::endl;
   os << indent << "Diagonal: " << this->GetGeometry()->GetDiagonalLength()  << "mm" << std::endl;
 
   os << "\nReference geometry:" << std::endl;
   os << indent << "Size: [" << std::defaultfloat << m_TrackVisHeader.dim[0] << " " << m_TrackVisHeader.dim[1] << " " << m_TrackVisHeader.dim[2] << "]" << std::endl;
   os << indent << "Voxel size: [" << m_TrackVisHeader.voxel_size[0] << " " << m_TrackVisHeader.voxel_size[1] << " " << m_TrackVisHeader.voxel_size[2] << "]" << std::endl;
   os << indent << "Origin: [" << m_TrackVisHeader.origin[0] << " " << m_TrackVisHeader.origin[1] << " " << m_TrackVisHeader.origin[2] << "]" << std::endl;
   os << indent << "Matrix: " << std::scientific << std::endl;
   os << indent << "[[" << m_TrackVisHeader.vox_to_ras[0][0] << ", " << m_TrackVisHeader.vox_to_ras[0][1] << ", " << m_TrackVisHeader.vox_to_ras[0][2] << ", " << m_TrackVisHeader.vox_to_ras[0][3] << "]" << std::endl;
   os << indent << " [" << m_TrackVisHeader.vox_to_ras[1][0] << ", " << m_TrackVisHeader.vox_to_ras[1][1] << ", " << m_TrackVisHeader.vox_to_ras[1][2] << ", " << m_TrackVisHeader.vox_to_ras[1][3] << "]" << std::endl;
   os << indent << " [" << m_TrackVisHeader.vox_to_ras[2][0] << ", " << m_TrackVisHeader.vox_to_ras[2][1] << ", " << m_TrackVisHeader.vox_to_ras[2][2] << ", " << m_TrackVisHeader.vox_to_ras[2][3] << "]" << std::endl;
   os << indent << " [" << m_TrackVisHeader.vox_to_ras[3][0] << ", " << m_TrackVisHeader.vox_to_ras[3][1] << ", " << m_TrackVisHeader.vox_to_ras[3][2] << ", " << m_TrackVisHeader.vox_to_ras[3][3] << "]]" << std::defaultfloat << std::endl;
 
   if (m_FiberWeights!=nullptr)
   {
     std::vector< float > weights;
     for (int i=0; i<m_FiberWeights->GetSize(); i++)
       weights.push_back(m_FiberWeights->GetValue(i));
 
     std::sort(weights.begin(), weights.end());
 
     os << "\nFiber weight statistics" << std::endl;
     os << indent << "Min: " << weights.front() << std::endl;
     os << indent << "1% quantile: " << weights.at(static_cast<unsigned long>(weights.size()*0.01)) << std::endl;
     os << indent << "5% quantile: " << weights.at(static_cast<unsigned long>(weights.size()*0.05)) << std::endl;
     os << indent << "25% quantile: " << weights.at(static_cast<unsigned long>(weights.size()*0.25)) << std::endl;
     os << indent << "Median: " << weights.at(static_cast<unsigned long>(weights.size()*0.5)) << std::endl;
     os << indent << "75% quantile: " << weights.at(static_cast<unsigned long>(weights.size()*0.75)) << std::endl;
     os << indent << "95% quantile: " << weights.at(static_cast<unsigned long>(weights.size()*0.95)) << std::endl;
     os << indent << "99% quantile: " << weights.at(static_cast<unsigned long>(weights.size()*0.99)) << std::endl;
     os << indent << "Max: " << weights.back() << std::endl;
   }
   else
     os << indent << "\n\nNo fiber weight array found." << std::endl;
 
   Superclass::PrintSelf(os, 0);
 }
 
 mitk::FiberBundle::TrackVis_header mitk::FiberBundle::GetTrackVisHeader()
 {
   if (m_TrackVisHeader.hdr_size==0)
   {
     mitk::Geometry3D::Pointer geom = dynamic_cast<mitk::Geometry3D*>(this->GetGeometry());
     SetTrackVisHeader(geom);
   }
   return m_TrackVisHeader;
 }
 
 void mitk::FiberBundle::SetTrackVisHeader(const mitk::FiberBundle::TrackVis_header &TrackVisHeader)
 {
   m_TrackVisHeader = TrackVisHeader;
 }
 
 void mitk::FiberBundle::SetTrackVisHeader(mitk::BaseGeometry* geometry)
 {
   vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
   matrix->Identity();
 
   if (geometry==nullptr)
     return;
 
   for(int i=0; i<3 ;i++)
   {
     m_TrackVisHeader.dim[i]            = geometry->GetExtent(i);
     m_TrackVisHeader.voxel_size[i]     = geometry->GetSpacing()[i];
     m_TrackVisHeader.origin[i]         = geometry->GetOrigin()[i];
     matrix = geometry->GetVtkMatrix();
   }
 
   for (int i=0; i<4; ++i)
     for (int j=0; j<4; ++j)
       m_TrackVisHeader.vox_to_ras[i][j] = matrix->GetElement(i, j);
 
   m_TrackVisHeader.n_scalars = 0;
   m_TrackVisHeader.n_properties = 0;
   sprintf(m_TrackVisHeader.voxel_order,"LPS");
   m_TrackVisHeader.image_orientation_patient[0] = 1.0;
   m_TrackVisHeader.image_orientation_patient[1] = 0.0;
   m_TrackVisHeader.image_orientation_patient[2] = 0.0;
   m_TrackVisHeader.image_orientation_patient[3] = 0.0;
   m_TrackVisHeader.image_orientation_patient[4] = 1.0;
   m_TrackVisHeader.image_orientation_patient[5] = 0.0;
   m_TrackVisHeader.pad1[0] = 0;
   m_TrackVisHeader.pad1[1] = 0;
   m_TrackVisHeader.pad2[0] = 0;
   m_TrackVisHeader.pad2[1] = 0;
   m_TrackVisHeader.invert_x = 0;
   m_TrackVisHeader.invert_y = 0;
   m_TrackVisHeader.invert_z = 0;
   m_TrackVisHeader.swap_xy = 0;
   m_TrackVisHeader.swap_yz = 0;
   m_TrackVisHeader.swap_zx = 0;
   m_TrackVisHeader.n_count = 0;
   m_TrackVisHeader.version = 2;
   m_TrackVisHeader.hdr_size = 1000;
   std::string id = "TRACK";
   strcpy(m_TrackVisHeader.id_string, id.c_str());
 }
 
 /* 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/FiberDissection/Interactor/mitkStreamlineInteractor.cpp b/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp
index 2cfd0c4..ee82c54 100644
--- a/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp
+++ b/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp
@@ -1,1185 +1,1205 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkStreamlineInteractor.h"
 //#include "mitkStreamlineMapper2D.h"
 
 // MITK includes
 #include <mitkInteractionConst.h>
 #include <mitkInteractionPositionEvent.h>
 #include <mitkInternalEvent.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkOperationEvent.h>
 #include <mitkRotationOperation.h>
 #include <mitkScaleOperation.h>
 #include <mitkSurface.h>
 #include <mitkUndoController.h>
 #include <mitkVtkMapper.h>
 
 // VTK includes
 #include <vtkCamera.h>
 #include <vtkInteractorObserver.h>
 #include <vtkInteractorStyle.h>
 #include <vtkMath.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkVector.h>
 #include <vtkPolyLine.h>
 #include <vtkVectorOperators.h>
 
 mitk::StreamlineInteractor::StreamlineInteractor()
 {
     m_ColorForHighlight[0] = 1.0;
     m_ColorForHighlight[1] = 0.5;
     m_ColorForHighlight[2] = 0.0;
     m_ColorForHighlight[3] = 1.0;
 
     // TODO if we want to get this configurable, the this is the recipe:
     // - make the 2D mapper add corresponding properties to control "enabled" and "color"
     // - make the interactor evaluate those properties
     // - in an ideal world, modify the state machine on the fly and skip mouse move handling
 }
 
 mitk::StreamlineInteractor::~StreamlineInteractor()
 {
 }
 
 void mitk::StreamlineInteractor::ConnectActionsAndFunctions()
 {
 //  CONNECT_CONDITION("isoverstreamline", HasPickedHandle);
     CONNECT_CONDITION("isoverstreamline", CheckSelection);
     CONNECT_FUNCTION("selectstreamline", SelectStreamline);
 
   CONNECT_FUNCTION("addnegstreamline", AddStreamlineNegBundle);
   CONNECT_FUNCTION("addposstreamline", AddStreamlinePosBundle);
   CONNECT_FUNCTION("addnegtolabelstreamline", AddNegStreamlinetolabelsBundle);
   CONNECT_FUNCTION("addpostolabelstreamline", AddPosStreamlinetolabelsBundle);
 //  CONNECT_FUNCTION("FeedUndoStack", FeedUndoStack);
 }
 
 void mitk::StreamlineInteractor::SetNegativeNode(DataNode *node)
 {
 
 //    DataInteractor::SetDataNode(node);
     m_NegStreamlineNode = node;
     m_NegStreamline= dynamic_cast<mitk::FiberBundle *>(node->GetData());
     MITK_INFO << "Negative Node added";
 }
 
 void mitk::StreamlineInteractor::SetToLabelNode(DataNode *node)
 {
     m_manStreamlineNode = node;
     DataInteractor::SetDataNode(m_manStreamlineNode);
     m_manStreamline = dynamic_cast<mitk::FiberBundle *>(node->GetData());
     MITK_INFO << "Label node added";
+//    m_init = false;
 
 }
 
 void mitk::StreamlineInteractor::SetPositiveNode(DataNode *node)
 {
 
     //    DataInteractor::SetDataNode(node);
     m_PosStreamlineNode = node;
     m_PosStreamline= dynamic_cast<mitk::FiberBundle *>(node->GetData());
     MITK_INFO << "Positive Node added";
-  }
+}
+
+void mitk::StreamlineInteractor::LabelfromPrediction(bool predlabeling)
+{
+    m_predlabeling = predlabeling;
+
+}
 
 bool mitk::StreamlineInteractor::CheckSelection(const InteractionEvent *interactionEvent)
 {
     /* Save Colorvector here*/
-    vtkSmartPointer<vtkUnsignedCharArray> color = m_manStreamline->GetFiberColors();
 
     const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent != nullptr)
     {
         if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
         {
             BaseRenderer *renderer = positionEvent->GetSender();
 
             auto &picker = m_Picker[renderer];
 
             picker = vtkSmartPointer<vtkCellPicker>::New();
             picker->SetTolerance(0.01);
             auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
 
 
               auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
               if (vtk_mapper)
               { // doing this each time is bizarre
                 picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
                 picker->PickFromListOn();
               }
 
             auto displayPosition = positionEvent->GetPointerPositionOnScreen();
             picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
 
 
-            if (picker->GetCellId()==-1)
+            if (picker->GetCellId()==-1 && m_predlabeling==false)
             {
-                m_manStreamline->SetFiberColors(255, 255, 255);
+//                m_manStreamline->SetFiberColors(255, 255, 255);
+//                vtkSmartPointer<vtkUnsignedCharArray> FiberColors = m_manStreamline->m_FiberColors;
+
                 RenderingManager::GetInstance()->RequestUpdateAll();
                 return false;
             }
             else
             {
 
                 return true;
             }
         }
         else {
             BaseRenderer *renderer = positionEvent->GetSender();
 
             auto &picker = m_Picker[renderer];
 
             picker = vtkSmartPointer<vtkCellPicker>::New();
             picker->SetTolerance(0.01);
             auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
               auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
               if (vtk_mapper)
               { // doing this each time is bizarre
                 picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
                 picker->PickFromListOn();
               }
 
             auto displayPosition = positionEvent->GetPointerPositionOnScreen();
             picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
 
 
-            if (picker->GetCellId()==-1)
+            if (picker->GetCellId()==-1 && m_predlabeling==false)
             {
-                m_manStreamline->SetFiberColors(255, 255, 255);
+//                m_manStreamline->SetFiberColors(255, 255, 255);
                 RenderingManager::GetInstance()->RequestUpdateAll();
                 return false;
             }
             else
             {
 
                 return true;
             }
 
         }
 
 
     }
     else {
 //        m_manStreamline->SetFiberColors(255, 255, 255);
         RenderingManager::GetInstance()->RequestUpdateAll();
         return false;
     }
 
 }
 
 void mitk::StreamlineInteractor::SelectStreamline(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     auto *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
     //        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
-
+        if (m_predlabeling==false)
+            {
         vtkIdType pickedCellID = picker->GetCellId();
-        m_manStreamline->SetSingleFiberColor(0, 255, 0, pickedCellID);
+        m_manStreamline->SetSingleFiberColor(0.0, 255.0, 0.0, pickedCellID);
+        }
     }
     else {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
     //        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
-
+        if (m_predlabeling==false)
+            {
         vtkIdType pickedCellID = picker->GetCellId();
-
-        m_manStreamline->SetSingleFiberColor(0, 255, 0, pickedCellID);
+        m_manStreamline->SetSingleFiberColor(0.0, 255.0, 0.0, pickedCellID);
+        }
     }
 
+
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::StreamlineInteractor::AddStreamlinePosBundle(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     MITK_INFO << "PositiveBundle clicked";
     DataInteractor::SetDataNode(m_manStreamlineNode);
 
     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent == nullptr)
     {
         MITK_INFO << "no position";
     }
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
 //      m_PickedHandle = PickFrom2D(positionEvent);
         MITK_INFO << "2D";
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
 
         auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
         if (vtk_mapper)
         { // doing this each time is bizarre
           picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
           picker->PickFromListOn();
         }
 //        }
 
       auto displayPosition = positionEvent->GetPointerPositionOnScreen();
       picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
       vtkIdType pickedCellID = picker->GetCellId();
 
 
 
       if (picker->GetCellId()==-1)
       {
           MITK_INFO << "Nothing picked";
       }
       else {
 
 
           vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
           unsigned int counter = 0;
           for ( int i=0; i<m_PosStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
           {
 
             vtkCell* cell = m_PosStreamline->GetFiberPolyData()->GetCell(i);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned 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++;
 
           }
 
 
 
           vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(pickedCellID);
 
           auto numPoints = cell->GetNumberOfPoints();
           vtkPoints* points = cell->GetPoints();
 
           vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
           for (unsigned int j=0; j<numPoints; j++)
           {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
           }
           vNewLines->InsertNextCell(container);
 
           vNewPolyData->SetPoints(vNewPoints);
           vNewPolyData->SetLines(vNewLines);
 
   //        m_PosStreamline = mitk::FiberBundle::New(vNewPolyData);
           m_PosStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
           m_PosStreamline->GetFiberPolyData()->SetLines(vNewLines);
           m_PosStreamline->SetFiberColors(0, 255, 0);
 //            m_PosStreamline->SetFiberWeights(m_PosStreamline->GetFiberWeights());
 
           m_manStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
           m_manStreamline->GetFiberPolyData()->RemoveDeletedCells();
-
+          if (m_predlabeling==false)
+          {
           vtkSmartPointer<vtkPolyData> vNewPolyData2 = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines2 = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints2 = vtkSmartPointer<vtkPoints>::New();
 
 
          counter = 0;
           for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
           {
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints2->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
         //    weights->InsertValue(counter, fib->GetFiberWeight(i));
             vNewLines2->InsertNextCell(container);
             counter++;
 
           }
           m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints2);
           m_manStreamline->GetFiberPolyData()->SetLines(vNewLines2);
           m_manStreamline->SetFiberColors(255, 255, 255);
+          }
 
 
 
 
 
     }
     }
     else
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
 //        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
         vtkIdType pickedCellID = picker->GetCellId();
 
 
 
         if (picker->GetCellId()==-1)
         {
             MITK_INFO << "Nothing picked";
         }
         else {
 
 
             vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
             vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             unsigned int counter = 0;
             for ( int i=0; i<m_PosStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
 
               vtkCell* cell = m_PosStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned 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++;
 
             }
 
 
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(pickedCellID);
 
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
 
             vNewPolyData->SetPoints(vNewPoints);
             vNewPolyData->SetLines(vNewLines);
 
     //        m_PosStreamline = mitk::FiberBundle::New(vNewPolyData);
             m_PosStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
             m_PosStreamline->GetFiberPolyData()->SetLines(vNewLines);
             m_PosStreamline->SetFiberColors(0, 255, 0);
 //            m_PosStreamline->SetFiberWeights(m_PosStreamline->GetFiberWeights());
 
 
             m_manStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
             m_manStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
-
+            if (m_predlabeling==false)
+            {
             vtkSmartPointer<vtkPolyData> vNewPolyData2 = vtkSmartPointer<vtkPolyData>::New();
             vtkSmartPointer<vtkCellArray> vNewLines2 = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints2 = vtkSmartPointer<vtkPoints>::New();
 
 
            counter = 0;
             for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
 
               vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned int j=0; j<numPoints; j++)
               {
                 double p[3];
                 points->GetPoint(j, p);
 
                 vtkIdType id = vNewPoints2->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
               }
           //    weights->InsertValue(counter, fib->GetFiberWeight(i));
               vNewLines2->InsertNextCell(container);
               counter++;
 
             }
             m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints2);
             m_manStreamline->GetFiberPolyData()->SetLines(vNewLines2);
             m_manStreamline->SetFiberColors(255, 255, 255);
+            }
 
         }
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
 void mitk::StreamlineInteractor::AddStreamlineNegBundle(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     MITK_INFO << "NegativeBundle clicked";
 
     DataInteractor::SetDataNode(m_manStreamlineNode);
 
     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent == nullptr)
     {
         MITK_INFO << "no position";
     }
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
 //      m_PickedHandle = PickFrom2D(positionEvent);
         MITK_INFO << "2D";
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
 
         auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
         if (vtk_mapper)
         { // doing this each time is bizarre
           picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
           picker->PickFromListOn();
         }
 //        }
 
       auto displayPosition = positionEvent->GetPointerPositionOnScreen();
       picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
       vtkIdType pickedCellID = picker->GetCellId();
 
 
 
       if (picker->GetCellId()==-1)
       {
           MITK_INFO << "Nothing picked";
       }
       else {
 
 
           vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
           unsigned int counter = 0;
           for ( int i=0; i<m_NegStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
           {
 
             vtkCell* cell = m_NegStreamline->GetFiberPolyData()->GetCell(i);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned 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++;
 
           }
 
 
 
           vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(pickedCellID);
 
           auto numPoints = cell->GetNumberOfPoints();
           vtkPoints* points = cell->GetPoints();
 
           vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
           for (unsigned int j=0; j<numPoints; j++)
           {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
           }
           vNewLines->InsertNextCell(container);
 
           vNewPolyData->SetPoints(vNewPoints);
           vNewPolyData->SetLines(vNewLines);
 
   //        m_NegStreamline = mitk::FiberBundle::New(vNewPolyData);
           m_NegStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
           m_NegStreamline->GetFiberPolyData()->SetLines(vNewLines);
           m_NegStreamline->SetFiberColors(255, 0, 0);
 //            m_NegStreamline->SetFiberWeights(m_NegStreamline->GetFiberWeights());
 
           m_manStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
           m_manStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
+          if (m_predlabeling==false)
+          {
           vtkSmartPointer<vtkPolyData> vNewPolyData2 = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines2 = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints2 = vtkSmartPointer<vtkPoints>::New();
 
 
          counter = 0;
           for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
           {
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints2->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
         //    weights->InsertValue(counter, fib->GetFiberWeight(i));
             vNewLines2->InsertNextCell(container);
             counter++;
 
           }
           m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints2);
           m_manStreamline->GetFiberPolyData()->SetLines(vNewLines2);
           m_manStreamline->SetFiberColors(255, 255, 255);
-
+            }
 
 
 
 
 
     }
     }
     else
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 //        if (picker == nullptr)
 //        {
 
 
           picker = vtkSmartPointer<vtkCellPicker>::New();
           picker->SetTolerance(0.01);
           auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
 //        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
 
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
         vtkIdType pickedCellID = picker->GetCellId();
 
 
         if (picker->GetCellId()==-1)
         {
             MITK_INFO << "Nothing picked";
         }
         else
         {
             vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
             vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             unsigned int counter = 0;
             for ( int i=0; i<m_NegStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
               vtkCell* cell = m_NegStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned 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++;
 
             }
 
 
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(pickedCellID);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
 
             vNewPolyData->SetPoints(vNewPoints);
             vNewPolyData->SetLines(vNewLines);
 
     //        m_NegStreamline = mitk::FiberBundle::New(vNewPolyData);
             m_NegStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
             m_NegStreamline->GetFiberPolyData()->SetLines(vNewLines);
             m_NegStreamline->SetFiberColors(255, 0, 0);
 
             m_manStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
             m_manStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
-          vtkSmartPointer<vtkPolyData> vNewPolyData2 = vtkSmartPointer<vtkPolyData>::New();
-          vtkSmartPointer<vtkCellArray> vNewLines2 = vtkSmartPointer<vtkCellArray>::New();
-          vtkSmartPointer<vtkPoints> vNewPoints2 = vtkSmartPointer<vtkPoints>::New();
-
-
-         counter = 0;
-          for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
-          {
-
-            vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
-            auto numPoints = cell->GetNumberOfPoints();
-            vtkPoints* points = cell->GetPoints();
-
-            vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-            for (unsigned int j=0; j<numPoints; j++)
+            if (m_predlabeling==false)
             {
-              double p[3];
-              points->GetPoint(j, p);
-
-              vtkIdType id = vNewPoints2->InsertNextPoint(p);
-              container->GetPointIds()->InsertNextId(id);
+                vtkSmartPointer<vtkPolyData> vNewPolyData2 = vtkSmartPointer<vtkPolyData>::New();
+                vtkSmartPointer<vtkCellArray> vNewLines2 = vtkSmartPointer<vtkCellArray>::New();
+                vtkSmartPointer<vtkPoints> vNewPoints2 = vtkSmartPointer<vtkPoints>::New();
+
+
+                counter = 0;
+                for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
+                {
+
+                vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
+                auto numPoints = cell->GetNumberOfPoints();
+                vtkPoints* points = cell->GetPoints();
+
+                vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
+                for (unsigned int j=0; j<numPoints; j++)
+                {
+                  double p[3];
+                  points->GetPoint(j, p);
+
+                  vtkIdType id = vNewPoints2->InsertNextPoint(p);
+                  container->GetPointIds()->InsertNextId(id);
+                }
+                //    weights->InsertValue(counter, fib->GetFiberWeight(i));
+                vNewLines2->InsertNextCell(container);
+                counter++;
+
+                }
+                m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints2);
+                m_manStreamline->GetFiberPolyData()->SetLines(vNewLines2);
+                m_manStreamline->SetFiberColors(255, 255, 255);
             }
-        //    weights->InsertValue(counter, fib->GetFiberWeight(i));
-            vNewLines2->InsertNextCell(container);
-            counter++;
-
-          }
-          m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints2);
-          m_manStreamline->GetFiberPolyData()->SetLines(vNewLines2);
-          m_manStreamline->SetFiberColors(255, 255, 255);
-
 
         }
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
 void mitk::StreamlineInteractor::AddNegStreamlinetolabelsBundle(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     MITK_INFO << "TolabelBundle clicked";
     DataInteractor::SetDataNode(m_NegStreamlineNode);
 
 
     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent == nullptr)
     {
         MITK_INFO << "no position";
     }
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
 //      m_PickedHandle = PickFrom2D(positionEvent);
 
         MITK_INFO << "2D";
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
 
         auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
         if (vtk_mapper)
         { // doing this each time is bizarre
           picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
           picker->PickFromListOn();
         }
 //        }
 
       auto displayPosition = positionEvent->GetPointerPositionOnScreen();
       picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
       vtkIdType pickedCellID = picker->GetCellId();
 
 
 
       if (picker->GetCellId()==-1)
       {
           MITK_INFO << "Nothing picked";
       }
       else {
 
 
           vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
           unsigned int counter = 0;
           for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
           {
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned 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++;
 
           }
 
 
 
           vtkCell* cell = m_NegStreamline->GetFiberPolyData()->GetCell(pickedCellID);
 
           auto numPoints = cell->GetNumberOfPoints();
           vtkPoints* points = cell->GetPoints();
 
           vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
           for (unsigned int j=0; j<numPoints; j++)
           {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
           }
           vNewLines->InsertNextCell(container);
 
           vNewPolyData->SetPoints(vNewPoints);
           vNewPolyData->SetLines(vNewLines);
 
   //        m_manStreamline = mitk::FiberBundle::New(vNewPolyData);
           m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
           m_manStreamline->GetFiberPolyData()->SetLines(vNewLines);
           m_manStreamline->SetFiberColors(255, 255, 255);
 //            m_manStreamline->SetFiberWeights(m_manStreamline->GetFiberWeights());
 
           m_NegStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
           m_NegStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
 
 
 
 
     }
     }
     else
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 //        if (picker == nullptr)
 //        {
 
 
           picker = vtkSmartPointer<vtkCellPicker>::New();
           picker->SetTolerance(0.01);
           auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
 //        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
 
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
         vtkIdType pickedCellID = picker->GetCellId();
 
 
         if (picker->GetCellId()==-1)
         {
             MITK_INFO << "Nothing picked";
         }
         else
         {
             vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
             vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             unsigned int counter = 0;
             for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
               vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned 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++;
 
             }
 
 
 
             vtkCell* cell = m_NegStreamline->GetFiberPolyData()->GetCell(pickedCellID);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
 
             vNewPolyData->SetPoints(vNewPoints);
             vNewPolyData->SetLines(vNewLines);
 
     //        m_manStreamline = mitk::FiberBundle::New(vNewPolyData);
             m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
             m_manStreamline->GetFiberPolyData()->SetLines(vNewLines);
             m_manStreamline->SetFiberColors(255, 255, 255);
 
             m_NegStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
             m_NegStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
         }
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
 void mitk::StreamlineInteractor::AddPosStreamlinetolabelsBundle(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     MITK_INFO << "TolabelBundle clicked";
     DataInteractor::SetDataNode(m_PosStreamlineNode);
 
 
     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent == nullptr)
     {
         MITK_INFO << "no position";
     }
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
 //      m_PickedHandle = PickFrom2D(positionEvent);
 
         MITK_INFO << "2D";
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 
         picker = vtkSmartPointer<vtkCellPicker>::New();
         picker->SetTolerance(0.01);
         auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard2D);
 
         auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
         if (vtk_mapper)
         { // doing this each time is bizarre
           picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
           picker->PickFromListOn();
         }
 //        }
 
       auto displayPosition = positionEvent->GetPointerPositionOnScreen();
       picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
       vtkIdType pickedCellID = picker->GetCellId();
 
 
 
       if (picker->GetCellId()==-1)
       {
           MITK_INFO << "Nothing picked";
       }
       else {
 
 
           vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
           unsigned int counter = 0;
           for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
           {
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned 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++;
 
           }
 
 
 
           vtkCell* cell = m_PosStreamline->GetFiberPolyData()->GetCell(pickedCellID);
 
           auto numPoints = cell->GetNumberOfPoints();
           vtkPoints* points = cell->GetPoints();
 
           vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
           for (unsigned int j=0; j<numPoints; j++)
           {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
           }
           vNewLines->InsertNextCell(container);
 
           vNewPolyData->SetPoints(vNewPoints);
           vNewPolyData->SetLines(vNewLines);
 
   //        m_manStreamline = mitk::FiberBundle::New(vNewPolyData);
           m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
           m_manStreamline->GetFiberPolyData()->SetLines(vNewLines);
           m_manStreamline->SetFiberColors(255, 255, 255);
 //            m_manStreamline->SetFiberWeights(m_manStreamline->GetFiberWeights());
 
           m_PosStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
           m_PosStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
 
 
 
 
     }
     }
     else
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
 //        if (picker == nullptr)
 //        {
 
 
           picker = vtkSmartPointer<vtkCellPicker>::New();
           picker->SetTolerance(0.01);
           auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
 //        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
 
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
         vtkIdType pickedCellID = picker->GetCellId();
 
 
         if (picker->GetCellId()==-1)
         {
             MITK_INFO << "Nothing picked";
         }
         else
         {
             vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
             vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             unsigned int counter = 0;
             for ( int i=0; i<m_manStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
               vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned 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++;
 
             }
 
 
 
             vtkCell* cell = m_PosStreamline->GetFiberPolyData()->GetCell(pickedCellID);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
 
             vNewPolyData->SetPoints(vNewPoints);
             vNewPolyData->SetLines(vNewLines);
 
     //        m_manStreamline = mitk::FiberBundle::New(vNewPolyData);
             m_manStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
             m_manStreamline->GetFiberPolyData()->SetLines(vNewLines);
             m_manStreamline->SetFiberColors(255, 255, 255);
 
             m_PosStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
             m_PosStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
         }
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
diff --git a/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.h b/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.h
index 23f0595..3b43f1e 100644
--- a/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.h
+++ b/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.h
@@ -1,118 +1,123 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkStreamlineInteractor_h
 #define mitkStreamlineInteractor_h
 
 
 #include "MitkFiberDissectionExports.h"
 
 // MITK includes
 #include <mitkDataInteractor.h>
 #include <mitkDataNode.h>
 #include <mitkGeometry3D.h>
 #include <mitkFiberBundle.h>
 
 // VTK includes
 #include <vtkCellPicker.h>
 #include <vtkSmartPointer.h>
 
 // System includes
 #include <memory>
 
 
 namespace mitk
 {
   class InteractionPositionEvent;
 
   //! Data interactor to pick streamlines via interaction
   //! with a mitk::Streamline.
   //!
   //!
   //! To determine what parts of the object are clicked during interaction,
   //! the mappers (2D: custom mapper, 3D: regular surface mapper) are asked
   //! for their VTK objects, picking is performed, and the picked point is
   //! forwarded to the Streamline object for interpretation.
   //!
   //! The interactor fills the undo/redo stack with operations on the modified geometry.
   //!
   //! \sa Streamline
   class MITKFIBERDISSECTION_EXPORT StreamlineInteractor : public DataInteractor
   {
   public:
     mitkClassMacro(StreamlineInteractor, DataInteractor);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       //! The node holding the Fiberbundle for visual feedback.
       //! This is the node that the interactor is primarily working on
       //! (calls DataInteractor::SetDataNode).
 
       void SetNegativeNode(DataNode *node);
       void SetToLabelNode(DataNode *node);
       void SetPositiveNode(DataNode *node);
+      void LabelfromPrediction(bool predlabeling);
 
   protected:
 
        void AddStreamlineNegBundle(StateMachineAction *, InteractionEvent *interactionEvent);
 
        void AddStreamlinePosBundle(StateMachineAction *, InteractionEvent *interactionEvent);
 
        void AddNegStreamlinetolabelsBundle(StateMachineAction *, InteractionEvent *interactionEvent);
 
        void AddPosStreamlinetolabelsBundle(StateMachineAction *, InteractionEvent *interactionEvent);
 
        bool CheckSelection(const InteractionEvent *interactionEvent);
 
        void SelectStreamline(StateMachineAction *, InteractionEvent *);
 
+
        std::map<BaseRenderer *, vtkSmartPointer<vtkCellPicker>> m_Picker;
 
   private:
     StreamlineInteractor();
     ~StreamlineInteractor() override;
 
     //! Setup the relation between the XML state machine and this object's methods.
     void ConnectActionsAndFunctions() override;
 
     //! State machine condition: successful Streamline picking
     //! \return true when any part of the Streamline has been picked.
 //    bool HasPickedHandle(const InteractionEvent *);
 
 //    void DecideInteraction(StateMachineAction *, InteractionEvent *interactionEvent);
 
 //    //! Pick a Streamline handle from a 2D event (passing by the 2D mapper)
 //    Streamline::HandleType PickFrom2D(const InteractionPositionEvent *positionEvent);
 
 //    //! Pick a Streamline handle from a 3D event
 //    //! (passing by the general surface mapper and the Streamline object)
 //    Streamline::HandleType PickFrom3D(const InteractionPositionEvent *positionEvent);
 
 //    void UpdateHandleHighlight();
 
     //! the Streamline used for visual feedback and picking
     mitk::FiberBundle::Pointer            m_NegStreamline;
     mitk::FiberBundle::Pointer            m_PosStreamline;
     mitk::FiberBundle::Pointer            m_manStreamline;
+    bool                                  m_predlabeling;
 //    mitk::FiberBundle::Pointer            m_visualStreamline;
     mitk::DataNode::Pointer               m_NegStreamlineNode;
     mitk::DataNode::Pointer               m_PosStreamlineNode;
     mitk::DataNode::Pointer               m_manStreamlineNode;
 //    mitk::DataNode::Pointer               m_visualStreamlineNode;
 
+
+
     vtkSmartPointer<vtkPolyData>  m_extracted_streamline;
 
     double m_ColorForHighlight[4];
 
   };
 }
 #endif
diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
index b02ebed..10707e4 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
@@ -1,767 +1,799 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "mitkStreamlineFeatureExtractor.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 #include <vnl/vnl_sparse_matrix.h>
 #include <mitkIOUtil.h>
 
 namespace mitk{
 
 StreamlineFeatureExtractor::StreamlineFeatureExtractor()
   : m_NumPoints(40)
 {
 
 }
 
 StreamlineFeatureExtractor::~StreamlineFeatureExtractor()
 {
 
 }
 
 
 
 void StreamlineFeatureExtractor::SetTractogramPlus(const mitk::FiberBundle::Pointer &TractogramPlus)
 {
   m_TractogramPlus = TractogramPlus;
 }
 
 void StreamlineFeatureExtractor::SetTractogramMinus(const mitk::FiberBundle::Pointer &TractogramMinus)
 {
   m_TractogramMinus = TractogramMinus;
 }
 
 void StreamlineFeatureExtractor::SetTractogramPrototypes(const mitk::FiberBundle::Pointer &TractogramPrototypes, bool standard)
 {
   if (standard)
   {
       MITK_INFO << "Use Standard Prototypes...";
-    m_inputPrototypes = mitk::IOUtil::Load<mitk::FiberBundle>("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/prototypes_599671.trk");
+    m_inputPrototypes = mitk::IOUtil::Load<mitk::FiberBundle>("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/prototypes_599671_40.trk");
   }
   else {
       MITK_INFO << "Use individual Prototypes...";
       m_inputPrototypes = TractogramPrototypes;
   }
 
 
 }
 
 void StreamlineFeatureExtractor::SetActiveCycle(int &activeCycle)
 {
   m_activeCycle= activeCycle;
 }
 
+void StreamlineFeatureExtractor::SetInitRandom(int &initRandom)
+{
+  m_initRandom= initRandom;
+}
+
 
 
 
 void StreamlineFeatureExtractor::SetTractogramTest(const mitk::FiberBundle::Pointer &TractogramTest, std::string TractogramTestName)
 {
     std::string path = "/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/storage/";
     path.append(TractogramTestName);
     m_TractogramTest= TractogramTest;
     auto s = std::to_string(m_NumPoints);
-    m_DistancesTestName= path.append("_distances" + s + ".csv");
+    m_DistancesTestName= path.append("_distances" + std::to_string(m_NumPoints) + "_" + std::to_string(m_activeCycle) + ".csv");
 }
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
   temp_fib->ResampleToNumPoints(m_NumPoints);
   MITK_INFO << "Resampling Done";
 
   std::vector< vnl_matrix<float> > out_fib(temp_fib->GetFiberPolyData()->GetNumberOfCells());
 
   for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
     vtkCell* cell = temp_fib->GetFiberPolyData()->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     vnl_matrix<float> streamline;
     streamline.set_size(3, m_NumPoints);
     streamline.fill(0.0);
 
     for (int j=0; j<numPoints; j++)
     {
       double cand[3];
       points->GetPoint(j, cand);
 
       vnl_vector_fixed< float, 3 > candV;
       candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
       streamline.set_column(j, candV);
     }
 
 //        out_fib.push_back(streamline);
     out_fib.at(i)=streamline;
   }
 //      });
 
 
 
   return out_fib;
 }
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::CalculateDmdf(std::vector<vnl_matrix<float> > tractogram,
                                                                           std::vector<vnl_matrix<float> > prototypes)
 {
 
     std::vector< vnl_matrix<float> >  dist_vec(tractogram.size());//
     MITK_INFO << "Start Calculating Dmdf";
     cv::parallel_for_(cv::Range(0, tractogram.size()), [&](const cv::Range &range)
     {
     for (int i = range.start; i < range.end; i++)
 
 //    for (unsigned int i=0; i<tractogram.size(); i++)
     {
 
         vnl_matrix<float> distances;
         distances.set_size(1, prototypes.size());
         distances.fill(0.0);
 
 
         for (unsigned int j=0; j<prototypes.size(); j++)
         {
             vnl_matrix<float> single_distances;
             single_distances.set_size(1, tractogram.at(0).cols());
             single_distances.fill(0.0);
             vnl_matrix<float> single_distances_flip;
             single_distances_flip.set_size(1, tractogram.at(0).cols());
             single_distances_flip.fill(0.0);
             for (unsigned int ik=0; ik<tractogram.at(0).cols(); ik++)
             {
                 double cur_dist;
                 double cur_dist_flip;
 
                 cur_dist = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,ik), 2.0) +
                                        pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,ik), 2.0) +
                                        pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,ik), 2.0));
 
                 cur_dist_flip = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,prototypes.at(0).cols()-(ik+1)), 2.0) +
                                        pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,prototypes.at(0).cols()-(ik+1)), 2.0) +
                                        pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,prototypes.at(0).cols()-(ik+1)), 2.0));
 
                 single_distances.put(0,ik, cur_dist);
                 single_distances_flip.put(0,ik, cur_dist_flip);
 
             }
 
             if (single_distances_flip.mean()> single_distances.mean())
             {
                 distances.put(0,j, single_distances.mean());
             }
             else {
                 distances.put(0,j, single_distances_flip.mean());
             }
 
 
 
         }
 //        dist_vec.push_back(distances);
         dist_vec.at(i) = distances;
     }
     });
     MITK_INFO << "Done Calculation";
     MITK_INFO << dist_vec.at(0).size();
 
     return dist_vec;
 }
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::MergeTractogram(std::vector<vnl_matrix<float> > prototypes,
                                                                            std::vector<vnl_matrix<float> > positive_local_prototypes,
                                                                            std::vector<vnl_matrix<float> > negative_local_prototypes)
 {
     unsigned int pos_locals;
     unsigned int neg_locals;
 
     if (positive_local_prototypes.size() >= 50)
     {
         pos_locals= 50;
     }
     else {
         pos_locals= positive_local_prototypes.size();
     }
 
     if (pos_locals <= negative_local_prototypes.size())
     {
         neg_locals = pos_locals;
     }
     else {
         neg_locals= negative_local_prototypes.size();
     }
 
 
 
     std::vector< vnl_matrix<float> > merged_prototypes;
 
     for (unsigned int k=0; k<prototypes.size(); k++)
     {
         merged_prototypes.push_back(prototypes.at(k));
     }
 
     for (unsigned int k=0; k<pos_locals; k++)
     {
         merged_prototypes.push_back(positive_local_prototypes.at(k));
     }
 
-    for (unsigned int k=0; k<neg_locals; k++)
+    for (unsigned int k=m_initRandom; k<neg_locals; k++)
     {
         merged_prototypes.push_back(negative_local_prototypes.at(k));
     }
 
     MITK_INFO << "Number of prototypes:";
     MITK_INFO << prototypes.size();
     MITK_INFO << "Number of positive local prototypes:";
     MITK_INFO << pos_locals;
     MITK_INFO << "Number of negative local prototypes:";
     MITK_INFO << neg_locals;
 
     return merged_prototypes;
 
 }
 
 
 std::vector<unsigned int> StreamlineFeatureExtractor::Sort(std::vector<float> sortingVector, int lengths)
 {
     std::vector<unsigned int> index;
     std::priority_queue<std::pair<float, int>> q;
 
     for (unsigned int i = 0; i < sortingVector.size(); ++i)
     {
         q.push(std::pair<float, int>(sortingVector[i], i));
     }
 
 
     for (int i = 0; i < lengths; ++i)
     {
         int ki = q.top().second;
         index.push_back(ki);
         q.pop();
     }
     return index;
 }
 
 
 std::vector<std::vector<unsigned int>>  StreamlineFeatureExtractor::GetData()
 {
     MITK_INFO << "Start Function Get Data";
 
     /*Vector which saves Prediction and Fibers to label based on uncertainty*/
     std::vector<std::vector<unsigned int>> index_vec;
 
 //    int labels_arr [m_DistancesPlus.size()+m_DistancesMinus.size()];
     cv::Mat data;
     cv::Mat labels_arr_vec;
 
     int size_plus = 0;
 
 
     /*Create Trainingdata: Go through positive and negative Bundle and save distances as cv::Mat and create vector with labels*/
     for ( unsigned int i=0; i<m_DistancesPlus.size(); i++)
     {
         float data_arr [m_DistancesPlus.at(0).size()];
 //        labels_arr[i]=1;
         labels_arr_vec.push_back(1);
 
         for ( unsigned int j=0; j<m_DistancesPlus.at(0).cols(); j++)
         {
             data_arr[j] = m_DistancesPlus.at(i).get(0,j);
         }
         cv::Mat curdata(1, m_DistancesPlus.at(0).size(), CV_32F, data_arr);
         data.push_back(curdata);
         size_plus++;
 
     }
 
     for ( unsigned int i=m_DistancesPlus.size(); i<m_DistancesPlus.size()+m_DistancesMinus.size(); i++)
     {
         int it = i - size_plus;
         float data_arr [m_DistancesMinus.at(0).size()];
 //        labels_arr[i]=0;
         labels_arr_vec.push_back(0);
 
          for ( unsigned int j=0; j<m_DistancesMinus.at(0).cols(); j++)
         {
             data_arr[j] = m_DistancesMinus.at(it).get(0,j);
         }
         cv::Mat curdata(1, m_DistancesPlus.at(0).size(), CV_32F, data_arr);
         data.push_back(curdata);
 
     }
     MITK_INFO << data.cols;
     MITK_INFO << data.rows;
 
     /*Calculate weights*/
     int zerosgt = labels_arr_vec.rows - cv::countNonZero(labels_arr_vec);
     int onesgt = cv::countNonZero(labels_arr_vec);
     float plusval = labels_arr_vec.rows / (2.0 * onesgt );
     float minusval = labels_arr_vec.rows / (2.0 * zerosgt );
     float w[2] = {minusval, plusval};
     cv::Mat newweight = cv::Mat(1,2, CV_32F, w);
     MITK_INFO << "Weights";
     MITK_INFO << newweight;
 
 
     /*Shuffle Data*/
     std::vector <int> seeds;
     for (int cont = 0; cont < labels_arr_vec.rows; cont++)
     {
         seeds.push_back(cont);
     }
 
     cv::randShuffle(seeds);
     cv::Mat labels_shuffled;
     cv::Mat samples_shuffled;
 
+
+
+
     for (int cont = 0; cont < labels_arr_vec.rows; cont++)
     {
         labels_shuffled.push_back(labels_arr_vec.row(seeds[cont]));
     }
 
     for (int cont = 0; cont < labels_arr_vec.rows; cont++)
     {
         samples_shuffled.push_back(data.row(seeds[cont]));
     }
 
 
+    std::ofstream labelsfile;
+    labelsfile.open("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/storage/Labels_" + std::to_string(m_activeCycle) + ".csv");
+    labelsfile<< cv::format(labels_shuffled, cv::Formatter::FMT_CSV) << std::endl;
+    labelsfile.close();
+
+    std::ofstream featuresfile;
+    featuresfile.open("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/storage/Features_" + std::to_string(m_activeCycle) + ".csv");
+    featuresfile<< cv::format(samples_shuffled, cv::Formatter::FMT_CSV) << std::endl;
+    featuresfile.close();
 
     /*Create Dataset and initialize Classifier*/
     cv::Ptr<cv::ml::TrainData> m_traindata = cv::ml::TrainData::create(samples_shuffled, cv::ml::ROW_SAMPLE, labels_shuffled);
 
 
 
 
     auto statistic_model = cv::ml::RTrees::create();
     auto criteria = cv::TermCriteria();
     criteria.type = cv::TermCriteria::MAX_ITER;
 //    criteria.epsilon = 1e-8;
     criteria.maxCount = 800;
 
     statistic_model->setMaxDepth(50); //set to three
 //    statistic_model->setMinSampleCount(m_traindata->getNTrainSamples()*0.01);
     statistic_model->setMinSampleCount(2);
     statistic_model->setTruncatePrunedTree(false);
     statistic_model->setUse1SERule(false);
     statistic_model->setUseSurrogates(false);
     statistic_model->setTermCriteria(criteria);
     statistic_model->setCVFolds(1);
     statistic_model->setPriors(newweight);
 
 
     /*Train Classifier*/
     MITK_INFO << "Start Training";
     statistic_model->train(m_traindata);
 
 
 
     /*Predict on Test Data*/
     MITK_INFO << "Predicting";
 
     /*Create Dataset as cv::Mat*/
     cv::Mat dataTest;
     for ( unsigned int i=0; i<m_DistancesTest.size(); i++)
     {
         float data_arr [m_DistancesTest.at(0).size()];
 
         for ( unsigned int j=0; j<m_DistancesTest.at(0).cols(); j++)
         {
             data_arr[j] = m_DistancesTest.at(i).get(0,j);
         }
         cv::Mat curdata(1, m_DistancesTest.at(0).size(), CV_32F, data_arr);
         dataTest.push_back(curdata);
     }
 
 
     std::vector<unsigned int> indexPrediction;
     std::vector<float> e(m_DistancesTest.size());
 
 
     /*For every Sample/Streamline get Prediction and entropy (=based on counts of Random Forest)*/
     MITK_INFO << "Predicting on all cores";
 #pragma omp parallel for
     for (unsigned int i=0; i<m_DistancesTest.size(); i++)
     {
 
 
         int val = statistic_model->predict(dataTest.row(i));
 
         #pragma omp critical
         if (val==1)
         {
            indexPrediction.push_back(i);
         }
 
 
         cv::Mat vote;
         statistic_model->getVotes(dataTest.row(i), vote, 0);
         e.at(i) = ( -(vote.at<int>(1,0)*1.0)/ (vote.at<int>(1,0)+vote.at<int>(1,1)) * log2((vote.at<int>(1,0)*1.0)/ (vote.at<int>(1,0)+vote.at<int>(1,1))) -
                     (vote.at<int>(1,1)*1.0)/ (vote.at<int>(1,0)+vote.at<int>(1,1))* log2((vote.at<int>(1,1)*1.0)/ (vote.at<int>(1,0)+vote.at<int>(1,1))));
 
         if (isnan(e.at(i)))
         {
             e.at(i)=0;
         }
 
     }
     MITK_INFO << "Done";
 
     /*Save entropy values for analysis*/
-//    std::ofstream myfile3;
-//    myfile3.open("/home/r948e/mycsv/entropydata" + std::to_string(m_activeCycle) + ".csv");
-//    for (unsigned int i = 0; i < e.size(); i++)
-//    {
-//        myfile3 << e.at(i) << ' ';
-//    }
-//    myfile3.close();
+    std::ofstream myfile3;
+    myfile3.open("/home/r948e/mycsv/entropydata_" + std::to_string(m_activeCycle) + ".csv");
+    for (unsigned int i = 0; i < e.size(); i++)
+    {
+        myfile3 << e.at(i) << ' ';
+    }
+    myfile3.close();
 
 
     MITK_INFO << "--------------";
     MITK_INFO << "Prediction vector size:";
     MITK_INFO << indexPrediction.size();
     MITK_INFO << "Entropy vector size:";
     MITK_INFO << e.size();
 
     MITK_INFO << "--------------";
 
     /*Get index of most unertain data (lengths defines how many data is saved)*/
-    int lengths=500;
-//  int lengths = std::count_if(e.begin(), e.end(),[&](auto const& val){ return val >= 0.9; });
+//    int lengths=500;
+  int lengths = std::count_if(e.begin(), e.end(),[&](auto const& val){ return val >= 0.95; });
+  if (length<500)
+  {
+      length=500
+  }
+
     std::vector<unsigned int> indexUnc = Sort(e, lengths);
 
     MITK_INFO << indexUnc.size();
 
 
     vnl_matrix<float> distances_matrix;
 
     distances_matrix.set_size(lengths, lengths);
     distances_matrix.fill(0.0);
 
     std::vector<float> distances_matrix_mean;
 
 
     for (int i=0; i<lengths; i++)
     {
         for (int k=0; k<lengths; k++)
         {
             /*From the length.size() Samples with the highest Entropey calculate the differen between the Features*/
             vnl_matrix<float> diff =  m_DistancesTest.at(indexUnc.at(i)) - m_DistancesTest.at(indexUnc.at(k));
 
             /*Into the eucledean difference matrix, put the distance in Feature Space between every sample pair*/
             distances_matrix.put(i,k,diff.absolute_value_sum()/m_DistancesTest.at(0).size());
 
         }
         /*For every Sample/Streamline get the mean eucledean distance to all other Samples => one value for every Sample*/
         distances_matrix_mean.push_back(distances_matrix.get_row(i).mean());
 //        MITK_INFO << meanval.at(i);
 
     }
 
 //    vnl_vector<float> sum_matrix;
 //    sum_matrix.set_size(lengths);
 //    sum_matrix.fill(0.0);
 
 
 //    MITK_INFO << distances_matrix.get_row(myidx.at(i)+ sum_matrix.get_row(0)
 
 
 //    for (int i=0; i<lengths; i++)
 //    {
 ////        unsigned int cur_i = indexUnc.at(myidx.at(i));
 //        /*Save mean distance of all used Samples*/
 //        sum_matrix = (sum_matrix + distances_matrix.get_row(myidx.at(i)))/=(i+1);
 
 //        myidx.push_back(distances_matrix.get_row(myidx.at(i)).arg_max());
 ////        myidx.push_back(sum_matrix.arg_max());
 //        indexUncDist.push_back(indexUnc.at(myidx.at(i)));
 ////        distances_matrix.set_column(myidx.at(i), 0.0001);
 //        distances_matrix.set_column(myidx.at(i), 0.0001);
 //        sum_matrix.put(myidx.at(i), 0.0001);
 ////        MITK_INFO<< sum_matrix;
 
 //    }
 
     /*Matrix that stores distances of used samples */
 //    vnl_matrix<float> sum_matrix;
 //    sum_matrix.set_size(lengths, lengths);
 //    sum_matrix.set_size(lengths, lengths);
 
     /*Index to find values in distancematrix*/
     std::vector<unsigned int> myidx;
     /*Index to find actual streamlines using indexUnc*/
     std::vector<unsigned int> indexUncDist;
     /*Start with the Streamline of the highest entropy, which is in distance_matrix at idx 0*/
     myidx.push_back(0);
     indexUncDist.push_back(indexUnc.at(myidx.at(0)));
 
     /*Vecotr that stores minvalues of current iteration*/
     vnl_matrix<float> cur_vec;
     cur_vec.set_size(1,lengths);
     cur_vec.fill(0.0);
     for (int i=0; i<lengths; i++)
     {
 
 //        unsigned int cur_i = indexUnc.at(myidx.at(i));
 
         /*Save mean distance of all used Samples*/
         vnl_matrix<float> sum_matrix;
         sum_matrix.set_size(myidx.size(), lengths);
         sum_matrix.fill(0);
         for (unsigned int ii=0; ii<myidx.size(); ii++)
         {
 
             sum_matrix.set_row(ii, distances_matrix.get_column(myidx.at(ii)));
         }
 
         for (unsigned int k=0; k<sum_matrix.columns(); k++)
         {
             cur_vec.put(0,k, sum_matrix.get_column(k).min_value());
         }
         myidx.push_back(cur_vec.arg_max());
 
 
         indexUncDist.push_back(indexUnc.at(myidx.at(i+1)));
         sum_matrix.clear();
 
     }
 
 //    std::vector<unsigned int> indexUncdist;
 //    std::priority_queue<std::pair<float, int>> qq;
 //    for (unsigned int i = 0; i < distances_matrix_mean.size(); ++i)
 //    {
 //        qq.push(std::pair<float, int>(distances_matrix_mean[i], i));
 //    }
 ////    int k = m_DistancesTest.size(); // number of indices we need
 ////    int k = lengths; // number of indices we need
 //    for (int i = 0; i < lengths; ++i)
 //    {
 //        int kki = qq.top().second;
 
 //        indexUncdist.push_back(indexUnc.at(kki));
 //        qq.pop();
 //    }
 
     MITK_INFO << "Dist_stop";
 
 //    std::ofstream myfile6;
 //    myfile6.open("/home/r948e/mycsv/distances_matrix_mean.csv");
 //    for (unsigned int i = 0; i < distances_matrix_mean.size(); i++)
 //    {
 //        myfile6 << distances_matrix_mean.at(i) << ' ';
 //    }
 //    myfile6.close();
 
 //    std::ofstream myfile5;
 //    myfile5.open("/home/r948e/mycsv/indexUncdist.csv");
 //    for (unsigned int i = 0; i < indexUncdist.size(); i++)
 //    {
 //        myfile5 << indexUncdist.at(i) << ' ';
 //    }
 //    myfile5.close();
 
 //    MITK_INFO << distances_matrix;
 //    MITK_INFO << distances_matrix.max_value();
 //    MITK_INFO << distances_matrix.arg_max();
 
 
 //    vnl_matrix<float> myx =  m_DistancesTest.at(indexUnc.at(0)) - m_DistancesTest.at(indexUnc.at(1));
 ////    myx = (m_DistancesTest.at(indexUnc.at(0)) - m_DistancesTest.at(indexUnc.at(1)));
 //    MITK_INFO << m_DistancesTest.at(indexUnc.at(0));
 //    MITK_INFO << m_DistancesTest.at(indexUnc.at(1));
 //    MITK_INFO << myx.get(0,0);
 //    MITK_INFO << sqrt(pow(myx.get(0,0),2));
 //    MITK_INFO << myx.get(0,1);
 //    MITK_INFO << myx.absolute_value_sum()/m_DistancesTest.at(0).size();
 //    MITK_INFO << "Done";
 
     /*Save Prediction*/
     index_vec.push_back(indexPrediction);
     /*Save index of uncertainty measures*/
     index_vec.push_back(indexUnc);
     /*Save index of uncertainty measures influenced by distance*/
     index_vec.push_back(indexUncDist);
 
     return index_vec;
 
 }
 
 mitk::FiberBundle::Pointer StreamlineFeatureExtractor::CreatePrediction(std::vector<unsigned int> &index)
 {
 
 
 
     mitk::FiberBundle::Pointer Prediction;
     MITK_INFO << "Create Bundle";
 
     vtkSmartPointer<vtkPolyData> FibersData;
     FibersData = vtkSmartPointer<vtkPolyData>::New();
     FibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
     FibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
 //    vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 //    weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
 
     unsigned int indexSize = index.size();
     unsigned int counter = 0;
     MITK_INFO << "Start Loop";
     for (unsigned int i=0; i<indexSize; i++)
     {
 
         vtkCell* cell = m_TractogramTest->GetFiberPolyData()->GetCell(index[i]);
         auto numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (unsigned 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++;
 
     }
     MITK_INFO << "Counter";
     MITK_INFO << counter;
 
 
      vNewPolyData->SetLines(vNewLines);
      vNewPolyData->SetPoints(vNewPoints);
 
      FibersData = vtkSmartPointer<vtkPolyData>::New();
      FibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
      FibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
      FibersData->SetPoints(vNewPoints);
      FibersData->SetLines(vNewLines);
 
      Prediction = mitk::FiberBundle::New(vNewPolyData);
 
 //     Bundle->SetFiberColors(255, 255, 255);
     MITK_INFO << "Cells Prediciton";
     MITK_INFO << Prediction->GetFiberPolyData()->GetNumberOfCells();
     MITK_INFO << "Cells Tractorgram";
     MITK_INFO << m_TractogramTest->GetFiberPolyData()->GetNumberOfCells();
 
     return Prediction;
 }
 
 void  StreamlineFeatureExtractor::GenerateData()
 {
     MITK_INFO << "Update";
 
 //    mitk::FiberBundle::Pointer inputPrototypes = mitk::IOUtil::Load<mitk::FiberBundle>("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/data/Synt_tract_40_prototypes.trk");
 
     std::vector<vnl_matrix<float> >             T_Prototypes;
     std::vector<vnl_matrix<float> >             T_TractogramPlus;
     std::vector<vnl_matrix<float> >             T_TractogramMinus;
     std::vector<vnl_matrix<float> >             T_TractogramTest;
     std::vector<vnl_matrix<float> >             T_mergedPrototypes;
 
     T_Prototypes = ResampleFibers(m_inputPrototypes);
     T_TractogramMinus= ResampleFibers(m_TractogramMinus);
     T_TractogramPlus= ResampleFibers(m_TractogramPlus);
 
     /* Merge T_Prototypes, T_TractogramMinus and T_TractogramPlus for extra Features*/
     T_mergedPrototypes = MergeTractogram(T_Prototypes, T_TractogramPlus, T_TractogramMinus);
 
 
 
     MITK_INFO << "Calculate Features";
     m_DistancesMinus = CalculateDmdf(T_TractogramMinus, T_mergedPrototypes);
     m_DistancesPlus = CalculateDmdf(T_TractogramPlus, T_mergedPrototypes);
 
 
 
 
     std::ifstream f(m_DistancesTestName);
 
-    MITK_INFO << m_DistancesTestName;
-    if (f.good())
+
+    if (f.good() && m_activeCycle!=0)
     {
-        MITK_INFO << "File exists";
+        MITK_INFO << "Loading Features of Tractogram";
         m_DistancesTest.clear();
         std::ifstream myFile(m_DistancesTestName);
 
         if(!myFile.is_open()) throw std::runtime_error("Could not open file");
         std::string line;
         vnl_matrix<float> curline;
         curline.set_size(1, m_DistancesPlus.at(0).cols());
         curline.fill(0.0);
 
         float val;
 
         while(std::getline(myFile, line))
             {
                 // Create a stringstream of the current line
                 std::stringstream ss(line);
 //                MITK_INFO << ss;
 
                 // Keep track of the current column index
                 int colIdx = 0;
 
                 // Extract each integer
                 while(ss >> val){
 
 //                    // Add the current integer to the 'colIdx' column's values vector
                     curline.put(0,colIdx, val);
 
 //                    // If the next token is a comma, ignore it and move on
 //                    if(ss.peek() == ',') ss.ignore();
 //                    // Increment the column index
                     colIdx++;
                 }
                 m_DistancesTest.push_back(curline);
             }
 
             // Close file
             myFile.close();
     }
     else
     {
         MITK_INFO << m_DistancesTestName;
         MITK_INFO << "Resample Test Data";
         T_TractogramTest= ResampleFibers(m_TractogramTest);
         MITK_INFO << "Calculate Features of Test Data";
         m_DistancesTest= CalculateDmdf(T_TractogramTest, T_mergedPrototypes);
 
+                std::ofstream myFile(m_DistancesTestName);
+        //        myFile << colname << "\n";
+                for(long unsigned int i = 0; i < m_DistancesTest.size(); ++i)
+                {
+                    myFile << m_DistancesTest.at(i);
+                }
+                myFile.close();
+
     }
     MITK_INFO << m_DistancesTest.size();
 
 
     MITK_INFO << "Sizes of Plus and Minus";
     MITK_INFO << m_DistancesPlus.size() + m_DistancesMinus.size();
+    MITK_INFO << "Sizes of Prototypes";
+    MITK_INFO << T_mergedPrototypes.size();
+    MITK_INFO << T_mergedPrototypes.at(0).rows();
     MITK_INFO << "Size of Test Data";
     MITK_INFO << m_DistancesTest.size();
     MITK_INFO << "Done with Datacreation";
     m_index =GetData();
 
 }
 
 
 
 }
 
 
 
-
diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
index b9dab44..58e23a5 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
@@ -1,108 +1,110 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 StreamlineFeatureExtractor_h
 #define StreamlineFeatureExtractor_h
 
 
 #include "MitkFiberDissectionExports.h"
 // MITK
 #include <mitkPlanarEllipse.h>
 #include <mitkFiberBundle.h>
 
 // ITK
 #include <itkProcessObject.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 // OpenCV
 #include <opencv2/ml.hpp>
 #include <opencv2/opencv.hpp>
 #include <opencv2/highgui/highgui.hpp>
 
 namespace mitk{
 
 /**
 * \brief    */
 
 class MITKFIBERDISSECTION_EXPORT StreamlineFeatureExtractor      
 {
 public:
 
 
   StreamlineFeatureExtractor();
   ~StreamlineFeatureExtractor();
 
   typedef itk::Image< float, 3 >                              FloatImageType;
   typedef itk::Image< unsigned char, 3 >                      UcharImageType;
 
   void Update(){
     this->GenerateData();
   }
 
   void SetTractogramPlus(const mitk::FiberBundle::Pointer &Tractogram);
   void SetTractogramMinus(const mitk::FiberBundle::Pointer &Tractogram);
   void SetTractogramTest(const mitk::FiberBundle::Pointer &Tractogram, std::string TractogramTestName);
   void SetTractogramPrototypes(const mitk::FiberBundle::Pointer &TractogramPrototypes, bool standard);
   void SetActiveCycle(int &activeCycle);
+  void SetInitRandom(int &initRandom);
 //  void SetRandomThreshold(int &threshold);
 
 
   void CreateClassifier();
   std::vector<std::vector<unsigned int>>  GetData();
 
 //  void CreatePrediction(std::vector<unsigned int> &index);
   mitk::FiberBundle::Pointer CreatePrediction(std::vector<unsigned int> &index);
 
   mitk::FiberBundle::Pointer                  m_Prediction;
   mitk::FiberBundle::Pointer                  m_ToLabel;
 
   std::vector<std::vector<unsigned int>>      m_index;
 
 
 protected:
 
   void GenerateData();
   std::vector< vnl_matrix<float> > ResampleFibers(FiberBundle::Pointer tractogram);
   std::vector<vnl_matrix<float> > CalculateDmdf(std::vector<vnl_matrix<float> > tractogram,
                                                 std::vector<vnl_matrix<float> > prototypes);
   std::vector< vnl_matrix<float> > MergeTractogram(std::vector<vnl_matrix<float> > prototypes,
                                                   std::vector<vnl_matrix<float> > positive_local_prototypes,
                                                   std::vector<vnl_matrix<float> > negative_local_prototypes);
   std::vector<unsigned int> Sort(std::vector<float> sortingVector, int lengths);
 
 
 
   unsigned int                                m_NumPoints;
   int                                         m_activeCycle;
+  int                                         m_initRandom;
   int                                         m_thresh;
   mitk::FiberBundle::Pointer                  m_TractogramPlus;
   mitk::FiberBundle::Pointer                  m_TractogramMinus;
   mitk::FiberBundle::Pointer                  m_TractogramTest;
   mitk::FiberBundle::Pointer                  m_inputPrototypes;
   std::string                                 m_DistancesTestName;
   std::vector<vnl_matrix<float> >             m_DistancesPlus;
   std::vector<vnl_matrix<float> >             m_DistancesMinus;
   std::vector<vnl_matrix<float> >             m_DistancesTest;
   cv::Ptr<cv::ml::TrainData>                  m_traindata;
 };
 }
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.cpp
index 0bca8ee..aad5e77 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.cpp
@@ -1,1196 +1,1233 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchPart.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkInteractiveFiberDissectionView.h"
 #include <QmitkRenderWindow.h> //Pointset
 #include <QmitkPointListWidget.h> //Pointset
 
 #include <QMessageBox>
 
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 //#include <mitkStreamlineFeatureExtractor.h>
 
 #include <mitkInteractionConst.h>
 #include "usModuleRegistry.h"
 //#include <itkFiberCurvatureFilter.h>
 
 
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 #include <itkFiberExtractionFilter.h>
 
 #include <mitkInteractionEventObserver.h>
 #include <vtkCellPicker.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <vnl/vnl_sparse_matrix.h>
 
 const std::string QmitkInteractiveFiberDissectionView::VIEW_ID = "org.mitk.views.interactivefiberdissection";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkInteractiveFiberDissectionView::QmitkInteractiveFiberDissectionView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_IterationCounter(0)
   , m_RandomExtractionCounter(0)
   , m_activeCycleCounter(0)
   , m_StreamlineInteractor(nullptr)
 {
 
 }
 
 // Destructor
 QmitkInteractiveFiberDissectionView::~QmitkInteractiveFiberDissectionView()
 {
   //disable interactor
   if (m_StreamlineInteractor != nullptr)
   {
 //    m_StreamlineInteractor->SetStreamlineNode(nullptr);
     m_StreamlineInteractor->EnableInteraction(false);
   }
 }
 
 
 void QmitkInteractiveFiberDissectionView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkInteractiveFiberDissectionViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_selectedPointSetWidget->SetDataStorage(GetDataStorage());//pointset
     m_Controls->m_selectedPointSetWidget->SetNodePredicate(mitk::NodePredicateAnd::New(//pointset
       mitk::TNodePredicateDataType<mitk::PointSet>::New(),//pointset
       mitk::NodePredicateNot::New(mitk::NodePredicateOr::New(//pointset
         mitk::NodePredicateProperty::New("helper object"),//pointset
         mitk::NodePredicateProperty::New("hidden object")))));//pointset
 
     m_Controls->m_selectedPointSetWidget->SetSelectionIsOptional(true);//pointset
     m_Controls->m_selectedPointSetWidget->SetAutoSelectNewNodes(true);//pointset
     m_Controls->m_selectedPointSetWidget->SetEmptyInfo(QString("Please select a point set"));//pointset
     m_Controls->m_selectedPointSetWidget->SetPopUpTitel(QString("Select point set"));//pointsett
 
     m_Controls->m_BundleBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isBundle= mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     m_Controls->m_BundleBox->SetPredicate( isBundle );
 
     m_Controls->m_PrototypeBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isPrototype = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     m_Controls->m_PrototypeBox->SetPredicate( isPrototype );
 
 
 
 
     connect(m_Controls->m_ErazorButton, SIGNAL(toggled(bool)), this, SLOT( RemovefromBundle(bool) ) ); //need
 
     connect(m_Controls->m_StreamlineCreation, SIGNAL( clicked() ), this, SLOT( CreateStreamline()));
 
     connect(m_Controls->m_AddRandomFibers, SIGNAL( clicked() ), this, SLOT( ExtractRandomFibersFromTractogram() ) ); //need
 
     connect(m_Controls->m_TrainClassifier, SIGNAL( clicked() ), this, SLOT( StartAlgorithm( )));
 
     connect(m_Controls->m_CreatePrediction, SIGNAL( clicked() ), this, SLOT( CreatePredictionNode( )));
 
     connect(m_Controls->m_AddUncertainFibers, SIGNAL( clicked() ), this, SLOT( CreateUncertaintySampleNode( )));
 
     connect(m_Controls->m_AddDistanceFibers, SIGNAL( clicked() ), this, SLOT( CreateDistanceSampleNode( )));
 
     connect(m_Controls->m_unclabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromUncertainty(bool) ) ); //need
 
     connect(m_Controls->m_distlabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromDistance(bool) ) ); //need
 
     connect(m_Controls->m_predlabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromPrediction(bool) ) ); //need
+
+    connect(m_Controls->m_sellabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromSelection(bool) ) ); //need
     
     connect(m_Controls->m_ResampleButton, SIGNAL( clicked() ), this, SLOT( ResampleTractogram( ) ) );
 
     connect(m_Controls->m_RandomPrototypesButton, SIGNAL( clicked() ), this, SLOT( RandomPrototypes( ) ) );
 
     connect(m_Controls->m_SFFPrototypesButton, SIGNAL( clicked() ), this, SLOT( SFFPrototypes( ) ) );
 
 
 
     connect(m_Controls->m_addPointSetPushButton, &QPushButton::clicked,//pointset
       this, &QmitkInteractiveFiberDissectionView::OnAddPointSetClicked);//pointset
     connect(m_Controls->m_selectedPointSetWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,//pointset
       this, &QmitkInteractiveFiberDissectionView::OnCurrentSelectionChanged);//pointset
 
 
 
 
     auto renderWindowPart = this->GetRenderWindowPart();//pointset
     if (nullptr != renderWindowPart)//pointset
       this->RenderWindowPartActivated(renderWindowPart);//pointset
     this->OnCurrentSelectionChanged(m_Controls->m_selectedPointSetWidget->GetSelectedNodes());//pointset
 
   }
 
   UpdateGui();
 }
 
 
 void QmitkInteractiveFiberDissectionView::SetFocus()
 {
   m_Controls->toolBoxx->setFocus();
   //m_Controls->m_addPointSetPushButton->setFocus();//pointset
 }
 
 void QmitkInteractiveFiberDissectionView::UpdateGui()
 {
   m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
   m_Controls->m_InputData->setTitle("Please Select Input Data");
 
    // disable alle frames
 
   m_Controls->m_ErazorButton->setCheckable(true);
   m_Controls->m_ErazorButton->setEnabled(false);
   m_Controls->m_unclabeling->setCheckable(true);
   m_Controls->m_unclabeling->setEnabled(false);
   m_Controls->m_predlabeling->setCheckable(true);
   m_Controls->m_predlabeling->setEnabled(false);
   m_Controls->m_distlabeling->setCheckable(true);
   m_Controls->m_distlabeling->setEnabled(false);
+  m_Controls->m_sellabeling->setCheckable(true);
+  m_Controls->m_sellabeling->setEnabled(false);
 
 
 
   m_Controls->m_addPointSetPushButton->setEnabled(false);
   m_Controls->m_StreamlineCreation->setEnabled(false);
   m_Controls->m_TrainClassifier->setEnabled(false);
   m_Controls->m_CreatePrediction->setEnabled(false);
   m_Controls->m_CreateUncertantyMap->setEnabled(false);
   m_Controls->m_Numtolabel->setEnabled(false);
   m_Controls->m_Numtolabel2->setEnabled(false);
   m_Controls->m_addPointSetPushButton->setEnabled(false);
   m_Controls->m_AddRandomFibers->setEnabled(false);
   m_Controls->m_AddDistanceFibers->setEnabled(false);
   m_Controls->m_AddUncertainFibers->setEnabled(false);
-  m_Controls->m_unclabeling->setEnabled(false);
-  m_Controls->m_predlabeling->setEnabled(false);
-  m_Controls->m_distlabeling->setEnabled(false);
 //  m_Controls->m_PrototypeBox->setEditable(false);
 //  m_Controls->m_useStandardP->
 
   bool fibSelected = !m_SelectedFB.empty();
   bool multipleFibsSelected = (m_SelectedFB.size()>1);
   bool sthSelected = m_SelectedImageNode.IsNotNull();
   bool psSelected = m_SelectedPS.IsNotNull();
 //  bool nfibSelected = !m_newfibersBundleNode.empty();
 //  bool posSelected = !m_positivBundlesNode.empty();
   bool nfibSelected = m_newfibersBundleNode.IsNotNull();
 //  bool posSelected = !m_positivBundlesNode.IsNotNull();
 //  bool negSelected = !m_negativeBundleNode.IsNotNull();
     bool posSelected = this->GetDataStorage()->Exists(m_positivBundlesNode);
     bool negSelected = this->GetDataStorage()->Exists(m_negativeBundleNode);
     bool indexSelected = !m_index.empty();
     bool uncertaintySelected = this->GetDataStorage()->Exists(m_UncertaintyLabelNode);
     bool distanceSelected = this->GetDataStorage()->Exists(m_DistanceLabelNode);
     bool predictionSelected = this->GetDataStorage()->Exists(m_PredictionNode);
 
 
 
   // toggle visibility of elements according to selected method
 
 
   // are fiber bundles selected?
   if ( fibSelected )
   {
     m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
     m_Controls->m_addPointSetPushButton->setEnabled(true);
     m_Controls->m_AddRandomFibers->setEnabled(true);
+    m_Controls->m_sellabeling->setEnabled(true);
 
 
 
     // more than two bundles needed to join/subtract
     if (multipleFibsSelected)
     {
       m_Controls->m_FibLabel->setText("multiple bundles selected");
     }
 
 
 
   }
 
 
   // is image selected
   if (sthSelected)
   {
     m_Controls->m_addPointSetPushButton->setEnabled(true);
   }
 
   if (psSelected)
   {
       m_Controls->m_StreamlineCreation->setEnabled(true);
   }
 
   if (nfibSelected && posSelected)
   {
       m_Controls->m_ErazorButton->setEnabled(true);
   }
 
 
   if (posSelected && negSelected)
   {
       m_Controls->m_TrainClassifier->setEnabled(true);
   }
 
   if (indexSelected)
   {
       m_Controls->m_CreatePrediction->setEnabled(true);
       m_Controls->m_AddUncertainFibers->setEnabled(true);
       m_Controls->m_Numtolabel->setEnabled(true);
       m_Controls->m_AddDistanceFibers->setEnabled(true);
       m_Controls->m_Numtolabel2->setEnabled(true);
   }
 
   if (uncertaintySelected)
   {
       m_Controls->m_unclabeling->setEnabled(true);
   }
 
   if (predictionSelected)
   {
       m_Controls->m_predlabeling->setEnabled(true);
   }
 
   if (distanceSelected)
   {
       m_Controls->m_distlabeling->setEnabled(true);
   }
 
-  if (m_Controls->m_useStandardP->isChecked())
-  {
-      m_Controls->m_PrototypeBox->setEditable(true);
-  }
+//  if (m_Controls->m_useStandardP->isChecked())
+//  {
+//      m_Controls->m_PrototypeBox->setEditable(true);
+//  }
 
 
 
 
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::OnEndInteraction()
 {
 
 }
 
 void QmitkInteractiveFiberDissectionView::ResampleTractogram()
 {
     mitk::DataNode::Pointer node = m_Controls->m_BundleBox->GetSelectedNode();
     auto tractogram = dynamic_cast<mitk::FiberBundle *>(node->GetData());
     mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
     temp_fib->ResampleToNumPoints(40);
     MITK_INFO << "Resampling Done";
 
     mitk::DataNode::Pointer newnode = mitk::DataNode::New();
     newnode->SetData( temp_fib );
     newnode->SetName( node->GetName() + "_" + std::to_string(40) );
     this->GetDataStorage()->Add(newnode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::RandomPrototypes()
 {
 
 
      MITK_INFO << "Number of Fibers to use as Prototypes: ";
      MITK_INFO << m_Controls->m_NumPrototypes->value();
 
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_Controls->m_BundleBox->GetSelectedNode()->GetData());
 
       MITK_INFO << fib->GetNumFibers();
       std::vector<int> myvec;
       for (unsigned int k=0; k<fib->GetNumFibers(); k++)
       {
         myvec.push_back(k);
       }
 //      auto rng = std::default_random_engine {};
-//      std::random_shuffle(std::begin(myvec), std::end(myvec));
+      std::random_shuffle(std::begin(myvec), std::end(myvec));
 
       vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
       vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 
        /* Check wether all Streamlines of the bundles are labeled... If all are labeled Skip for Loop*/
       unsigned int counter = 0;
 
       for (int i=0; i<m_Controls->m_NumPrototypes->value(); i++)
       {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(myvec.at(i));
         auto numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (unsigned 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(myvec.at(i)));
         vNewLines->InsertNextCell(container);
         counter++;
 
       }
 
 
 
       vNewPolyData->SetLines(vNewLines);
       vNewPolyData->SetPoints(vNewPoints);
 
       mitk::FiberBundle::Pointer PrototypesBundle = mitk::FiberBundle::New(vNewPolyData);
       PrototypesBundle->SetFiberWeights(weights);
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(PrototypesBundle);
       node->SetName("Random_Prototypes");
 
 //      MITK_INFO << "Number of Streamlines in first function";
 //      MITK_INFO << m_newfibersBundleNode->GetData()->GetFiberPolyData()->GetNumberOfCells();
       this->GetDataStorage()->Add(node);
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::SFFPrototypes()
 {
 
 
      MITK_INFO << "Number of Fibers to use as Prototypes: ";
      MITK_INFO << m_Controls->m_NumPrototypes->value();
      MITK_INFO << "Start Creating Prototypes based on SFF";
 
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_Controls->m_BundleBox->GetSelectedNode()->GetData());
 
       /* Get Subset of Tractogram*/
       int size_subset = std::max(1.0, ceil(3.0 * m_Controls->m_NumPrototypes->value() * std::log(m_Controls->m_NumPrototypes->value())));
 
       MITK_INFO << fib->GetNumFibers();
       std::vector<int> myvec;
       for (unsigned int k=0; k<fib->GetNumFibers(); k++)
       {
         myvec.push_back(k);
       }
 
 //      std::random_shuffle(std::begin(myvec), std::end(myvec));
 
       vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
       vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 
 
       unsigned int counter = 0;
 
       for (int i=0; i<size_subset; i++)
       {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(myvec.at(i));
         auto numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (unsigned 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(myvec.at(i)));
         vNewLines->InsertNextCell(container);
         counter++;
 
       }
 
 
       vNewPolyData->SetLines(vNewLines);
       vNewPolyData->SetPoints(vNewPoints);
 
       mitk::FiberBundle::Pointer temp_fib = mitk::FiberBundle::New(vNewPolyData);
       temp_fib->SetFiberWeights(weights);
 
       MITK_INFO << temp_fib->GetFiberPolyData()->GetNumberOfCells();
       /* Create std::vector <vnl_matrix> of the SubsetBundle*/
       std::vector< vnl_matrix<float> > out_fib(temp_fib->GetFiberPolyData()->GetNumberOfCells());
 
       for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
       {
         vtkCell* cell = temp_fib->GetFiberPolyData()->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vnl_matrix<float> streamline;
         streamline.set_size(3, cell->GetNumberOfPoints());
         streamline.fill(0.0);
 
         for (int j=0; j<numPoints; j++)
         {
           double cand[3];
           points->GetPoint(j, cand);
 
           vnl_vector_fixed< float, 3 > candV;
           candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
           streamline.set_column(j, candV);
         }
 
     //        out_fib.push_back(streamline);
         out_fib.at(i)=streamline;
       }
 
 
       /* Calculate the distancematrix of Subset*/
       std::vector< vnl_matrix<float> >  dist_vec(out_fib.size());//
       cv::parallel_for_(cv::Range(0, out_fib.size()), [&](const cv::Range &range)
       {
       for (int i = range.start; i < range.end; i++)
 
   //    for (unsigned int i=0; i<tractogram.size(); i++)
       {
 
           vnl_matrix<float> distances;
           distances.set_size(1, out_fib.size());
           distances.fill(0.0);
 
 
           for (unsigned int j=0; j<out_fib.size(); j++)
           {
               vnl_matrix<float> single_distances;
               single_distances.set_size(1, out_fib.at(0).cols());
               single_distances.fill(0.0);
               vnl_matrix<float> single_distances_flip;
               single_distances_flip.set_size(1, out_fib.at(0).cols());
               single_distances_flip.fill(0.0);
               for (unsigned int ik=0; ik<out_fib.at(0).cols(); ik++)
               {
                   double cur_dist;
                   double cur_dist_flip;
 
                   cur_dist = sqrt(pow(out_fib.at(i).get(0,ik) - out_fib.at(j).get(0,ik), 2.0) +
                                          pow(out_fib.at(i).get(1,ik) - out_fib.at(j).get(1,ik), 2.0) +
                                          pow(out_fib.at(i).get(2,ik) - out_fib.at(j).get(2,ik), 2.0));
 
                   cur_dist_flip = sqrt(pow(out_fib.at(i).get(0,ik) - out_fib.at(j).get(0,out_fib.at(0).cols()-(ik+1)), 2.0) +
                                          pow(out_fib.at(i).get(1,ik) - out_fib.at(j).get(1,out_fib.at(0).cols()-(ik+1)), 2.0) +
                                          pow(out_fib.at(i).get(2,ik) - out_fib.at(j).get(2,out_fib.at(0).cols()-(ik+1)), 2.0));
 
                   single_distances.put(0,ik, cur_dist);
                   single_distances_flip.put(0,ik, cur_dist_flip);
 
               }
 
               if (single_distances_flip.mean()> single_distances.mean())
               {
                   distances.put(0,j, single_distances.mean());
               }
               else {
                   distances.put(0,j, single_distances_flip.mean());
               }
 
 
 
           }
   //        dist_vec.push_back(distances);
           dist_vec.at(i) = distances;
       }
       });
 
 
       /*Index to find values in distancematrix*/
       std::vector<unsigned int> myidx;
       /*Index to find actual streamlines using indexUnc*/
       std::vector<unsigned int> indexUncDist;
       /*Start with the Streamline of the highest entropy, which is in distance_matrix at idx 0*/
       myidx.push_back(0);
 
       /*Vecotr that stores minvalues of current iteration*/
       vnl_matrix<float> cur_vec;
       cur_vec.set_size(1, size_subset);
       cur_vec.fill(0.0);
       for (int i=0; i<m_Controls->m_NumPrototypes->value(); i++)
       {
 
   //        unsigned int cur_i = indexUnc.at(myidx.at(i));
 
           /*Save mean distance of all used Samples*/
 
           vnl_matrix<float> sum_matrix;
           sum_matrix.set_size(myidx.size(), size_subset);
           sum_matrix.fill(0);
           for (unsigned int ii=0; ii<myidx.size(); ii++)
           {
 
               sum_matrix.set_row(ii, dist_vec.at(myidx.at(ii)).get_row(0));
           }
 
           for (unsigned int k=0; k<sum_matrix.columns(); k++)
           {
               cur_vec.put(0,k, sum_matrix.get_column(k).min_value());
           }
           myidx.push_back(cur_vec.arg_max());
           sum_matrix.clear();
 
         }
           vtkSmartPointer<vtkPolyData> vNewPolyData2 = vtkSmartPointer<vtkPolyData>::New();
           vtkSmartPointer<vtkCellArray> vNewLines2 = vtkSmartPointer<vtkCellArray>::New();
           vtkSmartPointer<vtkPoints> vNewPoints2 = vtkSmartPointer<vtkPoints>::New();
 
           vtkSmartPointer<vtkFloatArray> weights2 = vtkSmartPointer<vtkFloatArray>::New();
 
            /* Check wether all Streamlines of the bundles are labeled... If all are labeled Skip for Loop*/
           counter = 0;
 
           for (int i=0; i<m_Controls->m_NumPrototypes->value(); i++)
           {
 
             vtkCell* cell = fib->GetFiberPolyData()->GetCell(myidx.at(i));
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints2->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             weights2->InsertValue(counter, fib->GetFiberWeight(myvec.at(i)));
             vNewLines2->InsertNextCell(container);
             counter++;
 
           }
 
           vNewPolyData2->SetLines(vNewLines2);
           vNewPolyData2->SetPoints(vNewPoints2);
 
           mitk::FiberBundle::Pointer PrototypesBundle = mitk::FiberBundle::New(vNewPolyData2);
           PrototypesBundle->SetFiberWeights(weights2);
           MITK_INFO << PrototypesBundle->GetFiberPolyData()->GetNumberOfCells();
 
 
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(PrototypesBundle);
       node->SetName("SFF_Prototypes");
 
 ////      MITK_INFO << "Number of Streamlines in first function";
 ////      MITK_INFO << m_newfibersBundleNode->GetData()->GetFiberPolyData()->GetNumberOfCells();
       this->GetDataStorage()->Add(node);
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::OnAddPointSetClicked()//pointset
 {
   // ask for the name of the point set
   bool ok = false;
   QString name = QInputDialog::getText(QApplication::activeWindow(),
     tr("Add point set..."), tr("Enter name for the new point set"), QLineEdit::Normal, tr("PointSet").arg(++m_IterationCounter), &ok);
 //  QString name = "PointSet";
   if (!ok || name.isEmpty())
   {
     return;
   }
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   pointSetNode->SetData(pointSet);
   pointSetNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   pointSetNode->SetProperty("opacity", mitk::FloatProperty::New(1));
   pointSetNode->SetColor(1.0, 1.0, 0.0);
   this->GetDataStorage()->Add(pointSetNode, m_SelectedImageNode);
 
 
   m_Controls->m_selectedPointSetWidget->SetCurrentSelectedNode(pointSetNode);
 }
 
 void QmitkInteractiveFiberDissectionView::OnCurrentSelectionChanged(QmitkSingleNodeSelectionWidget::NodeList /*nodes*/)//pointset
 {
 
   m_Controls->m_poinSetListWidget->SetPointSetNode(m_Controls->m_selectedPointSetWidget->GetSelectedNode());
   m_SelectedPS = m_Controls->m_selectedPointSetWidget->GetSelectedNode();
 
 //  m_Controls->m_trainbundleWidget->SetPointSetNode(m_Controls->m_trainbundleWidget->GetSelectedNode());
 //  m_trainbundle = m_Controls->m_trainbundleWidget->GetSelectedNode();
 
 
   UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
 
     m_SelectedFB.clear();
 
     if (nodes.empty() || nodes.front().IsNull())
     {
       m_SelectedImageNode = nullptr;
     }
     else
     {
       m_SelectedImageNode = nodes.front();
     }
 
 
 
     for (auto node: nodes)
     {
       if (dynamic_cast<mitk::Image*>(node->GetData()))
           m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
       else if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
           m_SelectedFB.push_back(node);
     }
 
 
 
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)//pointset
 {
   if (nullptr != m_Controls)
   {
     m_Controls->m_poinSetListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
   }
 }
 
 void QmitkInteractiveFiberDissectionView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)//pointset
 {
   if (nullptr != m_Controls)
   {
     m_Controls->m_poinSetListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
   }
 }
 
 void QmitkInteractiveFiberDissectionView::CreateStreamline()
 {
 
     if (m_positivBundlesNode.IsNull())
     {
         mitk::DataNode::Pointer node = mitk::DataNode::New();
 
         m_positiveFibersData = vtkSmartPointer<vtkPolyData>::New();
         m_positiveFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
         m_positiveFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
         m_positiveBundle = mitk::FiberBundle:: New(m_positiveFibersData);
 
         node->SetData( m_positiveBundle );
         m_positivBundlesNode = node;
         this->GetDataStorage()->Add(m_positivBundlesNode);
       MITK_INFO << "Create Bundle";
     }
 
     if (!m_positivBundlesNode.IsNull())
     {
 
         this->GetDataStorage()->Remove(m_positivBundlesNode);
         MITK_INFO << "Adding fibers";
         MITK_INFO << m_positiveBundle->GetFiberPolyData()->GetNumberOfCells();
         m_positiveFibersData = m_positiveBundle->GetFiberPolyData();
     }
 
 
 
 
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
 
 
     unsigned int counter = 0;
     for (unsigned int i=0; i<m_positiveFibersData->GetNumberOfCells(); ++i)
     {
       MITK_INFO<< "New Line";
       vtkCell* cell = m_positiveFibersData->GetCell(i);
       auto numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       for (unsigned int j=0; j<numPoints; ++j)
       {
         double p[3];
         points->GetPoint(j, p);
 
         vtkIdType id = vNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
 
       vNewLines->InsertNextCell(container);
       counter++;
     }
 
     mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(m_SelectedPS->GetData());
 
 
     vnl_matrix<float> streamline;
     streamline.set_size(3, pointSet->GetSize());
     streamline.fill(0.0);
 
 
     mitk::PointSet::PointsIterator begin = pointSet->Begin();
     mitk::PointSet::PointsIterator end = pointSet->End();
     unsigned int i;
     mitk::PointSet::PointsContainer::Iterator it;
 
     for (it = begin, i = 0; it != end; ++it, ++i)
     {
         PointSet::PointType pt = pointSet->GetPoint(it->Index());
         vnl_vector_fixed< float, 3 > candV;
         candV[0]=pt[0]; candV[1]=pt[1]; candV[2]=pt[2];
         streamline.set_column(i, candV);
     }
 
       // build Fiber
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
 
       for (unsigned int j=0; j<streamline.cols(); j++)
       {
         double p[3];
         p[0] = streamline.get(0,j);
         p[1] = streamline.get(1,j);
         p[2] = streamline.get(2,j);
 
         vtkIdType id = vNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       MITK_INFO<< "Last Line from current pointset";
       vNewLines->InsertNextCell(container);
 
       vNewPolyData->SetPoints(vNewPoints);
       vNewPolyData->SetLines(vNewLines);
 
       m_positiveFibersData = vtkSmartPointer<vtkPolyData>::New();
       m_positiveFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
       m_positiveFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
       m_positiveFibersData->SetPoints(vNewPoints);
       m_positiveFibersData->SetLines(vNewLines);
 
       m_positiveBundle = mitk::FiberBundle::New(vNewPolyData);
 //      m_positiveBundle->SetTrackVisHeader(dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetData())->GetGeometry());
       m_positiveBundle->SetFiberColors(0, 255, 0);
 
 
 
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(m_positiveBundle);
       node->SetName("+Bundle");
       m_positivBundlesNode= node;
 
 
 
 
       MITK_INFO << "The + Bundle has Streamlines:";
       auto m_PosStreamline= dynamic_cast<mitk::FiberBundle *>(m_positivBundlesNode->GetData());
       MITK_INFO << m_PosStreamline->GetFiberPolyData()->GetNumberOfCells();
 
       this->GetDataStorage()->Add(m_positivBundlesNode);
 //      m_Controls->m_selectedPointSetWidget->m_ToggleAddPoint->setEnabled(false);
 
       UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::ExtractRandomFibersFromTractogram()
 {
     m_SelectedFB.at(0)->SetVisibility(false);
     m_Controls->m_ErazorButton->setChecked(false);
 
 
      MITK_INFO << "Number of Fibers to extract from Tractogram: ";
      MITK_INFO << m_Controls->m_NumRandomFibers->value();
      if (this->GetDataStorage()->Exists(m_newfibersBundleNode))
      {
          MITK_INFO << "To Label Bundle Exists";
          mitk::FiberBundle::Pointer Stack = dynamic_cast<mitk::FiberBundle *>(m_newfibersBundleNode->GetData());
          this->GetDataStorage()->Remove(m_newfibersBundleNode);
 
          mitk::DataNode::Pointer node = mitk::DataNode::New();
 
          m_newfibersFibersData = vtkSmartPointer<vtkPolyData>::New();
          m_newfibersFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
          m_newfibersBundle = mitk::FiberBundle:: New(m_newfibersFibersData);
          m_newfibersFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
 
 //         node->SetData( m_newfibersBundle );
 //         m_newfibersBundleNode = node ;
 
        MITK_INFO << "Create Bundle";
      }
 
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
 //      mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle *>(m_trainbundle->GetData());
 
       vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
       vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 //      weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
 
        /* Check weather all Streamlines of the bundles are labeled... If all are labeled Skip for Loop*/
       unsigned int counter = 0;
       int thresh1;
       int thresh2;
       thresh2 = m_Controls->m_NumRandomFibers->value()*(m_RandomExtractionCounter+1);
       thresh1 = m_Controls->m_NumRandomFibers->value()*(m_RandomExtractionCounter);
       if (thresh1>fib->GetFiberPolyData()->GetNumberOfCells())
       {
           thresh1=fib->GetFiberPolyData()->GetNumberOfCells();
       }
       if (thresh2>fib->GetFiberPolyData()->GetNumberOfCells())
       {
           thresh2=fib->GetFiberPolyData()->GetNumberOfCells();
       }
 
       if (thresh1!=fib->GetFiberPolyData()->GetNumberOfCells())
       {
       for ( int i=thresh1; i<thresh2; i++)
       {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
         auto numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (unsigned 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++;
 
       }
 
 
 
       vNewPolyData->SetLines(vNewLines);
       vNewPolyData->SetPoints(vNewPoints);
 
       m_newfibersFibersData = vtkSmartPointer<vtkPolyData>::New();
       m_newfibersFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
       m_newfibersFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
       m_newfibersFibersData->SetPoints(vNewPoints);
       m_newfibersFibersData->SetLines(vNewLines);
 
       m_newfibersBundle = mitk::FiberBundle::New(vNewPolyData);
       m_newfibersBundle->SetFiberColors(255, 255, 255);
       m_newfibersBundle->SetFiberWeights(weights);
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(m_newfibersBundle);
       node->SetName("ToLabel");
       m_newfibersBundleNode = node;
 
 //      MITK_INFO << "Number of Streamlines in first function";
 //      MITK_INFO << m_newfibersBundleNode->GetData()->GetFiberPolyData()->GetNumberOfCells();
       this->GetDataStorage()->Add(m_newfibersBundleNode);
       m_RandomExtractionCounter++;
       }
 
       m_Controls->m_ErazorButton->setChecked(true);
 
 
     UpdateGui();
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromBundle( bool checked )
 {
     if (checked)
     {
 
         if (m_StreamlineInteractor.IsNull())
         {
             this->CreateStreamlineInteractor();
 
             mitk::FiberBundle::Pointer m_negativeBundle = mitk::FiberBundle::New();
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetName("-Bundle");
             node->SetData(m_negativeBundle);
             m_negativeBundleNode = node;
             this->GetDataStorage()->Add(m_negativeBundleNode);
 
             m_StreamlineInteractor->EnableInteraction(true);
+            m_StreamlineInteractor->LabelfromPrediction(false);
             m_StreamlineInteractor->SetNegativeNode(m_negativeBundleNode);
             m_StreamlineInteractor->SetPositiveNode(m_positivBundlesNode);
             m_StreamlineInteractor->SetToLabelNode(m_newfibersBundleNode);
         }
         else
         {
             m_StreamlineInteractor->EnableInteraction(true);
+            m_StreamlineInteractor->LabelfromPrediction(false);
             m_StreamlineInteractor->SetPositiveNode(m_positivBundlesNode);
             m_StreamlineInteractor->SetToLabelNode(m_newfibersBundleNode);
         }
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
 
 
 
 
 
 
 
 
    UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateStreamlineInteractor()
 {
 
     m_StreamlineInteractor = mitk::StreamlineInteractor::New();
 
     m_StreamlineInteractor->LoadStateMachine("Streamline3DStates.xml", us::ModuleRegistry::GetModule("MitkFiberDissection"));
     m_StreamlineInteractor->SetEventConfig("Streamline3DConfig.xml", us::ModuleRegistry::GetModule("MitkFiberDissection"));
 
 //  m_StreamlineInteractor->SetRotationEnabled(rotationEnabled);
 }
 
 void QmitkInteractiveFiberDissectionView::StartAlgorithm()
 {
 
+    m_negativeBundle = dynamic_cast<mitk::FiberBundle*>(m_negativeBundleNode->GetData());
+    if (m_activeCycleCounter==0)
+    {
+
+        int neg_cells;
+        int pos_cells;
+        neg_cells = m_negativeBundle->GetFiberPolyData()->GetNumberOfCells();
+        pos_cells = m_positiveBundle->GetFiberPolyData()->GetNumberOfCells();
+        m_initRandom = neg_cells - pos_cells;
+        MITK_INFO << m_initRandom;
+    }
+
     this->GetDataStorage()->Remove(m_UncertaintyLabelNode);
     this->GetDataStorage()->Remove(m_DistanceLabelNode);
 //    vtkSmartPointer< vtkFloatArray > weights = m_positiveBundle->GetFiberWeights();
 //    MITK_INFO << weights->GetNumberOfValues();
 //    MITK_INFO << m_positiveBundle->GetNumFibers();
 //    for (unsigned int k=0; k<m_positiveBundle->GetNumFibers(); k++)
 //    {
 //        m_positiveBundle->SetFiberWeight(k, 1.0);
 
 //    }
 //    vtkSmartPointer< vtkFloatArray > newweights = m_positiveBundle->GetFiberWeights();
 //    MITK_INFO << newweights->GetNumberOfValues();
 
     m_Controls->m_unclabeling->setChecked(false);
     m_Controls->m_distlabeling->setChecked(false);
     m_Controls->m_predlabeling->setChecked(false);
 
     clusterer.reset();
     MITK_INFO << "Extract Features";
-    m_negativeBundle = dynamic_cast<mitk::FiberBundle*>(m_negativeBundleNode->GetData());
+
     clusterer = std::make_shared<mitk::StreamlineFeatureExtractor>();
+    clusterer->SetInitRandom(m_initRandom);
     clusterer->SetActiveCycle(m_activeCycleCounter);
     clusterer->SetTractogramPlus(m_positiveBundle);
     clusterer->SetTractogramMinus(m_negativeBundle);
     clusterer->SetTractogramPrototypes(dynamic_cast<mitk::FiberBundle*>(m_Controls->m_PrototypeBox->GetSelectedNode()->GetData()), m_Controls->m_useStandardP->isChecked());
     clusterer->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData()), m_SelectedFB.at(0)->GetName());
 //    clusterer->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_trainbundle->GetData()), m_trainbundle->GetName());
 
 
 
     clusterer->Update();
 
     m_index = clusterer->m_index;
     MITK_INFO << "Number of Cycles";
     MITK_INFO << m_activeCycleCounter;
     m_activeCycleCounter += 1;
 
 //    m_Prediction = clusterer->CreatePrediction(m_index.at(0));
 //    mitk::DataNode::Pointer node = mitk::DataNode::New();
 //    node->SetData(m_Prediction);
 //    node->SetName("Prediction");
 //    m_PredictionNode = node;
 //    this->GetDataStorage()->Add(m_PredictionNode);
 
 
 
 
 //    m_UncertaintyLabel = clusterer->m_UncertaintyLabel;
 //    mitk::DataNode::Pointer node2 = mitk::DataNode::New();
 //    node2->SetData(m_UncertaintyLabel);
 //    node2->SetName("UncertaintyLabels");
 //    m_UncertaintyLabelNode = node2;
 
 //      MITK_INFO << "Number of Streamlines in first function";
 //      MITK_INFO << m_newfibersBundleNode->GetData()->GetFiberPolyData()->GetNumberOfCells();
 //    this->GetDataStorage()->Add(m_UncertaintyLabelNode);
 //    this->GetDataStorage()->Add(m_PredictionNode);
 
 //    clusterer->GetData();
 //    MITK_INFO << data.at(0);
 //    MITK_INFO << data.at(1);
 //    cv::Ptr<cv::ml::TrainData> m_traindata = clusterer->GetData();
 //    MITK_INFO << clusterer->m_labels;
 //    MITK_INFO << data.at(1);
 //    MITK_INFO << "Start Classification";
 //    clusterer->CreateClassifier();
 //     cv::Mat curdata = clusterer->StartAlgorithm();
 //     MITK_INFO << curdata;
 
 
 
     MITK_INFO << "Algorithm run succesfully";
 
     m_Controls->m_CreatePrediction->setEnabled(true);
     UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::CreatePredictionNode()
 {
     MITK_INFO << "Create Prediction";
 
     m_Prediction = clusterer->CreatePrediction(m_index.at(0));
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_Prediction);
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("Prediction"+s);
     m_PredictionNode = node;
     this->GetDataStorage()->Add(m_PredictionNode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateUncertaintySampleNode()
 {
      MITK_INFO << "Create Fibers to label based on Uncertainty";
 
      std::vector<unsigned int> myvec = m_index.at(1);
      myvec.resize(m_Controls->m_Numtolabel->value());
      MITK_INFO << m_index.at(1).size();
      MITK_INFO << myvec.size();
 
 
     m_UncertaintyLabel = clusterer->CreatePrediction(myvec);
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_UncertaintyLabel);
 
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("UncertaintyLabel"+s);
     m_UncertaintyLabelNode = node;
     this->GetDataStorage()->Add(m_UncertaintyLabelNode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateDistanceSampleNode()
 {
      MITK_INFO << "Create Fibers to label based on Distance in Features-Space";
      std::vector<unsigned int> myvec = m_index.at(2);
      myvec.resize(m_Controls->m_Numtolabel2->value());
      MITK_INFO << m_index.at(2).size();
      MITK_INFO << myvec.size();
 
 
     m_DistanceLabel = clusterer->CreatePrediction(myvec);
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_DistanceLabel);
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("DistanceLabel"+s);
     m_DistanceLabelNode = node;
     this->GetDataStorage()->Add(m_DistanceLabelNode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromUncertainty( bool checked )
 {
     if (checked)
     {
 
         m_UncertaintyLabel->SetFiberColors(255, 255, 255);
         m_StreamlineInteractor->EnableInteraction(true);
+        m_StreamlineInteractor->LabelfromPrediction(false);
         m_StreamlineInteractor->SetToLabelNode(m_UncertaintyLabelNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromDistance( bool checked )
 {
     if (checked)
     {
 
         m_DistanceLabel->SetFiberColors(255, 255, 255);
         m_StreamlineInteractor->EnableInteraction(true);
+        m_StreamlineInteractor->LabelfromPrediction(false);
         m_StreamlineInteractor->SetToLabelNode(m_DistanceLabelNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkInteractiveFiberDissectionView::RemovefromPrediction( bool checked )
 {
     if (checked)
     {
 
 //        m_Prediction->SetFiberColors(255, 255, 255);
         m_StreamlineInteractor->EnableInteraction(true);
+        m_StreamlineInteractor->LabelfromPrediction(true);
         m_StreamlineInteractor->SetToLabelNode(m_PredictionNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
 
 }
+
+void QmitkInteractiveFiberDissectionView::RemovefromSelection( bool checked )
+{
+    if (checked)
+    {
+
+    //        m_Prediction->SetFiberColors(255, 255, 255);
+        m_StreamlineInteractor->EnableInteraction(true);
+        m_StreamlineInteractor->LabelfromPrediction(true);
+        m_StreamlineInteractor->SetToLabelNode(m_SelectedFB.at(0));
+    }
+    else
+    {
+      m_StreamlineInteractor->EnableInteraction(false);
+    //      m_StreamlineInteractor = nullptr;
+    }
+}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.h
index 1712ea2..7573d57 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.h
@@ -1,161 +1,163 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 QmitkInteractiveFiberDissectionView_h
 #define QmitkInteractiveFiberDissectionView_h
 #include "ui_QmitkInteractiveFiberDissectionViewControls.h"
 
 #include <QInputDialog> //Pointset
 #include <QmitkPointListWidget.h>//Pointset
 
 #include <QmitkAbstractView.h>//Pointset
 #include <QmitkSingleNodeSelectionWidget.h>//Pointset
 
 
 #include <mitkFiberBundle.h>
 #include <mitkDataInteractor.h>
 #include <mitkIRenderWindowPartListener.h> //Pointset
 #include <mitkStreamlineInteractor.h>
 #include <mitkStreamlineFeatureExtractor.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 #include <vtkCellPicker.h>
 
 /*!
 \brief View to process fiber bundles. Supplies methods to extract fibers from the bundle, fiber resampling, mirroring, join and subtract bundles and much more.
 */
 class QmitkInteractiveFiberDissectionView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   typedef itk::Image< unsigned char, 3 >    ItkUCharImageType;
   typedef itk::Image< float, 3 >            ItkFloatImageType;
 
   static const std::string VIEW_ID;
 
   QmitkInteractiveFiberDissectionView();
   virtual ~QmitkInteractiveFiberDissectionView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Sets the focus to an internal widget.
   ///
   virtual void SetFocus() override;
 
 protected slots:
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override; //Pointset
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override; //Pointset
   void OnAddPointSetClicked();//Pointset
   void CreateStreamline();
   void RemovefromBundle( bool checked );
   void ExtractRandomFibersFromTractogram();
   void StartAlgorithm();
   void CreatePredictionNode();
   void CreateUncertaintySampleNode();
   void CreateDistanceSampleNode();
   void RemovefromUncertainty( bool checked );
   void RemovefromDistance( bool checked );
   void RemovefromPrediction( bool checked );
+  void RemovefromSelection( bool checked );
   void ResampleTractogram();
   void RandomPrototypes();
   void SFFPrototypes();
 
 
 
 
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
 
 
 
 
 protected:
   void OnCurrentSelectionChanged(QmitkSingleNodeSelectionWidget::NodeList nodes);//Pointset
 
 
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   void OnEndInteraction();
   void CreateStreamlineInteractor();
 
   Ui::QmitkInteractiveFiberDissectionViewControls* m_Controls;
 
 
 
   int m_IterationCounter;                                      ///< used for data node naming
   int m_RandomExtractionCounter;                               ///< used for random extracton of different Streamlines
   int m_activeCycleCounter;
+  int m_initRandom;
 //  int m_thresh2;
 
 
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
 //  mitk::DataNode::Pointer              m_trainbundle;
   mitk::Image::Pointer                  m_SelectedImage;
   mitk::DataNode::Pointer               m_SelectedPS;
   mitk::DataNode::Pointer               m_SelectedImageNode;
   mitk::FiberBundle::Pointer            m_positiveBundle;
   mitk::FiberBundle::Pointer            m_newfibersBundle;
   mitk::FiberBundle::Pointer            m_negativeBundle;
   mitk::FiberBundle::Pointer            m_Prediction;
   mitk::FiberBundle::Pointer            m_UncertaintyLabel;
   mitk::FiberBundle::Pointer            m_DistanceLabel;
 
 
   mitk::DataNode::Pointer               m_positivBundlesNode;
   mitk::DataNode::Pointer               m_newfibersBundleNode;
   mitk::DataNode::Pointer               m_negativeBundleNode;
   mitk::DataNode::Pointer               m_PredictionNode;
   mitk::DataNode::Pointer               m_UncertaintyLabelNode;
   mitk::DataNode::Pointer               m_DistanceLabelNode;
 
   vtkSmartPointer<vtkPolyData>          m_positiveFibersData;
   vtkSmartPointer<vtkPolyData>          m_newfibersFibersData;
 
   vtkSmartPointer<vtkCellPicker>        m_picker1;
   mitk::StreamlineInteractor::Pointer   m_StreamlineInteractor;
 
   std::shared_ptr< mitk::StreamlineFeatureExtractor > clusterer;
 
   std::vector<std::vector<unsigned int>> m_index;
 
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui
index 6acb62f..b4b89d4 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui
@@ -1,804 +1,811 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkInteractiveFiberDissectionViewControls</class>
  <widget class="QWidget" name="QmitkInteractiveFiberDissectionViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>417</width>
     <height>711</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <property name="styleSheet">
    <string>QCommandLinkButton:disabled {
   border: none;
 }
 
 QGroupBox {
   background-color: transparent;
 }</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_3">
    <property name="leftMargin">
     <number>9</number>
    </property>
    <property name="topMargin">
     <number>9</number>
    </property>
    <property name="rightMargin">
     <number>9</number>
    </property>
    <property name="bottomMargin">
     <number>9</number>
    </property>
    <item row="2" column="0" rowspan="2">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="0" column="0">
     <widget class="QGroupBox" name="m_InputData">
      <property name="title">
       <string>Please Select Input Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
        <widget class="QLabel" name="label_2">
         <property name="toolTip">
          <string>Input DTI</string>
         </property>
         <property name="text">
          <string>Fiber Bundle:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="m_FibLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QToolBox" name="toolBoxx">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="font">
       <font>
        <bold>true</bold>
       </font>
      </property>
      <property name="toolTip">
       <string>Label Fibers</string>
      </property>
      <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="currentIndex">
-      <number>0</number>
+      <number>3</number>
      </property>
      <property name="tabSpacing">
       <number>6</number>
      </property>
      <widget class="QWidget" name="page">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>399</width>
         <height>455</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Generate Prototypes</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_5">
        <item row="8" column="1">
         <widget class="QmitkDataStorageComboBox" name="m_PrototypeBox"/>
        </item>
        <item row="4" column="0">
         <widget class="QPushButton" name="pushButton">
          <property name="text">
           <string>Use Standard Prototypes</string>
          </property>
         </widget>
        </item>
        <item row="1" column="1">
         <widget class="QSpinBox" name="m_NumPrototypes">
          <property name="minimum">
           <number>10</number>
          </property>
          <property name="maximum">
           <number>200</number>
          </property>
          <property name="value">
           <number>100</number>
          </property>
         </widget>
        </item>
        <item row="8" column="0">
         <widget class="QLabel" name="inputImageOneLabel_2">
          <property name="text">
           <string>Choose own Prototypes</string>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QPushButton" name="m_RandomPrototypesButton">
          <property name="text">
           <string>Random Extraction</string>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QLabel" name="inputImageOneLabel_3">
          <property name="text">
           <string>Number of Prototypes</string>
          </property>
         </widget>
        </item>
        <item row="0" column="1">
         <widget class="QmitkDataStorageComboBox" name="m_BundleBox"/>
        </item>
        <item row="6" column="0">
         <widget class="QRadioButton" name="m_useStandardP">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="text">
           <string>Use Standard Prototypes</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QPushButton" name="m_SFFPrototypesButton">
          <property name="text">
           <string>SFF Extraction</string>
          </property>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QLabel" name="inputImageOneLabel">
          <property name="text">
           <string>Extract from</string>
          </property>
         </widget>
        </item>
        <item row="9" column="0">
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="5" column="0">
         <widget class="QPushButton" name="m_ResampleButton">
          <property name="text">
           <string>Resample Bundle</string>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_3">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>399</width>
         <height>455</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Fiber Creation</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_7">
        <item row="0" column="0">
         <widget class="QFrame" name="frame">
          <property name="frameShape">
           <enum>QFrame::StyledPanel</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_11">
           <item row="0" column="0">
            <widget class="QLabel" name="m_selectedPointSetLabel">
             <property name="text">
              <string>Selected Streamline Pointset</string>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <spacer name="horizontalSpacer_14">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="4" column="0" colspan="2">
            <widget class="QGroupBox" name="groupBox">
             <property name="title">
              <string>Streamline Points</string>
             </property>
             <layout class="QGridLayout" name="gridLayout_10">
              <item row="0" column="0">
               <widget class="QmitkPointListWidget" name="m_poinSetListWidget" native="true"/>
              </item>
              <item row="1" column="0">
               <spacer name="verticalSpacer_7">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>40</height>
                 </size>
                </property>
               </spacer>
              </item>
             </layout>
            </widget>
           </item>
           <item row="1" column="1">
            <spacer name="horizontalSpacer_13">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="0" column="1">
            <spacer name="horizontalSpacer_12">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="0">
            <widget class="QPushButton" name="m_addPointSetPushButton">
             <property name="text">
              <string>Add new Streamline Pointset</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QmitkSingleNodeSelectionWidget" name="m_selectedPointSetWidget" native="true">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimumSize">
              <size>
               <width>0</width>
               <height>40</height>
              </size>
             </property>
            </widget>
           </item>
           <item row="6" column="0">
            <spacer name="verticalSpacer_3">
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>40</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="7" column="0">
            <widget class="QPushButton" name="m_StreamlineCreation">
             <property name="text">
              <string>Create Streamline</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_2">
       <property name="enabled">
        <bool>true</bool>
       </property>
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>438</width>
         <height>441</height>
        </rect>
       </property>
       <property name="accessibleName">
        <string/>
       </property>
       <attribute name="label">
        <string>Fiber Labelling</string>
       </attribute>
       <attribute name="toolTip">
        <string>Dissect/Eraze Fibers by Erasion and Highlighting</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_13">
        <item row="4" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_LabelFrame">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="cursor">
           <cursorShape>ArrowCursor</cursorShape>
          </property>
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_4">
           <item row="0" column="0">
            <widget class="QLabel" name="label">
             <property name="text">
              <string>Label individual Streamlines</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_3">
          <property name="text">
           <string>Streamlines to be labeled</string>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_ExtractionToolsFrame">
          <property name="frameShape">
           <enum>QFrame::StyledPanel</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_2">
           <item row="6" column="3" colspan="6">
            <spacer name="horizontalSpacer_3">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="5" column="4" colspan="5">
            <spacer name="horizontalSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="7" colspan="3">
            <spacer name="horizontalSpacer_2">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="6">
            <widget class="QPushButton" name="m_AddRandomFibers">
             <property name="text">
              <string>Add</string>
             </property>
            </widget>
           </item>
           <item row="7" column="2">
            <widget class="QLabel" name="label_8">
             <property name="text">
              <string>Accept: Rightclick + alt</string>
             </property>
            </widget>
           </item>
           <item row="2" column="4">
            <widget class="QSpinBox" name="m_NumRandomFibers">
             <property name="minimum">
              <number>1</number>
             </property>
             <property name="maximum">
              <number>2000</number>
             </property>
             <property name="value">
              <number>10</number>
             </property>
            </widget>
           </item>
           <item row="2" column="2" colspan="2">
            <widget class="QLabel" name="label_7">
             <property name="text">
              <string>Random Streamlines</string>
             </property>
            </widget>
           </item>
           <item row="9" column="2">
            <spacer name="verticalSpacer_2">
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>40</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="5" column="3">
            <widget class="QPushButton" name="m_ErazorButton">
             <property name="maximumSize">
              <size>
               <width>30</width>
               <height>30</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="icon">
              <iconset>
               <normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberprocessing/resources/eraze.png</normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberprocessing/resources/eraze.png</iconset>
             </property>
             <property name="iconSize">
              <size>
               <width>32</width>
               <height>32</height>
              </size>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="5" column="2">
            <widget class="QLabel" name="label_4">
             <property name="text">
              <string>Label Streamlines</string>
             </property>
            </widget>
           </item>
           <item row="7" column="3" colspan="5">
            <spacer name="horizontalSpacer_8">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="6" column="2">
            <widget class="QLabel" name="label_6">
             <property name="text">
              <string>Reject: Rightclick + shift</string>
             </property>
            </widget>
           </item>
           <item row="8" column="2">
            <widget class="QLabel" name="label_10">
             <property name="text">
              <string>Unlabel: Leftclick + shift/alt</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_4">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>399</width>
         <height>455</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Active Learning</string>
       </attribute>
       <widget class="QFrame" name="frame_2">
        <property name="geometry">
         <rect>
          <x>9</x>
          <y>9</y>
          <width>341</width>
          <height>391</height>
         </rect>
        </property>
        <property name="frameShape">
         <enum>QFrame::StyledPanel</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Raised</enum>
        </property>
        <layout class="QGridLayout" name="gridLayout_6">
         <item row="3" column="1">
          <widget class="QSpinBox" name="m_Numtolabel">
           <property name="minimum">
            <number>1</number>
           </property>
           <property name="maximum">
            <number>500</number>
           </property>
           <property name="singleStep">
            <number>0</number>
           </property>
           <property name="value">
            <number>10</number>
           </property>
          </widget>
         </item>
         <item row="2" column="3">
          <spacer name="horizontalSpacer_7">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="5" column="0">
          <widget class="QPushButton" name="m_unclabeling">
           <property name="text">
            <string>Uncertainty_Label</string>
           </property>
           <property name="icon">
            <iconset theme="eraze.png">
             <normaloff>.</normaloff>.</iconset>
           </property>
          </widget>
         </item>
         <item row="1" column="3">
          <spacer name="horizontalSpacer_5">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="3" column="2">
          <widget class="QPushButton" name="m_AddUncertainFibers">
           <property name="text">
            <string>Add </string>
           </property>
          </widget>
         </item>
         <item row="5" column="1">
          <widget class="QPushButton" name="m_predlabeling">
           <property name="text">
            <string>Pred_Label</string>
           </property>
          </widget>
         </item>
         <item row="0" column="3">
          <spacer name="horizontalSpacer_4">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>84</width>
             <height>22</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="4" column="0">
          <widget class="QLabel" name="label_9">
           <property name="text">
            <string>Dist: to label</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0" colspan="3">
          <widget class="QPushButton" name="m_CreatePrediction">
           <property name="text">
            <string>Create Prediction</string>
           </property>
          </widget>
         </item>
         <item row="7" column="2">
          <spacer name="verticalSpacer_6">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>40</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="2" column="0" colspan="3">
          <widget class="QPushButton" name="m_CreateUncertantyMap">
           <property name="text">
            <string>Create Uncertanty Map</string>
           </property>
          </widget>
         </item>
         <item row="4" column="2">
          <widget class="QPushButton" name="m_AddDistanceFibers">
           <property name="text">
            <string>Add</string>
           </property>
          </widget>
         </item>
         <item row="0" column="0" colspan="3">
          <widget class="QPushButton" name="m_TrainClassifier">
           <property name="text">
            <string>Train Classifier</string>
           </property>
          </widget>
         </item>
         <item row="3" column="0">
          <widget class="QLabel" name="label_5">
           <property name="text">
            <string>Unc: to label</string>
           </property>
          </widget>
         </item>
         <item row="4" column="1">
          <widget class="QSpinBox" name="m_Numtolabel2">
           <property name="minimum">
            <number>1</number>
           </property>
           <property name="maximum">
            <number>500</number>
           </property>
           <property name="value">
            <number>10</number>
           </property>
          </widget>
         </item>
         <item row="3" column="3">
          <spacer name="horizontalSpacer_6">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="5" column="2">
          <widget class="QPushButton" name="m_distlabeling">
           <property name="text">
            <string>Unc_dis_Label</string>
           </property>
          </widget>
         </item>
+        <item row="6" column="0">
+         <widget class="QPushButton" name="m_sellabeling">
+          <property name="text">
+           <string>Selection_Label</string>
+          </property>
+         </widget>
+        </item>
        </layout>
       </widget>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
+  <customwidget>
+   <class>QmitkDataStorageComboBox</class>
+   <extends>QComboBox</extends>
+   <header location="global">QmitkDataStorageComboBox.h</header>
+  </customwidget>
   <customwidget>
    <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSingleNodeSelectionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkPointListWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkPointListWidget.h</header>
   </customwidget>
-  <customwidget>
-   <class>QmitkDataStorageComboBox</class>
-   <extends>QComboBox</extends>
-   <header location="global">QmitkDataStorageComboBox.h</header>
-  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>