diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
index 8cd76ba..4dd21fc 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
@@ -1,935 +1,946 @@
 /*===================================================================
 
 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::SetTractogramPrediction(const mitk::FiberBundle::Pointer &TractogramPrediction)
 {
   m_TractogramPrediction= TractogramPrediction;
 }
 
 void StreamlineFeatureExtractor::SetTractogramGroundtruth(const mitk::FiberBundle::Pointer &TractogramGroundtruth)
 {
   m_TractogramGroundtruth= TractogramGroundtruth;
 }
 
 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_40.trk");
   }
   else {
       MITK_INFO << "Use individual Prototypes...";
       m_inputPrototypes = TractogramPrototypes;
   }
 
 
 }
 
 void StreamlineFeatureExtractor::SetActiveCycle(int &activeCycle)
 {
   m_activeCycle= activeCycle;
 }
 
 
 void StreamlineFeatureExtractor::SetTractogramTest(const mitk::FiberBundle::Pointer &TractogramTest, std::string TractogramTestName)
 {
     MITK_INFO << TractogramTestName;
     m_TractogramTest= TractogramTest;
 }
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   MITK_INFO << "Infunction";
-//  mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
-//  temp_fib->ResampleToNumPoints(m_NumPoints);
+  mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
+  vtkPolyData* polyData = temp_fib->GetFiberPolyData();
+
+  for (vtkIdType i = 0; i < polyData->GetNumberOfCells(); i++)
+  {
+    vtkCell* cell = polyData->GetCell(i);
+    if (cell->GetNumberOfPoints() != polyData->GetCell(0)->GetNumberOfPoints())
+    {
+      throw std::runtime_error("Not all cells have an equal number of points!");
+//        temp_fib->ResampleToNumPoints(m_NumPoints);
+    }
+  }
+
   MITK_INFO << "Resampling Done";
 
-  std::vector< vnl_matrix<float> > out_fib(tractogram->GetFiberPolyData()->GetNumberOfCells());
+  std::vector< vnl_matrix<float> > out_fib(temp_fib->GetFiberPolyData()->GetNumberOfCells());
 //#pragma omp parallel for
-  for (int i=0; i<tractogram->GetFiberPolyData()->GetNumberOfCells(); i++)
+  for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
   {
-    vtkCell* cell = tractogram->GetFiberPolyData()->GetCell(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.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)
 {
 // Initialize a vector to store distance matrices for each tractogram item
 std::vector<vnl_matrix<float>> dist_vec(tractogram.size());
 
 // Loop over each tractogram item
 #pragma omp parallel for
 for (std::size_t i = 0; i < tractogram.size(); ++i)
 {
     // Initialize a distance matrix for the current tractogram item
     vnl_matrix<float> distances(1, 2 * prototypes.size(), 0.0);
 
     // Loop over each prototype
     for (std::size_t j = 0; j < prototypes.size(); ++j)
     {
         // Initialize matrices to store distances between the current tractogram item and the current prototype
         vnl_matrix<float> single_distances(1, tractogram[0].cols(), 0.0);
         vnl_matrix<float> single_distances_flip(1, tractogram[0].cols(), 0.0);
         vnl_matrix<float> single_end_distances(1, 2, 0.0);
         vnl_matrix<float> single_end_distances_flip(1, 2, 0.0);
 
         // Loop over each point in the current tractogram item
         for (std::size_t ik = 0; ik < tractogram[0].cols(); ++ik)
         {
             // Calculate the Euclidean distance between the current point in the current tractogram item and the current point in the current prototype
             const double cur_dist = std::sqrt(std::pow(tractogram[i](0, ik) - prototypes[j](0, ik), 2.0)
                                               + std::pow(tractogram[i](1, ik) - prototypes[j](1, ik), 2.0)
                                               + std::pow(tractogram[i](2, ik) - prototypes[j](2, ik), 2.0));
             single_distances(0, ik) = cur_dist;
 
             // Calculate the Euclidean distance between the current point in the current tractogram item and the mirrored current point in the current prototype
             const double cur_dist_flip = std::sqrt(std::pow(tractogram[i](0, ik) - prototypes[j](0, prototypes[0].cols() - (ik + 1)), 2.0)
                                                    + std::pow(tractogram[i](1, ik) - prototypes[j](1, prototypes[0].cols() - (ik + 1)), 2.0)
                                                    + std::pow(tractogram[i](2, ik) - prototypes[j](2, prototypes[0].cols() - (ik + 1)), 2.0));
             single_distances_flip(0, ik) = cur_dist_flip;
 
             // Store the distances between the first and last points of the current tractogram item and the current prototype
             if (ik == 0)
             {
                 single_end_distances(0, 0) = cur_dist;
                 single_end_distances_flip(0, 0) = cur_dist_flip;
             }
             else if (ik == tractogram[0].cols() - 1)
             {
                 single_end_distances(0, 1) = cur_dist;
                 single_end_distances_flip(0, 1) = cur_dist_flip;
             }
         }
 
         // Calculate the mean distance between the current tractogram item and the current prototype
         const double mean_single_distances = single_distances.mean();
         const double mean_single_distances_flip = single_distances_flip.mean();
         distances(0, j) = mean_single_distances_flip > mean_single_distances ? mean_single_distances : mean_single_distances_flip;
 
         // // Calculate the mean END distance between the current tractogram item and the current prototype
         const double mean_single_end_distances = single_end_distances.mean();
         const double mean_single_end_distances_flip = single_end_distances_flip.mean();
         const std::size_t end_distances_index = prototypes.size() + j;
         distances(0, end_distances_index) = mean_single_end_distances_flip > mean_single_end_distances ? mean_single_distances : mean_single_end_distances_flip;
     }
 
         dist_vec[i] = distances;
     }
 
     MITK_INFO << "The size of the distances is " <<dist_vec[0].cols();
     MITK_INFO << "Done calculating Dmdf";
 
     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 (negative_local_prototypes.size() >= 50)
     {
         neg_locals = 50;
     }
     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<positive_local_prototypes.size(); k++)
     {
         merged_prototypes.push_back(positive_local_prototypes.at(k));
     }
 
     for (unsigned int k=0; k<negative_local_prototypes.size(); 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, int start)
 {
     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;
         if (i>=start)
         {
         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;
 
     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_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_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]));
     }
 
     /*Create Dataset and initialize Classifier*/
     cv::Ptr<cv::ml::TrainData> m_traindata = cv::ml::TrainData::create(samples_shuffled, cv::ml::ROW_SAMPLE, labels_shuffled);
 
 
 
 
     statistic_model= cv::ml::RTrees::create();
     auto criteria = cv::TermCriteria();
     criteria.type = cv::TermCriteria::MAX_ITER;
 //    criteria.epsilon = 1e-8;
     criteria.maxCount = 300;
 
     statistic_model->setMaxDepth(10); //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());
     std::vector<int> pred(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));
         pred.at(i)=val;
 
         #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";
 
     MITK_INFO << "--------------";
     MITK_INFO << "Prediction vector size:";
     MITK_INFO << indexPrediction.size();
     MITK_INFO << "Entropy vector size:";
     entropy_vector = e;
     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.95; });
   if (lengths>1500)
   {
       lengths=1500;
   }
 
 
 
     int lengthsCertain = std::count_if(e.begin(), e.end(),[&](auto const& val){ return val < 0.1; });
 
     std::vector<unsigned int> indexUnc = Sort(e, lengths, 0);
 
     std::vector<unsigned int> indexCertain = Sort(e, e.size() , e.size()-lengthsCertain );
 
 //    std::vector<unsigned int> indexCertainBetween = Sort(e, e.size()-lengthsCertain , lengths);
 
     MITK_INFO << "Index Certainty Vector size";
     MITK_INFO << indexCertain.size();
 
     std::vector<unsigned int> indexCertainNeg;
     std::vector<unsigned int> indexCertainPos;
 
     for (unsigned int i=0; i<indexCertain.size(); i++)
     {
         if(pred.at(indexCertain.at(i))==0 )
         {
             indexCertainNeg.push_back(indexCertain.at(i));
         }
         else {
             indexCertainPos.push_back(indexCertain.at(i));
         }
 
     }
 
 
     //    for (unsigned int i=indexCertain.size(); i>=0; --i)
 //    std::vector<unsigned int> indexCertainBetweenNeg;
 //    std::vector<unsigned int> indexCertainBetweenPos;
 
 //    for (unsigned int i=0; i<indexCertainBetween.size(); i++)
 //    {
 //        if(pred.at(indexCertainBetween.at(i))==0 )
 //        {
 //            indexCertainBetweenNeg.push_back(indexCertainBetween.at(i));
 //        }
 //        else {
 //            indexCertainBetweenPos.push_back(indexCertainBetween.at(i));
 //        }
 
 //    }
 
     MITK_INFO << "Index Uncertainty Vector size";
     MITK_INFO << indexUnc.size();
     MITK_INFO << "Index Certainty Vector size";
     MITK_INFO << indexCertainPos.size();
     MITK_INFO << indexCertainNeg.size();
     MITK_INFO << indexCertainNeg.size() +indexCertainPos.size();
     MITK_INFO << "Index Certainty between Vector size";
 //    MITK_INFO << indexCertainBetweenPos.size();
 //    MITK_INFO << indexCertainBetweenNeg.size();
 //    MITK_INFO << indexCertainBetweenNeg.size() +indexCertainBetweenPos.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);
 
 //    }
 
 
 
 //    /*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();
 
 //    }
 
 //    MITK_INFO << "Dist_stop";
 
 
     /*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);
     /*Save index of certain measures*/
     index_vec.push_back(indexCertainNeg);
     /*Save index of certain measures*/
 //    index_vec.push_back(indexCertainPos);
     /*Save index of certain measures*/
 //    index_vec.push_back(indexCertainBetweenNeg);
     /*Save index of certain measures*/
 //    index_vec.push_back(indexCertainBetweenPos);
 
     return index_vec;
 
 }
 
 std::vector<std::vector<unsigned int>>  StreamlineFeatureExtractor::GetDistanceData(float &value)
 {
     /*Vector which saves Fibers to be labeled based on fft subset uncertainty*/
     std::vector<std::vector<unsigned int>> index_vec;
 
     /*Get index of most unertain data (lengths defines how many data is saved)*/
 //    int lengths=500;
     MITK_INFO << entropy_vector.size();
   int lengths = std::count_if(entropy_vector.begin(), entropy_vector.end(),[&](auto const& val){ return val >= value; });
   if (lengths>1500)
   {
       lengths=1500;
   }
   MITK_INFO << lengths;
     /*Maybe shuffling of length so not the most uncertain values are chosen*/
     std::vector<unsigned int> indexUnc = Sort(entropy_vector, lengths, 0);
 
     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);
 
     }
 
     MITK_INFO << "Distance Matrix Calculated";
 
     /*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();
 
     }
 
     MITK_INFO << "Dist_stop";
 
     index_vec.push_back(indexUncDist);
 
     return index_vec;
 }
 
 mitk::FiberBundle::Pointer StreamlineFeatureExtractor::CreatePrediction(std::vector<unsigned int> &index, bool removefrompool)
 {
     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++;
 
     }
     if (removefrompool)
     {
         for (unsigned int i=0; i<indexSize; i++)
         {
             m_TractogramTest->GetFiberPolyData()->DeleteCell(index[i]);
         }
     }
 
 
 
 
     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;
 }
 
 std::vector<int> StreamlineFeatureExtractor::CreateLabels(std::vector<vnl_matrix<float> > Testdata,
                                                               std::vector<vnl_matrix<float> > Prediction)
 {
 //    vnl_vector<int> labels;
 //    vnl_vector.set_size(Testdata.size());
 //    vnl_vector.fill(0);
     std::vector<int>  labels(Testdata.size(), 0);
 
 
 #pragma omp parallel for
     for (unsigned int i=0; i<Prediction.size(); i++)
     {
         for (unsigned int k=0; k<Testdata.size(); k++)
         {
             if (Testdata.at(k)==Prediction.at(i))
             {
                 labels.at(k)=1;
             }
         }
     }
 
 
     return labels;
 
 
 
 
 }
 
 void StreamlineFeatureExtractor::GenerateData()
 {
     MITK_INFO << "Update";
 
     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;
 
 
     MITK_INFO << "Resample Input Prototypes";
     T_Prototypes = ResampleFibers(m_inputPrototypes);
     MITK_INFO << "Resample Input Tractogram Minus";
     T_TractogramMinus= ResampleFibers(m_TractogramMinus);
     MITK_INFO << "Resample Input Tractogram Plus";
     T_TractogramPlus= ResampleFibers(m_TractogramPlus);
 
     /* Merge T_Prototypes, T_TractogramMinus and T_TractogramPlus for extra Features*/
     MITK_INFO << "Merging Prototypes";
     T_mergedPrototypes = MergeTractogram(T_Prototypes, T_TractogramPlus, T_TractogramMinus);
 
 
 
 
     MITK_INFO << "Calculate Features";
     MITK_INFO << "Calculate Minus Features";
     m_DistancesMinus = CalculateDmdf(T_TractogramMinus, T_mergedPrototypes);
     MITK_INFO << "Calculate Plus Features";
     m_DistancesPlus = CalculateDmdf(T_TractogramPlus, T_mergedPrototypes);
 
     MITK_INFO << "Resample Test Data";
     T_TractogramTest= ResampleFibers(m_TractogramTest);
     MITK_INFO << "Calculate Features of Test Data";
     m_DistancesTest= CalculateDmdf(T_TractogramTest, T_mergedPrototypes);
 
 
 
 
     MITK_INFO << "Done with Datacreation";
     m_index =GetData();
 
 }
 
 vnl_vector<float> StreamlineFeatureExtractor::ValidationPipe()
 {
     std::vector<vnl_matrix<float> >             T_Prototypes;
     std::vector<vnl_matrix<float> >             T_TractogramPrediction;
     std::vector<vnl_matrix<float> >             T_TractogramGroundtruth;
     std::vector<vnl_matrix<float> >             T_TractogramTest;
     std::vector<vnl_matrix<float> >             DistancesPrediction;
     std::vector<vnl_matrix<float> >             DistancesGroundtruth;
     std::vector<vnl_matrix<float> >             DistancesTest;
     std::vector<int>                            LabelsPrediction;
     std::vector<int>                            LabelsGroundtruth;
 
     MITK_INFO << "Start Resampling";
     T_Prototypes = ResampleFibers(m_inputPrototypes);
     T_TractogramPrediction= ResampleFibers(m_TractogramPrediction);
     T_TractogramGroundtruth= ResampleFibers(m_TractogramGroundtruth);
     T_TractogramTest= ResampleFibers(m_TractogramTest);
 
 
 
     MITK_INFO << "Calculate Features";
     DistancesPrediction = CalculateDmdf(T_TractogramPrediction, T_Prototypes);
     DistancesGroundtruth = CalculateDmdf(T_TractogramGroundtruth, T_Prototypes);
     DistancesTest = CalculateDmdf(T_TractogramTest, T_Prototypes);
 
     LabelsGroundtruth = CreateLabels(DistancesTest, DistancesGroundtruth);
     LabelsPrediction = CreateLabels(DistancesTest, DistancesPrediction);
 
     float FP = 0.0;
     float FN = 0.0;
     float TP = 0.0;
     float TN = 0.0;
     std::vector<int> indexfp;
 //#pragma omp parallel for
     for (unsigned int i=0; i<LabelsGroundtruth.size(); i++)
     {
         if (LabelsGroundtruth.at(i)==1 && LabelsPrediction.at(i)==1)
         {
             TP +=1;
         }
         else if (LabelsGroundtruth.at(i)==1 && LabelsPrediction.at(i)==0)
         {
             FN +=1;
         }
         else if (LabelsGroundtruth.at(i)==0 && LabelsPrediction.at(i)==1)
         {
             FP +=1;
             indexfp.push_back(i);
         }
         else if (LabelsGroundtruth.at(i)==0 && LabelsPrediction.at(i)==0)
         {
             TN +=1;
         }
     }
 
     float Precision;
     float Recall;
     float F1_score;
 
     MITK_INFO << "TP";
     MITK_INFO << TP;
     MITK_INFO << "FP";
     MITK_INFO << FP;
     MITK_INFO << "TN";
     MITK_INFO << TN;
     MITK_INFO << "FN";
     MITK_INFO << FN;
     Precision = TP/(TP + FP);
     MITK_INFO << "Precision";
     MITK_INFO << Precision;
     Recall = TP/(TP + FN);
     MITK_INFO << "Recall";
     MITK_INFO << Recall;
     F1_score = (2*Precision*Recall)/(Precision+Recall);
     MITK_INFO << "F1_score";
     MITK_INFO << F1_score;
 
 
 
     vnl_vector<float> metrics(7);
 
     metrics.put(0, TP);
     metrics.put(1, FP);
     metrics.put(2, TN);
     metrics.put(3, FN);
     metrics.put(4, Precision);
     metrics.put(5, Recall);
     metrics.put(6, F1_score);
 
 
 
 
     return metrics;
 
 }
 
 
 }
 
 
 
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 217b618..eaef2e8 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,1935 +1,1931 @@
 /*===================================================================
 
 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 <mitkPlanarCircle.h>
 #include <mitkSurface.h>
 #include <vtkSphereSource.h>
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <mitkPlanarFigureInteractor.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>
 
 
 
 #include <mitkBaseRenderer.h>
 #include <mitkRenderingManager.h>
 #include <mitkVtkPropRenderer.h>
 #include <mitkInteractionConst.h>
 #include <mitkInteractionPositionEvent.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.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_createdStreamlineCounter(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 );
 
     m_Controls->m_PredictionBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isPrediction = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     m_Controls->m_PredictionBox->SetPredicate( isPrediction );
 
     m_Controls->m_GroundtruthBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isGroundtruth = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     m_Controls->m_GroundtruthBox->SetPredicate( isGroundtruth );
 
     m_Controls->m_TestBundleBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isTestBundle = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     m_Controls->m_TestBundleBox->SetPredicate( isTestBundle);
 
 
 
 
     connect(m_Controls->m_ErazorButton, SIGNAL(toggled(bool)), this, SLOT( RemovefromBundle(bool) ) );
     connect(m_Controls->m_BrushButton, SIGNAL(toggled(bool)), this, SLOT( RemovefromBundleBrush(bool) ) );
 
     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_certainData, SIGNAL( clicked() ), this, SLOT( CreateCertainNode( )));
 
     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_unclabelingBrush, SIGNAL(toggled(bool)), this, SLOT( RemovefromUncertaintyBrush(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_predlabelingBrush, SIGNAL(toggled(bool)), this, SLOT( RemovefromPredictionBrush(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_validate, SIGNAL( clicked() ), this, SLOT( StartValidation( ) ) );
 
     connect(m_Controls->m_automaticLabelling, SIGNAL( clicked() ), this, SLOT( AutomaticLabelling( ) ) );
 
     connect(m_Controls->m_RemoveCertainData, SIGNAL( clicked() ), this, SLOT( RemoveCertainData( ) ) );
 
     connect(m_Controls->m_resetClassifier, SIGNAL( clicked() ), this, SLOT( ResetClassifier( ) ) );
 
 
 
     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
   UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::UpdateGui()
 {
   m_Controls->m_FibLabel->setText("<font color='red'>nothing selected</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_BrushButton->setCheckable(true);
   m_Controls->m_BrushButton->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_unclabelingBrush->setCheckable(true);
   m_Controls->m_unclabelingBrush->setEnabled(false);
   m_Controls->m_predlabelingBrush->setCheckable(true);
   m_Controls->m_predlabelingBrush->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(true);
   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_PrototypeBox->setEditable(false);
 //  m_Controls->m_useStandardP->
 
   mitk::DataNode::Pointer curtestnode =  m_Controls->m_TestBundleBox->GetSelectedNode();
   bool testnodeSelected = curtestnode.IsNotNull();
   MITK_INFO << testnodeSelected;
   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_positiveBundleNode.empty();
   bool nfibSelected = m_newfibersBundleNode.IsNotNull();
 //  bool posSelected = !m_positiveBundleNode.IsNotNull();
 //  bool negSelected = !m_negativeBundleNode.IsNotNull();
     bool posSelected = this->GetDataStorage()->Exists(m_positiveBundleNode);
     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 ( testnodeSelected )
   {
     m_Controls->m_addPointSetPushButton->setEnabled(true);
     m_Controls->m_AddRandomFibers->setEnabled(true);
     m_Controls->m_sellabeling->setEnabled(true);
   }
 
   if (fibSelected)
   {
     m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
     // more than two bundles needed to join/subtract
     if (multipleFibsSelected )
     {
       m_Controls->m_FibLabel->setText("multiple bundles selected");
     }
 
 
 
   }
 
 
   // is image selected
   if ((sthSelected) || (testnodeSelected))
   {
     m_Controls->m_addPointSetPushButton->setEnabled(true);
   }
 
   if (psSelected)
   {
       m_Controls->m_StreamlineCreation->setEnabled(true);
   }
 
   if (nfibSelected && posSelected)
   {
       m_Controls->m_ErazorButton->setEnabled(true);
       m_Controls->m_BrushButton->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);
       m_Controls->m_unclabelingBrush->setEnabled(true);
   }
 
   if (predictionSelected)
   {
       m_Controls->m_predlabeling->setEnabled(true);
       m_Controls->m_predlabelingBrush->setEnabled(true);
   }
 
 //  if (distanceSelected)
 //  {
       m_Controls->m_distlabeling->setEnabled(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 tempfib = tractogram->GetDeepCopy();
 
     std::vector<int> myvec;
     for (unsigned int k=0; k<tempfib->GetNumFibers(); k++)
     {
       myvec.push_back(k);
     }
 //      auto rng = std::default_random_engine {};
     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 (unsigned int i=0; i<tempfib->GetNumFibers(); i++)
     {
       vtkCell* cell = tempfib->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, tempfib->GetFiberWeight(myvec.at(i)));
       vNewLines->InsertNextCell(container);
       counter++;
 
     }
 
     vNewPolyData->SetLines(vNewLines);
     vNewPolyData->SetPoints(vNewPoints);
 
     mitk::FiberBundle::Pointer ShuffledBundle = mitk::FiberBundle::New(vNewPolyData);
     ShuffledBundle->SetFiberWeights(weights);
 
     ShuffledBundle->ResampleToNumPoints(40);
     MITK_INFO << "Resampling Done";
 
     mitk::DataNode::Pointer newnode = mitk::DataNode::New();
     newnode->SetData( ShuffledBundle );
     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);
 //      }
 //      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();
 //      m_Controls->m_PrototypeBox->SetAutoSelectNewItems (true);
 //      this->GetDataStorage()->Add(node);
 //      m_Controls->m_PrototypeBox->SetAutoSelectNewItems (false);
 //      m_Controls->m_useStandardP->setChecked(false);
 //      node->SetVisibility(false);
     // Get the number of fibers to use as prototypes from the user interface
     const int numPrototypes = m_Controls->m_NumPrototypes->value();
     MITK_INFO << "Number of Fibers to use as Prototypes: " << numPrototypes;
 
     // Get the bundle of fibers to extract prototypes from
     mitk::DataNode::Pointer selectedNode = m_Controls->m_BundleBox->GetSelectedNode();
     if (!selectedNode)
     {
         MITK_ERROR << "No fiber bundle selected";
         return;
     }
     mitk::FiberBundle::Pointer fiberBundle = dynamic_cast<mitk::FiberBundle*>(selectedNode->GetData());
     if (!fiberBundle)
     {
         MITK_ERROR << "Selected node does not contain a fiber bundle";
         return;
     }
     MITK_INFO << "Number of fibers in the selected bundle: " << fiberBundle->GetNumFibers();
 
     // Randomly shuffle the indices of fibers in the bundle
     std::vector<int> indices(fiberBundle->GetNumFibers());
     std::iota(std::begin(indices), std::end(indices), 0); // fill the vector with 0 to n-1
     std::random_shuffle(std::begin(indices), std::end(indices));
 
     // Create new PolyData to hold the prototype fibers
     vtkSmartPointer<vtkPolyData> prototypePolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> prototypeLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> prototypePoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkFloatArray> prototypeWeights = vtkSmartPointer<vtkFloatArray>::New();
 
     // Extract a subset of fibers as prototypes
     for (int i = 0; i < numPrototypes; i++)
     {
         if (indices.empty()) break;
         const int index = indices.back();
         indices.pop_back();
 
         vtkCell* cell = fiberBundle->GetFiberPolyData()->GetCell(index);
         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 = prototypePoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
 
         prototypeWeights->InsertNextValue(fiberBundle->GetFiberWeight(index));
         prototypeLines->InsertNextCell(container);
     }
 
     // Create a new FiberBundle containing the prototype fibers
     prototypePolyData->SetLines(prototypeLines);
     prototypePolyData->SetPoints(prototypePoints);
     mitk::FiberBundle::Pointer prototypesBundle = mitk::FiberBundle::New(prototypePolyData);
     prototypesBundle->SetFiberWeights(prototypeWeights);
     auto node = mitk::DataNode::New();
     node->SetData(prototypesBundle);
     node->SetName("Random_Prototypes");
     node->SetVisibility(false);
 
     GetDataStorage()->Add(node);
     m_Controls->m_PrototypeBox->SetAutoSelectNewItems(true);
     m_Controls->m_PrototypeBox->SetSelectedNode(node);
     m_Controls->m_PrototypeBox->SetAutoSelectNewItems(false);
     m_Controls->m_useStandardP->setChecked(false);
 
     MITK_INFO << "Created new node with " << numPrototypes << " random prototypes";
 
 }
 
 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();
       m_Controls->m_PrototypeBox->SetAutoSelectNewItems (true);
       this->GetDataStorage()->Add(node);
       m_Controls->m_PrototypeBox->SetAutoSelectNewItems (false);
       m_Controls->m_useStandardP->setChecked(false);
       node->SetVisibility(false);
 
 
 
 }
 
 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);
   m_testnode = m_Controls->m_TestBundleBox->GetSelectedNode();
   this->GetDataStorage()->Add(pointSetNode, m_testnode);
 
 
   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_positiveBundleNode.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 );
-//        node->SetData(m_negativeBundle);
-////        node->SetFloatProperty("shape.tuberadius", 0.5);
-////        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-//        m_positiveBundleNode = node;
-//        this->GetDataStorage()->Add(m_positiveBundleNode);
-//      MITK_INFO << "Create Bundle";
-//    }
+    if (m_positiveBundleNode.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 );
+        node->SetData(m_negativeBundle);
+//        node->SetFloatProperty("shape.tuberadius", 0.5);
+//        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+        m_positiveBundleNode = node;
+        this->GetDataStorage()->Add(m_positiveBundleNode);
+      MITK_INFO << "Create Bundle";
+    }
 
-//    if (!m_positiveBundleNode.IsNull())
-//    {
+    if (!m_positiveBundleNode.IsNull())
+    {
 
-//        this->GetDataStorage()->Remove(m_positiveBundleNode);
-//        MITK_INFO << "Adding fibers";
-//        MITK_INFO << m_positiveBundle->GetFiberPolyData()->GetNumberOfCells();
-//        m_positiveFibersData = m_positiveBundle->GetFiberPolyData();
-//    }
+        this->GetDataStorage()->Remove(m_positiveBundleNode);
+        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();
+    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();
+    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);
+      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);
-//      }
+        vtkIdType id = vNewPoints->InsertNextPoint(p);
+        container->GetPointIds()->InsertNextId(id);
+      }
 
-//      vNewLines->InsertNextCell(container);
-//      counter++;
-//    }
+      vNewLines->InsertNextCell(container);
+      counter++;
+    }
 
-//    mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(m_SelectedPS->GetData());
+    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);
+    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;
+    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);
-//    }
+    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();
+      // 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);
+      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);
+        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);
+      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_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->ResampleToNumPoints(40);
-//      MITK_INFO << "Resampling Done";
+      m_positiveBundle = mitk::FiberBundle::New(vNewPolyData);
+      m_positiveBundle->ResampleToNumPoints(40);
+      MITK_INFO << "Resampling Done";
 
 
-//      m_positiveBundle->SetFiberColors(0, 255, 0);
+      m_positiveBundle->SetFiberColors(0, 255, 0);
 
 
 
-//      mitk::DataNode::Pointer node = mitk::DataNode::New();
-//      node->SetData(m_positiveBundle);
-//      node->SetName("+Bundle");
-////      node->SetFloatProperty("shape.tuberadius", 0.5);
-////      mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+      mitk::DataNode::Pointer node = mitk::DataNode::New();
+      node->SetData(m_positiveBundle);
+      node->SetName("+Bundle");
+//      node->SetFloatProperty("shape.tuberadius", 0.5);
+//      mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+
+      m_positiveBundleNode= node;
 
-//      m_positiveBundleNode= node;
 
 
+      MITK_INFO << "The + Bundle has Streamlines:";
+      auto m_PosStreamline= dynamic_cast<mitk::FiberBundle *>(m_positiveBundleNode->GetData());
+      MITK_INFO << m_PosStreamline->GetFiberPolyData()->GetNumberOfCells();
 
-//      MITK_INFO << "The + Bundle has Streamlines:";
-//      auto m_PosStreamline= dynamic_cast<mitk::FiberBundle *>(m_positiveBundleNode->GetData());
-//      MITK_INFO << m_PosStreamline->GetFiberPolyData()->GetNumberOfCells();
+      this->GetDataStorage()->Add(m_positiveBundleNode);
+//      m_Controls->m_selectedPointSetWidget->m_ToggleAddPoint->setEnabled(false);
 
-//      this->GetDataStorage()->Add(m_positiveBundleNode);
-////      m_Controls->m_selectedPointSetWidget->m_ToggleAddPoint->setEnabled(false);
+      UpdateGui();
+      m_createdStreamlineCounter +=1;
 
-//      UpdateGui();
-//      m_createdStreamlineCounter +=1;
     // initialize figure's geometry with empty geometry
-    mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
-    mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
-    figure->SetPlaneGeometry( emptygeometry );
-
-    //set desired data to DataNode where Planarfigure is stored
-    mitk::DataNode::Pointer newNode = mitk::DataNode::New();
-    newNode->SetName(QString("Ball").toStdString());
-    newNode->SetData(figure);
-    newNode->SetBoolProperty("planarfigure.3drendering", true);
-    newNode->SetBoolProperty("planarfigure.3drendering.fill", true);
-
-    mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->GetDataInteractor().GetPointer());
-    if(figureInteractor.IsNull())
-    {
-      figureInteractor = mitk::PlanarFigureInteractor::New();
-      us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
-      figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
-      figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
-      figureInteractor->SetDataNode(newNode);
-    }
+//    mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
+//    mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
+//    figure->SetPlaneGeometry( emptygeometry );
+
+//    //set desired data to DataNode where Planarfigure is stored
+////    mitk::DataNode::Pointer circleNode = mitk::DataNode::New();
+//    circleNode->SetName(QString("Ball").toStdString());
+//    circleNode->SetData(figure);
+//    circleNode->SetBoolProperty("planarfigure.3drendering", true);
+//    circleNode->SetBoolProperty("planarfigure.3drendering.fill", true);
+
+//    mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(circleNode->GetDataInteractor().GetPointer());
+//    if(figureInteractor.IsNull())
+//    {
+//      figureInteractor = mitk::PlanarFigureInteractor::New();
+//      us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
+//      figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
+//      figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
+//      figureInteractor->SetDataNode(circleNode);
+//    }
 
-    // figure drawn on the topmost layer / image
-    GetDataStorage()->Add(newNode );
+//    // figure drawn on the topmost layer / image
+//    GetDataStorage()->Add(circleNode );
 
+//    UpdateGui();
 
-    newNode->SetSelected(true);
+//    circleNode->SetSelected(true);
 
-    vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
-    sphereSource->SetRadius(10);
-    sphereSource->SetPhiResolution(30);
-    sphereSource->SetThetaResolution(30);
-    sphereSource->Update();
+//    vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
+////    sphereSource->SetRadius(circleNode->GetData()->GetProperty("radius")->GetDoubleValue());
+//    sphereSource->SetRadius(5.0);
+//    sphereSource->SetCenter(0,0,0);
+//    sphereSource->SetPhiResolution(30);
+//    sphereSource->SetThetaResolution(30);
+//    sphereSource->Update();
 
-    // Convert the VTK sphere to a MITK surface
-    mitk::Surface::Pointer sphereSurface = mitk::Surface::New();
-    sphereSurface->SetVtkPolyData(sphereSource->GetOutput());
+//    // Convert the VTK sphere to a MITK surface
+//    mitk::Surface::Pointer sphereSurface = mitk::Surface::New();
+//    sphereSurface->SetVtkPolyData(sphereSource->GetOutput());
 
-    // Add the surface to the DataStorage
-    mitk::DataNode::Pointer sphereNode = mitk::DataNode::New();
-    sphereNode->SetData(sphereSurface);
-    sphereNode->SetName("Sphere");
-    GetDataStorage()->Add(sphereNode);
+//    // Add the surface to the DataStorage
+//    mitk::DataNode::Pointer sphereNode = mitk::DataNode::New();
+//    sphereNode->SetData(sphereSurface);
+//    sphereNode->SetName("Sphere");
+//    sphereNode->SetVisibility(true);
+//    sphereNode->SetOpacity(1.0);
+//    sphereNode->SetColor(1.0, 0.0, 0.0);
+//    GetDataStorage()->Add(sphereNode);
 
 
 //    vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
 //    sphereSource->SetCenter(0, 0, 0);
 //    sphereSource->SetRadius(5.0);
 
 //    auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
 //    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 //    vtkmapper->SetInputConnection(sphereSource->GetOutputPort());
 
 //    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
 //    actor->SetMapper(mapper);
 //    actor->GetProperty()->SetColor(1,0,0);
 
 //    mitk::Surface::Pointer sphereSurface = mitk::Surface::New();
 //    sphereSurface->SetVtkPolyData(sphereSource->GetOutput());
 
 //    mitk::DataNode::Pointer m_SphereNode = mitk::DataNode::New();
 //    m_SphereNode->SetName("Sphere");
 //    m_SphereNode->SetData(sphereSurface);
 
 //    m_SphereNode->SetOpacity(1.0);
 //    m_SphereNode->SetColor(1.0, 0.0, 0.0);
 //    m_SphereNode->SetVisibility(true);
 
 //    GetDataStorage()->Add(m_SphereNode);
 //    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 //    mitk::VtkPropRenderer::Pointer m_Renderer = mitk::VtkPropRenderer::New();
 //    m_Renderer->SetMapperID(mitk::BaseRenderer::Standard3D);
 //    m_Renderer->SetDataStorage(GetDataStorage());
 //    m_Renderer->SetDataNode(m_SphereNode);
 
 //    GetDataStorage()->Add(m_Renderer->GetRendererAsDataNode());
 //    mitk::DataNode::Pointer rendererNode = mitk::DataNode::New();
 //    rendererNode->SetData(m_Renderer);
 
 //    m_SphereNode->SetData(sphereSurface);
 //    m_SphereNode->SetVisibility(true);
 //    // Set a name for the renderer node
 //    rendererNode->SetName("RendererNode");
 
 //    // Add the renderer node to the DataStorage
 //    GetDataStorage()->Add(rendererNode);
 //    RenderingManager::GetInstance()->RequestUpdateAll();
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::ExtractRandomFibersFromTractogram()
 {
+
+
+    // Hide the selected node.
     m_testnode = m_Controls->m_TestBundleBox->GetSelectedNode();
     m_testnode->SetVisibility(false);
-//    m_SelectedFB.at(0)->SetVisibility(false);
+
+    // Uncheck the Brush and Erazor buttons.
     m_Controls->m_ErazorButton->setChecked(false);
     m_Controls->m_BrushButton->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());
+    // Print the number of fibers to extract.
+    MITK_INFO << "Number of Fibers to extract from Tractogram: ";
+    MITK_INFO << m_Controls->m_NumRandomFibers->value();
+    MITK_INFO << this->GetDataStorage()->GetAll();
 
-//         node->SetData( m_newfibersBundle );
-//         m_newfibersBundleNode = node ;
 
-       MITK_INFO << "Create Bundle";
-     }
-
-      mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData());
-     //      mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
-//      mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle *>(m_trainbundle->GetData());
+    // If a newfibersBundleNode exists, remove it from the data storage.
+    if (m_newfibersBundleNode)
+    {
+        MITK_INFO << "To Label Bundle Exists";
+        mitk::FiberBundle::Pointer Stack = dynamic_cast<mitk::FiberBundle *>(m_newfibersBundleNode->GetData());
+
+        // Create a new data node and set it to an empty FiberBundle.
+        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());
+
+        // Print a message to indicate the creation of the FiberBundle.
+        MITK_INFO << "Create Bundle";
+    }
+    // Get the selected node, which is assumed to be a FiberBundle.
+    mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData());
 
-      vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
-      vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
-      vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
+    // Create a new PolyData object, and its associated points and cell arrays.
+    vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
+    vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
+    vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
+    vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 
-      vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
-//      weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
+    // Initialize a counter variable.
+    unsigned int counter = 0;
 
-//      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));
+    if (m_Controls->m_NumRandomFibers->value() != fib->GetFiberPolyData()->GetNumberOfCells()) {
+        for (int i = 0; i < m_Controls->m_NumRandomFibers->value(); i++) {
+            // Get the i-th fiber in the input dataset
+            vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
+            // Get the number of points in the fiber
+            auto numPoints = cell->GetNumberOfPoints();
+            // Get the points in the fiber
+            vtkPoints* points = cell->GetPoints();
 
-       /* 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();
-//      }
+            // Create a new vtkPolyLine container to store the new fiber
+            vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
-//      if (thresh1!=fib->GetFiberPolyData()->GetNumberOfCells())
-        if (m_Controls->m_NumRandomFibers->value()!=fib->GetFiberPolyData()->GetNumberOfCells())
-      {
-//      for ( int i=thresh1; i<thresh2; i++)
-      for ( int i=0; i<m_Controls->m_NumRandomFibers->value(); i++)
-      {
-        vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
-        auto numPoints = cell->GetNumberOfPoints();
-        vtkPoints* points = cell->GetPoints();
+            // Loop through each point in the fiber
+            for (unsigned int j = 0; j < numPoints; j++) {
+                double p[3];
+                points->GetPoint(j, p);
 
-        vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-        for (unsigned int j=0; j<numPoints; j++)
-        {
-          double p[3];
-          points->GetPoint(j, p);
+                // Insert the new point into the vtkPoints object and get its ID
+                vtkIdType id = vNewPoints->InsertNextPoint(p);
+                // Add the ID to the container object to create a new fiber
+                container->GetPointIds()->InsertNextId(id);
+            }
 
-          vtkIdType id = vNewPoints->InsertNextPoint(p);
-          container->GetPointIds()->InsertNextId(id);
-        }
-        weights->InsertValue(counter, fib->GetFiberWeight(i));
-        vNewLines->InsertNextCell(container);
+            // Insert the fiber weight into the vtkDoubleArray object
+            weights->InsertValue(counter, fib->GetFiberWeight(i));
+            // Insert the new fiber into the vtkCellArray object
+            vNewLines->InsertNextCell(container);
 
+            // Increment the counter variable
         counter++;
+    }
 
-      }
-
-      for ( int i=0; i<m_Controls->m_NumRandomFibers->value(); i++)
-      {
+    // Delete the old fibers from the input dataset
+    for (int i = 0; i < m_Controls->m_NumRandomFibers->value(); i++) {
         fib->GetFiberPolyData()->DeleteCell(i);
-      }
-      fib->GetFiberPolyData()->RemoveDeletedCells();
-
-      MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
+    }
+    // Remove any deleted cells from the input dataset
+    fib->GetFiberPolyData()->RemoveDeletedCells();
 
-//      m_SelectedFB.at(0)->SetData(fib);
+    // Output the number of fibers in the new dataset to the console
+    MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
 
-      vNewPolyData->SetLines(vNewLines);
-      vNewPolyData->SetPoints(vNewPoints);
+    // Set the vtkPolyData object to the new fibers
+    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);
+    // Create a new vtkPolyData object and set it to the new fibers
+    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);
+    // Create a new mitk::FiberBundle object and set it to the new fibers
+    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");
-//      node->SetData(m_negativeBundle);
-//      node->SetFloatProperty("shape.tuberadius", 0.5);
-//      mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
-      m_newfibersBundleNode = node;
+    mitk::DataNode::Pointer node = mitk::DataNode::New();
+    node->SetData(m_newfibersBundle);
+    node->SetName("ToLabel");
+    m_newfibersBundleNode = node;
+    this->GetDataStorage()->Add(m_newfibersBundleNode);
 
-//      MITK_INFO << "Number of Streamlines in first function";
-//      MITK_INFO << m_newfibersBundleNode->GetData()->GetFiberPolyData()->GetNumberOfCells();
-      this->GetDataStorage()->Add(m_newfibersBundleNode);
+    // Create a new data node for the negativeBundle object
+    if (!m_negativeBundleNode)
+    {
+        mitk::FiberBundle::Pointer m_negativeBundle = mitk::FiberBundle::New();
+        mitk::DataNode::Pointer node2 = mitk::DataNode::New();
+        node2->SetName("-Bundle");
+        node2->SetData(m_negativeBundle);
+        m_negativeBundleNode = node2;
+        this->GetDataStorage()->Add(m_negativeBundleNode);
+    }
 
-      mitk::FiberBundle::Pointer m_negativeBundle = mitk::FiberBundle::New();
-      mitk::DataNode::Pointer node2 = mitk::DataNode::New();
-      node2->SetName("-Bundle");
-      node2->SetData(m_negativeBundle);
-//            node->SetFloatProperty("shape.tuberadius", 0.5);
-//            mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-      m_negativeBundleNode = node2;
-      this->GetDataStorage()->Add(m_negativeBundleNode);
 
-      m_RandomExtractionCounter++;
-      }
+    // Increment the RandomExtractionCounter
+    m_RandomExtractionCounter++;
+    }
 
-//      m_Controls->m_ErazorButton->setChecked(true);
 
 
     UpdateGui();
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromBundle( bool checked )
 {
     if (checked)
     {
         m_Controls->m_BrushButton->setChecked(false);
 
 //        if (m_StreamlineInteractor.IsNull())
 //        {
             this->CreateStreamlineInteractorBrush();
             this->CreateStreamlineInteractor();
 //        }
         m_StreamlineInteractor->EnableInteraction(true);
         m_StreamlineInteractor->LabelfromPrediction(false);
         m_StreamlineInteractor->SetNegativeNode(m_negativeBundleNode);
         m_StreamlineInteractor->SetPositiveNode(m_positiveBundleNode);
         m_StreamlineInteractor->SetToLabelNode(m_newfibersBundleNode);
         m_StreamlineInteractor->EnableInteraction(true);
 
 //            m_StreamlineInteractor->EnableInteraction(true);
 //            m_StreamlineInteractor->LabelfromPrediction(false);
 //            m_StreamlineInteractor->SetNegativeNode(m_negativeBundleNode);
 //            m_StreamlineInteractor->SetPositiveNode(m_positiveBundleNode);
 //            m_StreamlineInteractor->SetToLabelNode(m_newfibersBundleNode);
 //        }
 //        else
 //        {
 //            m_StreamlineInteractor->EnableInteraction(true);
 //            m_StreamlineInteractor->LabelfromPrediction(false);
 //            m_StreamlineInteractor->SetPositiveNode(m_positiveBundleNode);
 //            m_StreamlineInteractor->SetToLabelNode(m_newfibersBundleNode);
 //        }
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
 
 
    UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromBundleBrush( bool checked )
 {
     if (checked)
     {
         m_Controls->m_ErazorButton->setChecked(false);
 
 //        if (m_StreamlineInteractorBrush.IsNull())
 //        {
             this->CreateStreamlineInteractor();
             this->CreateStreamlineInteractorBrush();
 //        }
 
 
         m_StreamlineInteractorBrush->EnableInteraction(true);
         m_StreamlineInteractorBrush->LabelfromPrediction(false);
         m_StreamlineInteractorBrush->SetNegativeNode(m_negativeBundleNode);
         m_StreamlineInteractorBrush->SetPositiveNode(m_positiveBundleNode);
         m_StreamlineInteractorBrush->SetToLabelNode(m_newfibersBundleNode);
         m_StreamlineInteractorBrush->EnableInteraction(true);
 //            m_StreamlineInteractorBrush->EnableInteraction(true);
 //            m_StreamlineInteractorBrush->LabelfromPrediction(false);
 //            m_StreamlineInteractorBrush->SetNegativeNode(m_negativeBundleNode);
 //            m_StreamlineInteractorBrush->SetPositiveNode(m_positiveBundleNode);
 //            m_StreamlineInteractorBrush->SetToLabelNode(m_newfibersBundleNode);
 //        }
 //        else
 //        {
 //            m_StreamlineInteractorBrush->EnableInteraction(true);
 //            m_StreamlineInteractorBrush->LabelfromPrediction(false);
 //            m_StreamlineInteractorBrush->SetPositiveNode(m_positiveBundleNode);
 //            m_StreamlineInteractorBrush->SetToLabelNode(m_newfibersBundleNode);
 //        }
     }
     else
     {
       m_StreamlineInteractorBrush->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::CreateStreamlineInteractorBrush()
 {
 
     m_StreamlineInteractorBrush = mitk::StreamlineInteractorBrush::New();
 
     m_StreamlineInteractorBrush->LoadStateMachine("StreamlineBrush3DStates.xml", us::ModuleRegistry::GetModule("MitkFiberDissection"));
     m_StreamlineInteractorBrush->SetEventConfig("StreamlineBrush3DConfig.xml", us::ModuleRegistry::GetModule("MitkFiberDissection"));
 
 //  m_StreamlineInteractor->SetRotationEnabled(rotationEnabled);
 }
 
 void QmitkInteractiveFiberDissectionView::StartAlgorithm()
 {
 
     m_negativeBundle = dynamic_cast<mitk::FiberBundle*>(m_negativeBundleNode->GetData());
     m_positiveBundle = dynamic_cast<mitk::FiberBundle*>(m_positiveBundleNode->GetData());
 
 
     this->GetDataStorage()->Remove(m_UncertaintyLabelNode);
     this->GetDataStorage()->Remove(m_DistanceLabelNode);
 
 
     MITK_INFO << "Clean Test Data";
 
 //    this->CleanTestArray();
     m_testnode = m_Controls->m_TestBundleBox->GetSelectedNode();
 //     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData());
 
     MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
     fib->GetFiberPolyData()->RemoveDeletedCells();
     MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
 
 
     m_Controls->m_unclabeling->setChecked(false);
     m_Controls->m_distlabeling->setChecked(false);
     m_Controls->m_unclabelingBrush->setChecked(false);
     m_Controls->m_predlabeling->setChecked(false);
     m_Controls->m_predlabelingBrush->setChecked(false);
     m_uncCounter = 0;
 
 //    classifier.reset();
     MITK_INFO << "Extract Features";
 
     classifier = std::make_shared<mitk::StreamlineFeatureExtractor>();
     classifier->SetActiveCycle(m_activeCycleCounter);
     classifier->SetTractogramPlus(m_positiveBundle);
     classifier->SetTractogramMinus(m_negativeBundle);
     classifier->SetTractogramPrototypes(dynamic_cast<mitk::FiberBundle*>(m_Controls->m_PrototypeBox->GetSelectedNode()->GetData()), m_Controls->m_useStandardP->isChecked());
 //    classifier->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData()), m_SelectedFB.at(0)->GetName());
     classifier->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData()), m_testnode->GetName());
 //    classifier->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_trainbundle->GetData()), m_trainbundle->GetName());
 
 
 
     classifier->Update();
 
     m_index = classifier->m_index;
     MITK_INFO << "Number of Cycles";
     MITK_INFO << m_activeCycleCounter;
     m_activeCycleCounter += 1;
 
 
     MITK_INFO << "Algorithm run succesfully";
 //    mitk::DataNode::Pointer node = mitk::DataNode::New();
 //    this->GetDataStorage()->Add(node);
     m_Controls->m_CreatePrediction->setEnabled(true);
     UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::CreatePredictionNode()
 {
     MITK_INFO << "Create Prediction";
 
     m_Prediction = classifier->CreatePrediction(m_index.at(0), false);
 
 //    m_Prediction->ColorFibersByFiberWeights(false, mitk::LookupTable::JET);
     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::CreateCertainNode()
 {
     MITK_INFO << "Create Certain Data";
 
 
     m_CertainMinus = classifier->CreatePrediction(m_index.at(2), false);
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_CertainMinus);
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("m_CertainMinus"+s);
     m_CertainMinusNode = node;
     this->GetDataStorage()->Add(m_CertainMinusNode);
 
 //    m_CertainPlus = classifier->CreatePrediction(m_index.at(4));
 //    mitk::DataNode::Pointer node2= mitk::DataNode::New();
 //    node2->SetData(m_CertainPlus);
 //    node2->SetName("m_CertainPlus"+s);
 //    m_CertainPlusNode = node2;
 //    this->GetDataStorage()->Add(m_CertainPlusNode);
 
 
 //    m_CertainBetweenMinus = classifier->CreatePrediction(m_index.at(4));
 //    mitk::DataNode::Pointer node3 = mitk::DataNode::New();
 //    node3->SetData(m_CertainBetweenMinus);
 //    node3->SetName("m_CertainBetweenMinus"+s);
 //    m_CertainBetweenMinusNode = node3;
 //    this->GetDataStorage()->Add(m_CertainBetweenMinusNode);
 
 //    m_CertainBetweenPlus = classifier->CreatePrediction(m_index.at(6));
 //    mitk::DataNode::Pointer node4= mitk::DataNode::New();
 //    node4->SetData(m_CertainBetweenPlus);
 //    node4->SetName("m_CertainBetweenPlus"+s);
 //    m_CertainBetweenPlusNode = node4;
 //    this->GetDataStorage()->Add(m_CertainBetweenPlusNode);
 
 }
 
 void QmitkInteractiveFiberDissectionView::RemoveCertainData()
 {
 //    mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData());
     MITK_INFO << "Length of certain negativ data:";
     MITK_INFO << m_index.at(2).size();
     MITK_INFO << "Length of Testdata";
     MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
     for (unsigned int i=0; i< m_index.at(2).size(); i++)
     {
         fib->GetFiberPolyData()->DeleteCell(m_index.at(2).at(i));
     }
 //    fib->GetFiberPolyData()->RemoveDeletedCells();
 
     MITK_INFO << "Length of Testdata";
     MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateUncertaintySampleNode()
 {
      this->GetDataStorage()->Remove(m_UncertaintyLabelNode);
      MITK_INFO << "Create Fibers to label based on Uncertainty";
 
      std::vector<unsigned int> vec = m_index.at(1);
      std::vector<unsigned int> myvec = {vec.begin() + m_uncCounter, vec.begin() + m_uncCounter + m_Controls->m_Numtolabel->value()};
      m_uncCounter = m_uncCounter + m_Controls->m_Numtolabel->value();
      MITK_INFO << m_index.at(1).size();
      MITK_INFO << myvec.size();
 
 
     m_UncertaintyLabel = classifier->CreatePrediction(myvec, true);
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_UncertaintyLabel);
     float d = 5.0;
 
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("UncertaintyLabel"+s);
     m_UncertaintyLabelNode = node;
     m_UncertaintyLabelNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(d));
     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();
 
     float myval = m_Controls->m_subsetfft->value() * 0.01;
     MITK_INFO << myval;
     std::vector<std::vector<unsigned int>> curidx;
     curidx =  classifier->GetDistanceData(myval);
     std::vector<unsigned int> myvec = curidx.at(0);
     myvec.resize(m_Controls->m_Numtolabel2->value());
     MITK_INFO << m_index.at(2).size();
     MITK_INFO << myvec.size();
     m_DistanceLabel = classifier->CreatePrediction(myvec, true);
     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_Controls->m_unclabelingBrush->setChecked(false);
         m_Controls->m_predlabelingBrush->setChecked(false);
         m_Controls->m_predlabeling->setChecked(false);
 
 
         m_UncertaintyLabel->SetFiberColors(255, 255, 255);
         this->CreateStreamlineInteractor();
         m_StreamlineInteractor->EnableInteraction(true);
         m_StreamlineInteractor->LabelfromPrediction(false);
         m_StreamlineInteractor->SetNegativeNode(m_negativeBundleNode);
         m_StreamlineInteractor->SetPositiveNode(m_positiveBundleNode);
         m_StreamlineInteractor->SetToLabelNode(m_UncertaintyLabelNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromUncertaintyBrush( bool checked )
 {
     if (checked)
     {
         m_Controls->m_unclabeling->setChecked(false);
         m_Controls->m_predlabelingBrush->setChecked(false);
         m_Controls->m_predlabeling->setChecked(false);
 
         m_UncertaintyLabel->SetFiberColors(255, 255, 255);
         this->CreateStreamlineInteractorBrush();
         m_StreamlineInteractorBrush->EnableInteraction(true);
         m_StreamlineInteractorBrush->LabelfromPrediction(false);
         m_StreamlineInteractorBrush->SetNegativeNode(m_negativeBundleNode);
         m_StreamlineInteractorBrush->SetPositiveNode(m_positiveBundleNode);
         m_StreamlineInteractorBrush->SetToLabelNode(m_UncertaintyLabelNode);
     }
     else
     {
       m_StreamlineInteractorBrush->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_Controls->m_predlabelingBrush->setChecked(false);
         m_Controls->m_unclabelingBrush->setChecked(false);
         m_Controls->m_unclabeling->setChecked(false);
 
 //        m_Prediction->SetFiberColors(255, 255, 255);
         this->CreateStreamlineInteractor();
         m_StreamlineInteractor->EnableInteraction(true);
         m_StreamlineInteractor->LabelfromPrediction(true);
         m_StreamlineInteractor->SetNegativeNode(m_negativeBundleNode);
         m_StreamlineInteractor->SetPositiveNode(m_positiveBundleNode);
         m_StreamlineInteractor->SetToLabelNode(m_PredictionNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
 //      this->CleanTestArray();
     }
 
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromPredictionBrush( bool checked )
 {
     if (checked)
     {
         m_Controls->m_predlabeling->setChecked(false);
         m_Controls->m_unclabelingBrush->setChecked(false);
         m_Controls->m_unclabeling->setChecked(false);
 
 //        m_Prediction->SetFiberColors(255, 255, 255);
         this->CreateStreamlineInteractorBrush();
         m_StreamlineInteractorBrush->EnableInteraction(true);
         m_StreamlineInteractorBrush->LabelfromPrediction(true);
         m_StreamlineInteractorBrush->SetNegativeNode(m_negativeBundleNode);
         m_StreamlineInteractorBrush->SetPositiveNode(m_positiveBundleNode);
         m_StreamlineInteractorBrush->SetToLabelNode(m_PredictionNode);
     }
     else
     {
       m_StreamlineInteractorBrush->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
 //      this->CleanTestArray();
     }
 
 }
 
 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));
         m_StreamlineInteractor->SetToLabelNode(m_testnode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
     //      m_StreamlineInteractor = nullptr;
     }
 }
 
 void QmitkInteractiveFiberDissectionView::StartValidation()
 {
 
 
 
 
     validater.reset();
 //    mitk::DataNode::Pointer prednode = m_Controls->m_BundleBox->GetSelectedNode();
 //    mitk::FiberBundle::Pointer pred = dynamic_cast<mitk::FiberBundle *>(prednode->GetData());
 //    mitk::DataNode::Pointer gtnode = m_Controls->m_BundleBox->GetSelectedNode();
 //    mitk::FiberBundle::Pointer gt = dynamic_cast<mitk::FiberBundle *>(gtnode->GetData());
 //    mitk::FiberBundle::Pointer pred = dynamic_cast<mitk::FiberBundle*>(m_Controls->m_PredictionBox->GetSelectedNode()->GetData());
 //    mitk::FiberBundle::Pointer gt = dynamic_cast<mitk::FiberBundle*>(m_Controls->m_GroundtruthBox->GetSelectedNode()->GetData());
 
     validater= std::make_shared<mitk::StreamlineFeatureExtractor>();
     validater->SetTractogramPrototypes(dynamic_cast<mitk::FiberBundle*>(m_Controls->m_PrototypeBox->GetSelectedNode()->GetData()), m_Controls->m_useStandardP->isChecked());
     MITK_INFO << "Prototypes loaded";
     validater->SetTractogramPrediction(dynamic_cast<mitk::FiberBundle*>(m_Controls->m_PredictionBox->GetSelectedNode()->GetData()));
     MITK_INFO << "Prediction loaded";
     validater->SetTractogramGroundtruth(dynamic_cast<mitk::FiberBundle*>(m_Controls->m_GroundtruthBox->GetSelectedNode()->GetData()));
     MITK_INFO << "Groundtruth loaded";
 
     validater->SetActiveCycle(m_activeCycleCounter);
 //    validater->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData()), m_SelectedFB.at(0)->GetName());
     validater->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData()), m_testnode->GetName());
 //    classifier->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_trainbundle->GetData()), m_trainbundle->GetName());
 
 
 
     MITK_INFO << "Testdata loaded";
     vnl_vector<float> metrics;
     metrics = validater->ValidationPipe();
 
    m_metrics.push_back(metrics);
 
 
     MITK_INFO << "Validation run succesfully";
 
     UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::AutomaticLabelling()
 {
 //    mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
 //    mitk::FiberBundle::Pointer fib_true = dynamic_cast<mitk::FiberBundle*>(m_Controls->m_GroundtruthBox->GetSelectedNode()->GetData());
 //    vtkCell* cell;
 //    vtkCell* cell2;
 //    for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
 //    {
 //        cell = fib->GetFiberPolyData()->GetCell(i);
 //        for (int k=0; k<fib->GetFiberPolyData()->GetNumberOfCells(); k++ )
 //        {
 //            cell2 = fib_true->GetFiberPolyData()->GetCell(i);
 //            if (cell==cell2)
 //                MITK_INFO << "Same";
 //        }
 //    }
 
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_PredictionNode->GetData());
     mitk::FiberBundle::Pointer fib_true = dynamic_cast<mitk::FiberBundle*>(m_positiveBundleNode->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();
 
      /* 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<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++;
 
     }
 
     for (int i=0; i<fib_true->GetFiberPolyData()->GetNumberOfCells(); i++)
     {
       vtkCell* cell = fib_true->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_true->GetFiberWeight(i));
       vNewLines->InsertNextCell(container);
       counter++;
 
     }
 
 
 
     vNewPolyData->SetLines(vNewLines);
     vNewPolyData->SetPoints(vNewPoints);
 
     mitk::FiberBundle::Pointer MergedPrediction = mitk::FiberBundle::New(vNewPolyData);
     MergedPrediction->SetFiberWeights(weights);
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(MergedPrediction);
     node->SetName("MergedPrediction");
     this->GetDataStorage()->Add(node);
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::CleanTestArray()
 {
 
     mitk::FiberBundle::Pointer fib_pos = dynamic_cast<mitk::FiberBundle*>(m_positiveBundleNode->GetData());
     mitk::FiberBundle::Pointer fib_neg = dynamic_cast<mitk::FiberBundle*>(m_negativeBundleNode->GetData());
 //    mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_testnode->GetData());
     vtkCell* cur_cell;
     vtkCell* cur_cell2;
     MITK_INFO << fib_neg->GetFiberPolyData()->GetNumberOfCells();
     MITK_INFO << fib_pos->GetFiberPolyData()->GetNumberOfCells();
     MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
 
 
     std::vector<float> array;
     std::vector<float> array2;
 
 
     //    cv::parallel_for_(cv::Range(0, fib->GetFiberPolyData()->GetNumberOfCells()), [&](const cv::Range &range)
     //    {
     //    for (int i = range.start; i < range.end; i++)
         for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
                 cur_cell = fib->GetFiberPolyData()->GetCell(i);
                 auto numPoints = cur_cell->GetNumberOfPoints();
                 vtkPoints* points = cur_cell->GetPoints();
                 for (unsigned int j=0; j<numPoints; j++)
                 {
                   double p[3];
                   points->GetPoint(j, p);
                   array.push_back(*p);
                 }
                 for (int ik=0; ik<fib_neg->GetFiberPolyData()->GetNumberOfCells(); ik++)
                 {
                     cur_cell2 = fib_neg->GetFiberPolyData()->GetCell(ik);
                     auto numPoints2 = cur_cell2->GetNumberOfPoints();
                     vtkPoints* points2 = cur_cell2->GetPoints();
                     for (unsigned int j2=0; j2<numPoints2; j2++)
                     {
                       double p2[3];
                       points2->GetPoint(j2, p2);
                       array2.push_back(*p2);
 
                     }
                     if (array==array2)
                     {
                         fib->GetFiberPolyData()->DeleteCell(i);
                         MITK_INFO << "Delete Cell";
                     }
                     array2.clear();
                 }
                 for (int ik=0; ik<fib_pos->GetFiberPolyData()->GetNumberOfCells(); ik++)
                 {
 
                     cur_cell2 = fib_pos->GetFiberPolyData()->GetCell(ik);
                     auto numPoints2 = cur_cell2->GetNumberOfPoints();
                     vtkPoints* points2 = cur_cell2->GetPoints();
                     for (unsigned int j2=0; j2<numPoints2; j2++)
                     {
                       double p2[3];
                       points2->GetPoint(j2, p2);
                       array2.push_back(*p2);
                     }
                     if (array==array2)
                     {
                         fib->GetFiberPolyData()->DeleteCell(i);
                         MITK_INFO << "Delete Cell";
                     }
                     array2.clear();
                 }
                 array.clear();
             }
     //    });
 
 //        fib->GetFiberPolyData()->RemoveDeletedCells();
 
         MITK_INFO << fib->GetFiberPolyData()->GetNumberOfCells();
 
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::ResetClassifier()
 {
     m_IterationCounter = 0;
     m_RandomExtractionCounter = 0;
     m_activeCycleCounter = 0;
     m_createdStreamlineCounter = 0;
 
     classifier.reset();
     this->GetDataStorage()->Remove(m_positiveBundleNode);
     this->GetDataStorage()->Remove(m_negativeBundleNode);
     this->GetDataStorage()->Remove(m_negativeBundleNode);
 
     m_positiveBundleNode = NULL;
     m_negativeBundleNode = NULL;
     m_negativeBundleNode = NULL;
     m_positiveBundle = NULL;
     m_negativeBundle = NULL;
     m_negativeBundle = NULL;
     m_Controls->m_TrainClassifier->setEnabled(false);
     m_Controls->m_CreatePrediction->setEnabled(false);
     m_Controls->m_CreateUncertantyMap->setEnabled(false);
 
 
 
 }
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 a93a067..2491444 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,196 +1,198 @@
 /*===================================================================
 
 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 <mitkStreamlineInteractorBrush.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>
 
 #include <mitkSurface.h>
 
 #include <vtkSphereSource.h>
 #include <vtkPolyDataMapper.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 RemovefromBundleBrush( bool checked );
   void ExtractRandomFibersFromTractogram();
   void StartAlgorithm();
   void CreatePredictionNode();
   void CreateCertainNode();
   void CreateUncertaintySampleNode();
   void CreateDistanceSampleNode();
   void RemovefromUncertainty( bool checked );
   void RemovefromUncertaintyBrush( bool checked );
   void RemovefromDistance( bool checked );
   void RemovefromPrediction( bool checked );
   void RemovefromPredictionBrush( bool checked );
   void RemovefromSelection( bool checked );
   void ResampleTractogram();
   void RandomPrototypes();
   void SFFPrototypes();
   void StartValidation();
   void AutomaticLabelling();
   void RemoveCertainData();
   void ResetClassifier();
 
 
 
   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();
   void CreateStreamlineInteractorBrush();
   void CleanTestArray();
 
   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_newpos;
   int m_newneg;
   int m_startneg;
   int m_createdStreamlineCounter;
   int m_uncCounter;
 //  int m_thresh2;
 
 
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
   mitk::DataNode::Pointer m_testnode;
 //  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_CertainPlus;
   mitk::FiberBundle::Pointer            m_CertainMinus;
   mitk::FiberBundle::Pointer            m_CertainBetweenPlus;
   mitk::FiberBundle::Pointer            m_CertainBetweenMinus;
   mitk::FiberBundle::Pointer            m_UncertaintyLabel;
   mitk::FiberBundle::Pointer            m_DistanceLabel;
 
 
   mitk::DataNode::Pointer               m_positiveBundleNode;
   mitk::DataNode::Pointer               m_newfibersBundleNode;
   mitk::DataNode::Pointer               m_negativeBundleNode;
   mitk::DataNode::Pointer               m_PredictionNode;
   mitk::DataNode::Pointer               m_CertainPlusNode;
   mitk::DataNode::Pointer               m_CertainMinusNode;
   mitk::DataNode::Pointer               m_CertainBetweenPlusNode;
   mitk::DataNode::Pointer               m_CertainBetweenMinusNode;
   mitk::DataNode::Pointer               m_UncertaintyLabelNode;
   mitk::DataNode::Pointer               m_DistanceLabelNode;
 
   vtkSmartPointer<vtkPolyData>          m_positiveFibersData;
   vtkSmartPointer<vtkPolyData>          m_newfibersFibersData;
 
+  mitk::DataNode::Pointer               circleNode;
+
   vtkSmartPointer<vtkCellPicker>        m_picker1;
   mitk::StreamlineInteractor::Pointer   m_StreamlineInteractor;
   mitk::StreamlineInteractorBrush::Pointer   m_StreamlineInteractorBrush;
 
   std::shared_ptr< mitk::StreamlineFeatureExtractor > classifier;
   std::shared_ptr< mitk::StreamlineFeatureExtractor > validater;
 
 
   std::vector<vnl_vector<float>> m_metrics;
 
   std::vector<std::vector<unsigned int>> m_index;
 
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED