diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
index b2804c6..96bffe4 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
@@ -1,716 +1,715 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "mitkStreamlineFeatureExtractor.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 #include <vnl/vnl_sparse_matrix.h>
 #include <mitkIOUtil.h>
 
 namespace mitk{
 
 StreamlineFeatureExtractor::StreamlineFeatureExtractor()
   : m_NumPoints(40)
 {
 
 }
 
 StreamlineFeatureExtractor::~StreamlineFeatureExtractor()
 {
 
 }
 
 
 
 void StreamlineFeatureExtractor::SetTractogramPlus(const mitk::FiberBundle::Pointer &TractogramPlus)
 {
   m_TractogramPlus = TractogramPlus;
 }
 
 void StreamlineFeatureExtractor::SetTractogramMinus(const mitk::FiberBundle::Pointer &TractogramMinus)
 {
   m_TractogramMinus = TractogramMinus;
 }
 
 void StreamlineFeatureExtractor::SetActiveCycle(int &activeCycle)
 {
   m_activeCycle= activeCycle;
 }
 
+//void StreamlineFeatureExtractor::SetRandomThreshold(int &threshold)
+//{
+//    m_thresh = threshold;
+//    MITK_INFO << m_thresh;
+//}
+
+
+
 
 
 void StreamlineFeatureExtractor::SetTractogramTest(const mitk::FiberBundle::Pointer &TractogramTest, std::string TractogramTestName)
 {
     std::string path = "/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/storage/";
     path.append(TractogramTestName);
     m_TractogramTest= TractogramTest;
     auto s = std::to_string(m_NumPoints);
     m_DistancesTestName= path.append("_distances" + s + ".csv");
 }
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
   temp_fib->ResampleToNumPoints(m_NumPoints);
   MITK_INFO << "Resampling Done";
 
   std::vector< vnl_matrix<float> > out_fib(temp_fib->GetFiberPolyData()->GetNumberOfCells());
 //  std::vector< vnl_matrix<float> > out_fib();
 
 //  cv::parallel_for_(cv::Range(0, temp_fib->GetFiberPolyData()->GetNumberOfCells()), [&](const cv::Range &range)
 //  {
 //      for (int i = range.start; i < range.end; i++)
 //    #pragma omp parallel for
 //  #pragma omp parallel for num_threads(10) collapse(1)
       for (int i=0; i<temp_fib->GetFiberPolyData()->GetNumberOfCells(); i++)
       {
         vtkCell* cell = temp_fib->GetFiberPolyData()->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vnl_matrix<float> streamline;
         streamline.set_size(3, m_NumPoints);
         streamline.fill(0.0);
 
         for (int j=0; j<numPoints; j++)
         {
           double cand[3];
           points->GetPoint(j, cand);
 
           vnl_vector_fixed< float, 3 > candV;
           candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
           streamline.set_column(j, candV);
         }
 
 //        out_fib.push_back(streamline);
         out_fib.at(i)=streamline;
       }
 //      });
 
 
 
   return out_fib;
 }
 
-std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::CalculateDmdf(std::vector<vnl_matrix<float> > tractogram, std::vector<vnl_matrix<float> > prototypes,
+std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::CalculateDmdf(std::vector<vnl_matrix<float> > tractogram,
+                                                                          std::vector<vnl_matrix<float> > prototypes,
                                                                           std::vector<vnl_matrix<float> > positive_local_prototypes,
                                                                           std::vector<vnl_matrix<float> > negative_local_prototypes)
 {
-    unsigned int pos_locals;
-    unsigned int neg_locals;
-    if (positive_local_prototypes.size() >= 50)
-    {
-        pos_locals= 50;
-    }
-    else {
-        pos_locals= positive_local_prototypes.size();
-    }
-
-    if (pos_locals <= positive_local_prototypes.size())
-    {
-        neg_locals = pos_locals;
-    }
-    else {
-        neg_locals= negative_local_prototypes.size();
-    }
 
 
-    MITK_INFO << "Locals:";
-    MITK_INFO << neg_locals + pos_locals;
 
+    std::vector< vnl_matrix<float> > merged_prototypes;
 
-    std::vector<vnl_matrix<float> > merged_prototypes;
-
-
-    for (unsigned int k=0; k<prototypes.size(); k++ )
+    for (unsigned int k=0; k<prototypes.size(); k++)
     {
         merged_prototypes.push_back(prototypes.at(k));
     }
-    for (unsigned int k=0; k<pos_locals; k++ )
+    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<neg_locals; k++ )
+    for (unsigned int k=0; k<negative_local_prototypes.size(); k++)
     {
         merged_prototypes.push_back(negative_local_prototypes.at(k));
     }
 
-    MITK_INFO << "merged_prototypes";
-    MITK_INFO << merged_prototypes.size();
 
 
     std::vector< vnl_matrix<float> >  dist_vec(tractogram.size());//
     MITK_INFO << "Start Calculating Dmdf";
     cv::parallel_for_(cv::Range(0, tractogram.size()), [&](const cv::Range &range)
     {
     for (int i = range.start; i < range.end; i++)
 
 //    for (unsigned int i=0; i<tractogram.size(); i++)
     {
 
         vnl_matrix<float> distances;
-        distances.set_size(1, merged_prototypes.size());
+        distances.set_size(1, prototypes.size());
         distances.fill(0.0);
 
 
-        for (unsigned int j=0; j<merged_prototypes.size(); j++)
+        for (unsigned int j=0; j<prototypes.size(); j++)
         {
             vnl_matrix<float> single_distances;
             single_distances.set_size(1, tractogram.at(0).cols());
             single_distances.fill(0.0);
             vnl_matrix<float> single_distances_flip;
             single_distances_flip.set_size(1, tractogram.at(0).cols());
             single_distances_flip.fill(0.0);
             for (unsigned int ik=0; ik<tractogram.at(0).cols(); ik++)
             {
                 double cur_dist;
                 double cur_dist_flip;
 
-                cur_dist = sqrt(pow(tractogram.at(i).get(0,ik) - merged_prototypes.at(j).get(0,ik), 2.0) +
-                                       pow(tractogram.at(i).get(1,ik) - merged_prototypes.at(j).get(1,ik), 2.0) +
-                                       pow(tractogram.at(i).get(2,ik) - merged_prototypes.at(j).get(2,ik), 2.0));
+                cur_dist = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,ik), 2.0) +
+                                       pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,ik), 2.0) +
+                                       pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,ik), 2.0));
 
-                cur_dist_flip = sqrt(pow(tractogram.at(i).get(0,ik) - merged_prototypes.at(j).get(0,merged_prototypes.at(0).cols()-(ik+1)), 2.0) +
-                                       pow(tractogram.at(i).get(1,ik) - merged_prototypes.at(j).get(1,merged_prototypes.at(0).cols()-(ik+1)), 2.0) +
-                                       pow(tractogram.at(i).get(2,ik) - merged_prototypes.at(j).get(2,merged_prototypes.at(0).cols()-(ik+1)), 2.0));
+                cur_dist_flip = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,prototypes.at(0).cols()-(ik+1)), 2.0) +
+                                       pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,prototypes.at(0).cols()-(ik+1)), 2.0) +
+                                       pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,merged_prototypes.at(0).cols()-(ik+1)), 2.0));
 
                 single_distances.put(0,ik, cur_dist);
                 single_distances_flip.put(0,ik, cur_dist_flip);
 
             }
 
             if (single_distances_flip.mean()> single_distances.mean())
             {
                 distances.put(0,j, single_distances.mean());
             }
             else {
                 distances.put(0,j, single_distances_flip.mean());
             }
 
 
 
         }
 //        dist_vec.push_back(distances);
         dist_vec.at(i) = distances;
     }
     });
     MITK_INFO << "Done Calculation";
     MITK_INFO << dist_vec.at(0).size();
 
     return dist_vec;
 }
 
 std::vector<std::vector<unsigned int>>  StreamlineFeatureExtractor::GetData()
 {
     MITK_INFO << "Start Function Get Data";
-    MITK_INFO << m_DistancesPlus.at(0);
 
     /*Vector which saves Prediction and Fibers to label based on uncertainty*/
     std::vector<std::vector<unsigned int>> index_vec;
 
 //    int labels_arr [m_DistancesPlus.size()+m_DistancesMinus.size()];
     cv::Mat data;
     cv::Mat labels_arr_vec;
 
     int size_plus = 0;
 
 
     /*Create Trainingdata: Go through positive and negative Bundle and save distances as cv::Mat and create vector with labels*/
     for ( unsigned int i=0; i<m_DistancesPlus.size(); i++)
     {
         float data_arr [m_DistancesPlus.at(0).size()];
 //        labels_arr[i]=1;
         labels_arr_vec.push_back(1);
 
         for ( unsigned int j=0; j<m_DistancesPlus.at(0).cols(); j++)
         {
             data_arr[j] = m_DistancesPlus.at(i).get(0,j);
         }
         cv::Mat curdata(1, m_DistancesPlus.at(0).size(), CV_32F, data_arr);
         data.push_back(curdata);
         size_plus++;
 
     }
 
     for ( unsigned int i=m_DistancesPlus.size(); i<m_DistancesPlus.size()+m_DistancesMinus.size(); i++)
     {
         int it = i - size_plus;
         float data_arr [m_DistancesMinus.at(0).size()];
 //        labels_arr[i]=0;
         labels_arr_vec.push_back(0);
 
          for ( unsigned int j=0; j<m_DistancesMinus.at(0).cols(); j++)
         {
             data_arr[j] = m_DistancesMinus.at(it).get(0,j);
         }
         cv::Mat curdata(1, m_DistancesPlus.at(0).size(), CV_32F, data_arr);
         data.push_back(curdata);
 
     }
     MITK_INFO << data.cols;
     MITK_INFO << data.rows;
 
     /*Calculate weights*/
     int zerosgt = labels_arr_vec.rows - cv::countNonZero(labels_arr_vec);
     int onesgt = cv::countNonZero(labels_arr_vec);
     float plusval = labels_arr_vec.rows / (2.0 * onesgt );
     float minusval = labels_arr_vec.rows / (2.0 * zerosgt );
-    cv::Mat newweight;
-    newweight.push_back(minusval);
-    newweight.push_back(plusval);
+    float w[2] = {minusval, plusval};
+//    newweight(2,1,CV_32F);
+//    newweight.push_back(minusval);
+//    newweight.push_back(plusval);
+    cv::Mat newweight = cv::Mat(1,2, CV_32F, w);
+//    newweight.at<float>(1,1)=minusval;
+//    newweight.at<float>(1,2)=plusval;
     MITK_INFO << "Weights";
+    MITK_INFO << minusval;
+    MITK_INFO << plusval;
     MITK_INFO << newweight;
 
 
     /*Shuffle Data*/
     std::vector <int> seeds;
     for (int cont = 0; cont < labels_arr_vec.rows; cont++)
     {
         seeds.push_back(cont);
     }
 
     cv::randShuffle(seeds);
     cv::Mat labels_shuffled;
     cv::Mat samples_shuffled;
     for (int cont = 0; cont < labels_arr_vec.rows; cont++)
     {
         labels_shuffled.push_back(labels_arr_vec.row(seeds[cont]));
     }
 
     for (int cont = 0; cont < labels_arr_vec.rows; cont++)
     {
         samples_shuffled.push_back(data.row(seeds[cont]));
     }
 
 
 
 //    std::ofstream myfile1;
 //    myfile1.open("/home/r948e/mycsv/labels.csv");
 //    myfile1<< cv::format(labels_shuffled, cv::Formatter::FMT_CSV) << std::endl;
 //    myfile1.close();
 
 //    std::ofstream myfile2;
 //    myfile2.open("/home/r948e/mycsv/features.csv");
 //    myfile2<< cv::format(data, cv::Formatter::FMT_CSV) << std::endl;
 //    myfile2.close();
 
 
 
 
     /*Create Dataset and initialize Classifier*/
     cv::Ptr<cv::ml::TrainData> m_traindata = cv::ml::TrainData::create(samples_shuffled, cv::ml::ROW_SAMPLE, labels_shuffled);
-    MITK_INFO << m_traindata->getSamples();
+//    MITK_INFO << m_traindata->getSamples();
 //    m_traindata->setTrainTestSplitRatio(0.95, true);
-    MITK_INFO << m_traindata->getResponses();
+//    MITK_INFO << m_traindata->getResponses();
 //    m_traindata->shuffleTrainTest();
-    MITK_INFO << m_traindata->getClassLabels();
+//    MITK_INFO << m_traindata->getClassLabels();
 
     MITK_INFO << "Start Training";
 
     auto statistic_model = cv::ml::RTrees::create();
 
     auto criteria = cv::TermCriteria();
     criteria.type = cv::TermCriteria::MAX_ITER;
 //    criteria.epsilon = 1e-8;
     criteria.maxCount = 800;
 
     statistic_model->setMaxDepth(50); //set to three
 //    statistic_model->setMinSampleCount(m_traindata->getNTrainSamples()*0.01);
     statistic_model->setMinSampleCount(2);
     statistic_model->setTruncatePrunedTree(false);
     statistic_model->setUse1SERule(false);
     statistic_model->setUseSurrogates(false);
     statistic_model->setTermCriteria(criteria);
     statistic_model->setCVFolds(1);
     statistic_model->setPriors(newweight);
 
 
     /*Train Classifier*/
     statistic_model->train(m_traindata);
 
 
 
     /*Predict on Test Data*/
     MITK_INFO << "Predicting";
 
     /*Create Dataset as cv::Mat*/
     cv::Mat dataTest;
     for ( unsigned int i=0; i<m_DistancesTest.size(); i++)
     {
         float data_arr [m_DistancesTest.at(0).size()];
 
         for ( unsigned int j=0; j<m_DistancesTest.at(0).cols(); j++)
         {
             data_arr[j] = m_DistancesTest.at(i).get(0,j);
         }
         cv::Mat curdata(1, m_DistancesTest.at(0).size(), CV_32F, data_arr);
         dataTest.push_back(curdata);
     }
 
 
     std::vector<unsigned int> indexPrediction;
     std::vector<float> e(m_DistancesTest.size());
 
 
     /*For every Sample/Streamline get Prediction and entropy (=based on counts of Random Forest)*/
 #pragma omp parallel for num_threads(18)
     for (unsigned int i=0; i<m_DistancesTest.size(); i++)
     {
 
 
         int val = statistic_model->predict(dataTest.row(i));
         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;
         }
 
     }
 
     /*Save entropy values for analysis*/
     std::ofstream myfile3;
     auto s = std::to_string(m_activeCycle);
     myfile3.open("/home/r948e/mycsv/entropydata" + s + ".csv");
 
     for (unsigned int i = 0; i < e.size(); i++)
     {
         myfile3 << e.at(i) << ' ';
     }
     myfile3.close();
 
 
     MITK_INFO << "--------------";
     MITK_INFO << "Prediction vector size:";
     MITK_INFO << indexPrediction.size();
     MITK_INFO << "Entropy vector size:";
     MITK_INFO << e.size();
 
     MITK_INFO << "--------------";
 
     /*Get index of most unertain data (lengths defines how many data is saved)*/
 
-    int lengths=1000;
+    int lengths=500;
 //    auto it = std::minmax_element(e.begin(), e.end());
 //    int min_idx = std::distance(e.begin(), it.first);
 //    int max_idx = std::distance(e.begin(), it.second);
 
     std::vector<unsigned int> indexUnc;
     std::priority_queue<std::pair<float, int>> q;
     for (unsigned int i = 0; i < e.size(); ++i)
     {
         q.push(std::pair<float, int>(e[i], i));
     }
 
 //    auto lengths = std::count_if(e.begin(), e.end(),[&](auto const& val){ return val >= 0.9; });
     MITK_INFO << "Streamlines with uncertainty higher than 0.9";
     MITK_INFO << lengths;
 
     for (int i = 0; i < lengths; ++i)
     {
         int ki = q.top().second;
         indexUnc.push_back(ki);
         q.pop();
     }
 
 //    std::ofstream myfile4;
 //    myfile4.open("/home/r948e/mycsv/indexUnc.csv");
 //    for (unsigned int i = 0; i < indexUnc.size(); i++)
 //    {
 //        myfile4 << indexUnc.at(i) << ' ';
 //    }
 //    myfile4.close();
 
-    // Sorted depent on entropy now sort the 1/5
+    // Sorted depends on entropy now sort the 1/5
     vnl_matrix<float> distances_matrix;
 
     distances_matrix.set_size(lengths, lengths);
     distances_matrix.fill(0.0);
     MITK_INFO << "Dist_start";
 
     std::vector<float> distances_matrix_mean;
 
 
     for (int i=0; i<lengths; i++)
     {
         for (int k=0; k<lengths; k++)
         {
+            /*From the length.size() Samples with the highest Entropey calculate the differen between the Features*/
             vnl_matrix<float> diff =  m_DistancesTest.at(indexUnc.at(i)) - m_DistancesTest.at(indexUnc.at(k));
 
+            /*Into the eucledean difference matrix, put the distance in Feature Space between every sample pair*/
             distances_matrix.put(i,k,diff.absolute_value_sum()/m_DistancesTest.at(0).size());
 
         }
+        /*For every Sample/Streamline get the mean eucledean distance to all other Samples => one value for every Sample*/
         distances_matrix_mean.push_back(distances_matrix.get_row(i).mean());
 //        MITK_INFO << meanval.at(i);
 
     }
 
     vnl_vector<float> sum_matrix;
     sum_matrix.set_size(lengths);
     sum_matrix.fill(0.0);
 
-    /*Index to find values is distancematrix*/
+    /*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);
 
 //    MITK_INFO << distances_matrix.get_row(myidx.at(i)+ sum_matrix.get_row(0)
 
 
     for (int i=0; i<lengths; i++)
     {
 //        unsigned int cur_i = indexUnc.at(myidx.at(i));
+        /*Save mean distance of all used Samples*/
         sum_matrix = (sum_matrix + distances_matrix.get_row(myidx.at(i)))/=(i+1);
 
-//        myidx.push_back(distances_matrix.get_row(myidx.at(i)).arg_max());
-        myidx.push_back(sum_matrix.arg_max());
+        myidx.push_back(distances_matrix.get_row(myidx.at(i)).arg_max());
+//        myidx.push_back(sum_matrix.arg_max());
         indexUncDist.push_back(indexUnc.at(myidx.at(i)));
+//        distances_matrix.set_column(myidx.at(i), 0.0001);
         distances_matrix.set_column(myidx.at(i), 0.0001);
+        sum_matrix.put(myidx.at(i), 0.0001);
+//        MITK_INFO<< sum_matrix;
 
     }
 
     std::vector<unsigned int> indexUncdist;
     std::priority_queue<std::pair<float, int>> qq;
     for (unsigned int i = 0; i < distances_matrix_mean.size(); ++i)
     {
         qq.push(std::pair<float, int>(distances_matrix_mean[i], i));
     }
 //    int k = m_DistancesTest.size(); // number of indices we need
 //    int k = lengths; // number of indices we need
     for (int i = 0; i < lengths; ++i)
     {
         int kki = qq.top().second;
 
         indexUncdist.push_back(indexUnc.at(kki));
         qq.pop();
     }
 
     MITK_INFO << "Dist_stop";
 
 //    std::ofstream myfile6;
 //    myfile6.open("/home/r948e/mycsv/distances_matrix_mean.csv");
 //    for (unsigned int i = 0; i < distances_matrix_mean.size(); i++)
 //    {
 //        myfile6 << distances_matrix_mean.at(i) << ' ';
 //    }
 //    myfile6.close();
 
 //    std::ofstream myfile5;
 //    myfile5.open("/home/r948e/mycsv/indexUncdist.csv");
 //    for (unsigned int i = 0; i < indexUncdist.size(); i++)
 //    {
 //        myfile5 << indexUncdist.at(i) << ' ';
 //    }
 //    myfile5.close();
 
 //    MITK_INFO << distances_matrix;
 //    MITK_INFO << distances_matrix.max_value();
 //    MITK_INFO << distances_matrix.arg_max();
 
 
 //    vnl_matrix<float> myx =  m_DistancesTest.at(indexUnc.at(0)) - m_DistancesTest.at(indexUnc.at(1));
 ////    myx = (m_DistancesTest.at(indexUnc.at(0)) - m_DistancesTest.at(indexUnc.at(1)));
 //    MITK_INFO << m_DistancesTest.at(indexUnc.at(0));
 //    MITK_INFO << m_DistancesTest.at(indexUnc.at(1));
 //    MITK_INFO << myx.get(0,0);
 //    MITK_INFO << sqrt(pow(myx.get(0,0),2));
 //    MITK_INFO << myx.get(0,1);
 //    MITK_INFO << myx.absolute_value_sum()/m_DistancesTest.at(0).size();
 //    MITK_INFO << "Done";
 
     /*Save Prediction*/
     index_vec.push_back(indexPrediction);
     /*Save index of uncertainty measures*/
     index_vec.push_back(indexUnc);
     /*Save index of uncertainty measures influenced by distance*/
     index_vec.push_back(indexUncDist);
 
     return index_vec;
 
 }
 
 mitk::FiberBundle::Pointer StreamlineFeatureExtractor::CreatePrediction(std::vector<unsigned int> &index)
 {
 
 
 
     mitk::FiberBundle::Pointer Prediction;
     MITK_INFO << "Create Bundle";
 
     vtkSmartPointer<vtkPolyData> FibersData;
     FibersData = vtkSmartPointer<vtkPolyData>::New();
     FibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
     FibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     unsigned int indexSize = index.size();
     unsigned int counter = 0;
     MITK_INFO << "Start Loop";
     for (unsigned int i=0; i<indexSize; i++)
     {
 
         vtkCell* cell = m_TractogramTest->GetFiberPolyData()->GetCell(index[i]);
         auto numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (unsigned int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         //    weights->InsertValue(counter, fib->GetFiberWeight(i));
         vNewLines->InsertNextCell(container);
         counter++;
 
     }
     MITK_INFO << "Counter";
     MITK_INFO << counter;
 
 
      vNewPolyData->SetLines(vNewLines);
      vNewPolyData->SetPoints(vNewPoints);
 
      FibersData = vtkSmartPointer<vtkPolyData>::New();
      FibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
      FibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
      FibersData->SetPoints(vNewPoints);
      FibersData->SetLines(vNewLines);
 
      Prediction = mitk::FiberBundle::New(vNewPolyData);
 
 //     Bundle->SetFiberColors(255, 255, 255);
     MITK_INFO << "Cells Prediciton";
     MITK_INFO << Prediction->GetFiberPolyData()->GetNumberOfCells();
     MITK_INFO << "Cells Tractorgram";
     MITK_INFO << m_TractogramTest->GetFiberPolyData()->GetNumberOfCells();
 
     return Prediction;
 }
 
 void  StreamlineFeatureExtractor::GenerateData()
 {
     MITK_INFO << "Update";
-    mitk::FiberBundle::Pointer inputPrototypes = mitk::IOUtil::Load<mitk::FiberBundle>("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/prototypes_599671.trk");
-
+//    mitk::FiberBundle::Pointer inputPrototypes = mitk::IOUtil::Load<mitk::FiberBundle>("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/mitk_diff/prototypes_599671.trk");
+    mitk::FiberBundle::Pointer inputPrototypes = mitk::IOUtil::Load<mitk::FiberBundle>("/home/r948e/E132-Projekte/Projects/2022_Peretzke_Interactive_Fiber_Dissection/data/Synt_tract_40_prototypes.trk");
     T_Prototypes = ResampleFibers(inputPrototypes);
     T_TractogramMinus= ResampleFibers(m_TractogramMinus);
     T_TractogramPlus= ResampleFibers(m_TractogramPlus);
 
 
     MITK_INFO << "Calculate Features";
     m_DistancesMinus = CalculateDmdf(T_TractogramMinus, T_Prototypes, T_TractogramPlus, T_TractogramMinus);
     m_DistancesPlus = CalculateDmdf(T_TractogramPlus, T_Prototypes, T_TractogramPlus, T_TractogramMinus);
 
 
 
 
     std::ifstream f(m_DistancesTestName);
 
     MITK_INFO << m_DistancesTestName;
     if (f.good())
     {
         MITK_INFO << "File exists";
         m_DistancesTest.clear();
         std::ifstream myFile(m_DistancesTestName);
 
         if(!myFile.is_open()) throw std::runtime_error("Could not open file");
         std::string line;
         vnl_matrix<float> curline;
         curline.set_size(1, m_DistancesPlus.at(0).cols());
         curline.fill(0.0);
 
         float val;
 
         while(std::getline(myFile, line))
             {
                 // Create a stringstream of the current line
                 std::stringstream ss(line);
 //                MITK_INFO << ss;
 
                 // Keep track of the current column index
                 int colIdx = 0;
 
                 // Extract each integer
                 while(ss >> val){
 
 //                    // Add the current integer to the 'colIdx' column's values vector
                     curline.put(0,colIdx, val);
 
 //                    // If the next token is a comma, ignore it and move on
 //                    if(ss.peek() == ',') ss.ignore();
 //                    // Increment the column index
                     colIdx++;
                 }
                 m_DistancesTest.push_back(curline);
             }
 
             // Close file
             myFile.close();
     }
     else
     {
         MITK_INFO << m_DistancesTestName;
         MITK_INFO << "Resample Test Data";
         T_TractogramTest= ResampleFibers(m_TractogramTest);
         MITK_INFO << "Calculate Features of Test Data";
         m_DistancesTest= CalculateDmdf(T_TractogramTest, T_Prototypes, T_TractogramPlus, T_TractogramMinus);
 
 //        std::ofstream myFile(m_DistancesTestName);
 ////        myFile << colname << "\n";
 //        for(long unsigned int i = 0; i < m_DistancesTest.size(); ++i)
 //        {
 //            myFile << m_DistancesTest.at(i);
 //        }
 //        myFile.close();
     }
     MITK_INFO << m_DistancesTest.size();
 
 
     MITK_INFO << "Sizes of Plus and Minus";
     MITK_INFO << m_DistancesPlus.size() + m_DistancesMinus.size();
     MITK_INFO << "Size of Test Data";
     MITK_INFO << m_DistancesTest.size();
     MITK_INFO << "Done with Datacreation";
     m_index =GetData();
 
 }
 
 
 
 }
 
 
 
 
diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
index 7cde2ef..85f8e88 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
@@ -1,106 +1,108 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef StreamlineFeatureExtractor_h
 #define StreamlineFeatureExtractor_h
 
 
 #include "MitkFiberDissectionExports.h"
 // MITK
 #include <mitkPlanarEllipse.h>
 #include <mitkFiberBundle.h>
 
 // ITK
 #include <itkProcessObject.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 // OpenCV
 #include <opencv2/ml.hpp>
 #include <opencv2/opencv.hpp>
 #include <opencv2/highgui/highgui.hpp>
 
 namespace mitk{
 
 /**
 * \brief    */
 
 class MITKFIBERDISSECTION_EXPORT StreamlineFeatureExtractor      
 {
 public:
 
 
   StreamlineFeatureExtractor();
   ~StreamlineFeatureExtractor();
 
   typedef itk::Image< float, 3 >                              FloatImageType;
   typedef itk::Image< unsigned char, 3 >                      UcharImageType;
 
   void Update(){
     this->GenerateData();
   }
 
   void SetTractogramPlus(const mitk::FiberBundle::Pointer &Tractogram);
   void SetTractogramMinus(const mitk::FiberBundle::Pointer &Tractogram);
   void SetTractogramTest(const mitk::FiberBundle::Pointer &Tractogram, std::string TractogramTestName);
   void SetActiveCycle(int &activeCycle);
+//  void SetRandomThreshold(int &threshold);
 
 
   void CreateClassifier();
   std::vector<std::vector<unsigned int>>  GetData();
 
 //  void CreatePrediction(std::vector<unsigned int> &index);
   mitk::FiberBundle::Pointer CreatePrediction(std::vector<unsigned int> &index);
 
   mitk::FiberBundle::Pointer                  m_Prediction;
   mitk::FiberBundle::Pointer                  m_ToLabel;
 
   std::vector<std::vector<unsigned int>>      m_index;
 
 
 protected:
 
   void GenerateData();
   std::vector< vnl_matrix<float> > ResampleFibers(FiberBundle::Pointer tractogram);
   std::vector<vnl_matrix<float> > CalculateDmdf(std::vector<vnl_matrix<float> > tractogram,
                                                 std::vector<vnl_matrix<float> > prototypes,
                                                 std::vector<vnl_matrix<float> > positive_local_prototypes,
                                                 std::vector<vnl_matrix<float> > negative_local_prototypes);
 
 
 
   unsigned int                                m_NumPoints;
   int                                         m_activeCycle;
+  int                                         m_thresh;
   mitk::FiberBundle::Pointer                  m_TractogramPlus;
   mitk::FiberBundle::Pointer                  m_TractogramMinus;
   mitk::FiberBundle::Pointer                  m_TractogramTest;
   std::string                                 m_DistancesTestName;
   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> >             m_DistancesPlus;
   std::vector<vnl_matrix<float> >             m_DistancesMinus;
   std::vector<vnl_matrix<float> >             m_DistancesTest;
   cv::Ptr<cv::ml::TrainData>                  m_traindata;
 };
 }
 
 #endif
diff --git a/Modules/FiberDissection/resource/Interactions/Streamline3DConfig.xml b/Modules/FiberDissection/resource/Interactions/Streamline3DConfig.xml
index d852e6a..84399f3 100644
--- a/Modules/FiberDissection/resource/Interactions/Streamline3DConfig.xml
+++ b/Modules/FiberDissection/resource/Interactions/Streamline3DConfig.xml
@@ -1,18 +1,18 @@
 <config>
     <event_variant class="MousePressEvent" name="AddNegStreamlineClick">
          <attribute name="EventButton" value="RightMouseButton"/>
          <attribute name="Modifiers" value="shift"/>
     </event_variant>addtolabelstreamline
     <event_variant class="MousePressEvent" name="AddPosStreamlineClick">
          <attribute name="EventButton" value="RightMouseButton"/>
          <attribute name="Modifiers" value="alt"/>
     </event_variant>
     <event_variant class="MousePressEvent" name="AddNegStreamlinetolabelClick">
-         <attribute name="EventButton" value="RightMouseButton"/>
-         <attribute name="Modifiers" value="shift,ctrl"/>
+         <attribute name="EventButton" value="LeftMouseButton"/>
+         <attribute name="Modifiers" value="shift"/>
     </event_variant>
     <event_variant class="MousePressEvent" name="AddPosStreamlinetolabelClick">
-         <attribute name="EventButton" value="RightMouseButton"/>
-         <attribute name="Modifiers" value="alt,ctrl"/>
+         <attribute name="EventButton" value="LeftMouseButton"/>
+         <attribute name="Modifiers" value="alt"/>
     </event_variant>
 </config>
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 09e1173..9dde4b2 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,869 +1,869 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchPart.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkInteractiveFiberDissectionView.h"
 #include <QmitkRenderWindow.h> //Pointset
 #include <QmitkPointListWidget.h> //Pointset
 
 #include <QMessageBox>
 
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 //#include <mitkStreamlineFeatureExtractor.h>
 
 #include <mitkInteractionConst.h>
 #include "usModuleRegistry.h"
 //#include <itkFiberCurvatureFilter.h>
 
 
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 #include <itkFiberExtractionFilter.h>
 
 #include <mitkInteractionEventObserver.h>
 #include <vtkCellPicker.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <vnl/vnl_sparse_matrix.h>
 
 const std::string QmitkInteractiveFiberDissectionView::VIEW_ID = "org.mitk.views.interactivefiberdissection";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkInteractiveFiberDissectionView::QmitkInteractiveFiberDissectionView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_IterationCounter(0)
   , m_RandomExtractionCounter(0)
   , m_activeCycleCounter(0)
   , m_StreamlineInteractor(nullptr)
 {
 
 }
 
 // Destructor
 QmitkInteractiveFiberDissectionView::~QmitkInteractiveFiberDissectionView()
 {
   //disable interactor
   if (m_StreamlineInteractor != nullptr)
   {
 //    m_StreamlineInteractor->SetStreamlineNode(nullptr);
     m_StreamlineInteractor->EnableInteraction(false);
   }
 }
 
 
 void QmitkInteractiveFiberDissectionView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkInteractiveFiberDissectionViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_selectedPointSetWidget->SetDataStorage(GetDataStorage());//pointset
     m_Controls->m_selectedPointSetWidget->SetNodePredicate(mitk::NodePredicateAnd::New(//pointset
       mitk::TNodePredicateDataType<mitk::PointSet>::New(),//pointset
       mitk::NodePredicateNot::New(mitk::NodePredicateOr::New(//pointset
         mitk::NodePredicateProperty::New("helper object"),//pointset
         mitk::NodePredicateProperty::New("hidden object")))));//pointset
 
     m_Controls->m_selectedPointSetWidget->SetSelectionIsOptional(true);//pointset
     m_Controls->m_selectedPointSetWidget->SetAutoSelectNewNodes(true);//pointset
     m_Controls->m_selectedPointSetWidget->SetEmptyInfo(QString("Please select a point set"));//pointset
     m_Controls->m_selectedPointSetWidget->SetPopUpTitel(QString("Select point set"));//pointsett
 
 //    m_Controls->m_trainbundleWidget->SetDataStorage(GetDataStorage());//testdata
 //    m_Controls->m_trainbundleWidget->SetNodePredicate(mitk::NodePredicateAnd::New(//testdata
 //      mitk::TNodePredicateDataType<mitk::FiberBundle>::New(),//testdata
 //      mitk::NodePredicateNot::New(mitk::NodePredicateOr::New(//testdata
 //        mitk::NodePredicateProperty::New("helper object"),//testdata
 //        mitk::NodePredicateProperty::New("hidden object")))));//testdatat
 
 //    m_Controls->m_trainbundleWidget->SetSelectionIsOptional(true);//testdata
 //    m_Controls->m_trainbundleWidget->SetAutoSelectNewNodes(true);//testdat
 //    m_Controls->m_trainbundleWidget->SetEmptyInfo(QString("Please select a tractogram"));//testdat
 //    m_Controls->m_trainbundleWidget->SetPopUpTitel(QString("Select tractogram"));//testdat
 
 
     connect(m_Controls->m_ErazorButton, SIGNAL(toggled(bool)), this, SLOT( RemovefromBundle(bool) ) ); //need
 
     connect(m_Controls->m_StreamlineCreation, SIGNAL( clicked() ), this, SLOT( CreateStreamline()));
 
     connect(m_Controls->m_AddRandomFibers, SIGNAL( clicked() ), this, SLOT( ExtractRandomFibersFromTractogram() ) ); //need
 
     connect(m_Controls->m_TrainClassifier, SIGNAL( clicked() ), this, SLOT( StartAlgorithm( )));
 
     connect(m_Controls->m_CreatePrediction, SIGNAL( clicked() ), this, SLOT( CreatePredictionNode( )));
 
     connect(m_Controls->m_AddUncertainFibers, SIGNAL( clicked() ), this, SLOT( CreateUncertaintySampleNode( )));
 
     connect(m_Controls->m_AddDistanceFibers, SIGNAL( clicked() ), this, SLOT( CreateDistanceSampleNode( )));
 
     connect(m_Controls->m_unclabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromUncertainty(bool) ) ); //need
 
     connect(m_Controls->m_distlabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromDistance(bool) ) ); //need
 
     connect(m_Controls->m_predlabeling, SIGNAL(toggled(bool)), this, SLOT( RemovefromPrediction(bool) ) ); //need
 
 
 
     connect(m_Controls->m_addPointSetPushButton, &QPushButton::clicked,//pointset
       this, &QmitkInteractiveFiberDissectionView::OnAddPointSetClicked);//pointset
     connect(m_Controls->m_selectedPointSetWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,//pointset
       this, &QmitkInteractiveFiberDissectionView::OnCurrentSelectionChanged);//pointset
 
 
 
 
     auto renderWindowPart = this->GetRenderWindowPart();//pointset
     if (nullptr != renderWindowPart)//pointset
       this->RenderWindowPartActivated(renderWindowPart);//pointset
     this->OnCurrentSelectionChanged(m_Controls->m_selectedPointSetWidget->GetSelectedNodes());//pointset
 
   }
 
   UpdateGui();
 }
 
 
 void QmitkInteractiveFiberDissectionView::SetFocus()
 {
   m_Controls->toolBoxx->setFocus();
   //m_Controls->m_addPointSetPushButton->setFocus();//pointset
 }
 
 void QmitkInteractiveFiberDissectionView::UpdateGui()
 {
   m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
   m_Controls->m_InputData->setTitle("Please Select Input Data");
 
    // disable alle frames
 
   m_Controls->m_ErazorButton->setCheckable(true);
   m_Controls->m_ErazorButton->setEnabled(false);
   m_Controls->m_unclabeling->setCheckable(true);
   m_Controls->m_unclabeling->setEnabled(false);
   m_Controls->m_predlabeling->setCheckable(true);
   m_Controls->m_predlabeling->setEnabled(false);
   m_Controls->m_distlabeling->setCheckable(true);
   m_Controls->m_distlabeling->setEnabled(false);
 
 
 
   m_Controls->m_addPointSetPushButton->setEnabled(false);
   m_Controls->m_StreamlineCreation->setEnabled(false);
   m_Controls->m_TrainClassifier->setEnabled(false);
   m_Controls->m_CreatePrediction->setEnabled(false);
   m_Controls->m_CreateUncertantyMap->setEnabled(false);
   m_Controls->m_Numtolabel->setEnabled(false);
   m_Controls->m_Numtolabel2->setEnabled(false);
   m_Controls->m_addPointSetPushButton->setEnabled(false);
   m_Controls->m_AddRandomFibers->setEnabled(false);
   m_Controls->m_AddDistanceFibers->setEnabled(false);
   m_Controls->m_AddUncertainFibers->setEnabled(false);
   m_Controls->m_unclabeling->setEnabled(false);
   m_Controls->m_predlabeling->setEnabled(false);
   m_Controls->m_distlabeling->setEnabled(false);
 
   bool fibSelected = !m_SelectedFB.empty();
   bool multipleFibsSelected = (m_SelectedFB.size()>1);
   bool sthSelected = m_SelectedImageNode.IsNotNull();
   bool psSelected = m_SelectedPS.IsNotNull();
 //  bool nfibSelected = !m_newfibersSelectedBundles.empty();
 //  bool posSelected = !m_positivBundlesNode.empty();
   bool nfibSelected = m_newfibersSelectedBundles.IsNotNull();
 //  bool posSelected = !m_positivBundlesNode.IsNotNull();
 //  bool negSelected = !m_negativeSelectedBundles.IsNotNull();
     bool posSelected = this->GetDataStorage()->Exists(m_positivBundlesNode);
     bool negSelected = this->GetDataStorage()->Exists(m_negativeSelectedBundles);
     bool indexSelected = !m_index.empty();
     bool uncertaintySelected = this->GetDataStorage()->Exists(m_UncertaintyLabelNode);
     bool distanceSelected = this->GetDataStorage()->Exists(m_DistanceLabelNode);
     bool predictionSelected = this->GetDataStorage()->Exists(m_PredictionNode);
 
 
 
   // toggle visibility of elements according to selected method
 
 
   // are fiber bundles selected?
   if ( fibSelected )
   {
     m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
     m_Controls->m_addPointSetPushButton->setEnabled(true);
     m_Controls->m_AddRandomFibers->setEnabled(true);
 
 
 
     // more than two bundles needed to join/subtract
     if (multipleFibsSelected)
     {
       m_Controls->m_FibLabel->setText("multiple bundles selected");
     }
 
 
 
   }
 
 
   // is image selected
   if (sthSelected)
   {
     m_Controls->m_addPointSetPushButton->setEnabled(true);
   }
 
   if (psSelected)
   {
       m_Controls->m_StreamlineCreation->setEnabled(true);
   }
 
   if (nfibSelected && posSelected)
   {
       m_Controls->m_ErazorButton->setEnabled(true);
   }
 
 
   if (posSelected && negSelected)
   {
       m_Controls->m_TrainClassifier->setEnabled(true);
   }
 
   if (indexSelected)
   {
       m_Controls->m_CreatePrediction->setEnabled(true);
       m_Controls->m_AddUncertainFibers->setEnabled(true);
       m_Controls->m_Numtolabel->setEnabled(true);
       m_Controls->m_AddDistanceFibers->setEnabled(true);
       m_Controls->m_Numtolabel2->setEnabled(true);
   }
 
   if (uncertaintySelected)
   {
       m_Controls->m_unclabeling->setEnabled(true);
   }
 
   if (predictionSelected)
   {
       m_Controls->m_predlabeling->setEnabled(true);
   }
 
   if (distanceSelected)
   {
       m_Controls->m_distlabeling->setEnabled(true);
   }
 
 
 
 
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::OnEndInteraction()
 {
 
 }
 
 void QmitkInteractiveFiberDissectionView::OnAddPointSetClicked()//pointset
 {
   // ask for the name of the point set
   bool ok = false;
   QString name = QInputDialog::getText(QApplication::activeWindow(),
     tr("Add point set..."), tr("Enter name for the new point set"), QLineEdit::Normal, tr("PointSet").arg(++m_IterationCounter), &ok);
 //  QString name = "PointSet";
   if (!ok || name.isEmpty())
   {
     return;
   }
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   pointSetNode->SetData(pointSet);
   pointSetNode->SetProperty("name", mitk::StringProperty::New(name.toStdString()));
   pointSetNode->SetProperty("opacity", mitk::FloatProperty::New(1));
   pointSetNode->SetColor(1.0, 1.0, 0.0);
   this->GetDataStorage()->Add(pointSetNode, m_SelectedImageNode);
 
 
   m_Controls->m_selectedPointSetWidget->SetCurrentSelectedNode(pointSetNode);
 }
 
 void QmitkInteractiveFiberDissectionView::OnCurrentSelectionChanged(QmitkSingleNodeSelectionWidget::NodeList /*nodes*/)//pointset
 {
 
   m_Controls->m_poinSetListWidget->SetPointSetNode(m_Controls->m_selectedPointSetWidget->GetSelectedNode());
   m_SelectedPS = m_Controls->m_selectedPointSetWidget->GetSelectedNode();
 
 //  m_Controls->m_trainbundleWidget->SetPointSetNode(m_Controls->m_trainbundleWidget->GetSelectedNode());
 //  m_trainbundle = m_Controls->m_trainbundleWidget->GetSelectedNode();
 
 
   UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
 
     m_SelectedFB.clear();
 
     if (nodes.empty() || nodes.front().IsNull())
     {
       m_SelectedImageNode = nullptr;
     }
     else
     {
       m_SelectedImageNode = nodes.front();
     }
 
 
 
     for (auto node: nodes)
     {
       if (dynamic_cast<mitk::Image*>(node->GetData()))
           m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
       else if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
           m_SelectedFB.push_back(node);
     }
 
 
 
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)//pointset
 {
   if (nullptr != m_Controls)
   {
     m_Controls->m_poinSetListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->AddSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
   }
 }
 
 void QmitkInteractiveFiberDissectionView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)//pointset
 {
   if (nullptr != m_Controls)
   {
     m_Controls->m_poinSetListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     m_Controls->m_poinSetListWidget->RemoveSliceNavigationController(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
   }
 }
 
 void QmitkInteractiveFiberDissectionView::CreateStreamline()
 {
 
     if (m_positivBundlesNode.IsNull())
     {
         mitk::DataNode::Pointer node = mitk::DataNode::New();
 
         m_positiveFibersData = vtkSmartPointer<vtkPolyData>::New();
         m_positiveFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
         m_positiveFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
         m_positiveBundle = mitk::FiberBundle:: New(m_positiveFibersData);
 
         node->SetData( m_positiveBundle );
         m_positivBundlesNode = node;
         this->GetDataStorage()->Add(m_positivBundlesNode);
       MITK_INFO << "Create Bundle";
     }
 
     if (!m_positivBundlesNode.IsNull())
     {
 
         this->GetDataStorage()->Remove(m_positivBundlesNode);
         MITK_INFO << "Adding fibers";
         MITK_INFO << m_positiveBundle->GetFiberPolyData()->GetNumberOfCells();
         m_positiveFibersData = m_positiveBundle->GetFiberPolyData();
     }
 
 
 
 
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
 
 
     unsigned int counter = 0;
     for (unsigned int i=0; i<m_positiveFibersData->GetNumberOfCells(); ++i)
     {
       MITK_INFO<< "New Line";
       vtkCell* cell = m_positiveFibersData->GetCell(i);
       auto numPoints = cell->GetNumberOfPoints();
       vtkPoints* points = cell->GetPoints();
 
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
       for (unsigned int j=0; j<numPoints; ++j)
       {
         double p[3];
         points->GetPoint(j, p);
 
         vtkIdType id = vNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
 
       vNewLines->InsertNextCell(container);
       counter++;
     }
 
     mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(m_SelectedPS->GetData());
 
 
     vnl_matrix<float> streamline;
     streamline.set_size(3, pointSet->GetSize());
     streamline.fill(0.0);
 
 
     mitk::PointSet::PointsIterator begin = pointSet->Begin();
     mitk::PointSet::PointsIterator end = pointSet->End();
     unsigned int i;
     mitk::PointSet::PointsContainer::Iterator it;
 
     for (it = begin, i = 0; it != end; ++it, ++i)
     {
         PointSet::PointType pt = pointSet->GetPoint(it->Index());
         vnl_vector_fixed< float, 3 > candV;
         candV[0]=pt[0]; candV[1]=pt[1]; candV[2]=pt[2];
         streamline.set_column(i, candV);
     }
 
       // build Fiber
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
 
       for (unsigned int j=0; j<streamline.cols(); j++)
       {
         double p[3];
         p[0] = streamline.get(0,j);
         p[1] = streamline.get(1,j);
         p[2] = streamline.get(2,j);
 
         vtkIdType id = vNewPoints->InsertNextPoint(p);
         container->GetPointIds()->InsertNextId(id);
       }
       MITK_INFO<< "Last Line from current pointset";
       vNewLines->InsertNextCell(container);
 
       vNewPolyData->SetPoints(vNewPoints);
       vNewPolyData->SetLines(vNewLines);
 
       m_positiveFibersData = vtkSmartPointer<vtkPolyData>::New();
       m_positiveFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
       m_positiveFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
       m_positiveFibersData->SetPoints(vNewPoints);
       m_positiveFibersData->SetLines(vNewLines);
 
       m_positiveBundle = mitk::FiberBundle::New(vNewPolyData);
 //      m_positiveBundle->SetTrackVisHeader(dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetData())->GetGeometry());
       m_positiveBundle->SetFiberColors(0, 255, 0);
 
 
 
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(m_positiveBundle);
       node->SetName("+Bundle");
       m_positivBundlesNode= node;
 
 
 
 
       MITK_INFO << "The + Bundle has Streamlines:";
       auto m_NegStreamline= dynamic_cast<mitk::FiberBundle *>(m_positivBundlesNode->GetData());
       MITK_INFO << m_NegStreamline->GetFiberPolyData()->GetNumberOfCells();
 
       this->GetDataStorage()->Add(m_positivBundlesNode);
 //      m_Controls->m_selectedPointSetWidget->m_ToggleAddPoint->setEnabled(false);
 
       UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::ExtractRandomFibersFromTractogram()
 {
     m_SelectedFB.at(0)->SetVisibility(false);
     m_Controls->m_ErazorButton->setChecked(false);
 
 
      MITK_INFO << "Number of Fibers to extract from Tractogram: ";
      MITK_INFO << m_Controls->m_NumRandomFibers->value();
      if (this->GetDataStorage()->Exists(m_newfibersSelectedBundles))
      {
          MITK_INFO << "To Label Bundle Exists";
          mitk::FiberBundle::Pointer Stack = dynamic_cast<mitk::FiberBundle *>(m_newfibersSelectedBundles->GetData());
          this->GetDataStorage()->Remove(m_newfibersSelectedBundles);
 
          mitk::DataNode::Pointer node = mitk::DataNode::New();
 
          m_newfibersFibersData = vtkSmartPointer<vtkPolyData>::New();
          m_newfibersFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
          m_newfibersBundle = mitk::FiberBundle:: New(m_newfibersFibersData);
          m_newfibersFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
 
 //         node->SetData( m_newfibersBundle );
 //         m_newfibersSelectedBundles = node ;
 
        MITK_INFO << "Create Bundle";
      }
 
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
 //      mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle *>(m_trainbundle->GetData());
 
       vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
        /* Check weather all Streamlines of the bundles are labeled... If all are labeled Skip for Loop*/
       unsigned int counter = 0;
       int thresh1;
       int thresh2;
       thresh2 = m_Controls->m_NumRandomFibers->value()*(m_RandomExtractionCounter+1);
       thresh1 = m_Controls->m_NumRandomFibers->value()*(m_RandomExtractionCounter);
       if (thresh1>fib->GetFiberPolyData()->GetNumberOfCells())
       {
           thresh1=fib->GetFiberPolyData()->GetNumberOfCells();
       }
       if (thresh2>fib->GetFiberPolyData()->GetNumberOfCells())
       {
           thresh2=fib->GetFiberPolyData()->GetNumberOfCells();
       }
 
       if (thresh1!=fib->GetFiberPolyData()->GetNumberOfCells())
       {
       for ( int i=thresh1; i<thresh2; i++)
       {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
         auto numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (unsigned int j=0; j<numPoints; j++)
         {
           double p[3];
           points->GetPoint(j, p);
 
           vtkIdType id = vNewPoints->InsertNextPoint(p);
           container->GetPointIds()->InsertNextId(id);
         }
     //    weights->InsertValue(counter, fib->GetFiberWeight(i));
         vNewLines->InsertNextCell(container);
         counter++;
 
       }
 
 
 
       vNewPolyData->SetLines(vNewLines);
       vNewPolyData->SetPoints(vNewPoints);
 
       m_newfibersFibersData = vtkSmartPointer<vtkPolyData>::New();
       m_newfibersFibersData->SetPoints(vtkSmartPointer<vtkPoints>::New());
       m_newfibersFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
       m_newfibersFibersData->SetPoints(vNewPoints);
       m_newfibersFibersData->SetLines(vNewLines);
 
       m_newfibersBundle = mitk::FiberBundle::New(vNewPolyData);
       m_newfibersBundle->SetFiberColors(255, 255, 255);
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(m_newfibersBundle);
       node->SetName("ToLabel");
       m_newfibersSelectedBundles = node;
 
 //      MITK_INFO << "Number of Streamlines in first function";
 //      MITK_INFO << m_newfibersSelectedBundles->GetData()->GetFiberPolyData()->GetNumberOfCells();
       this->GetDataStorage()->Add(m_newfibersSelectedBundles);
       m_RandomExtractionCounter++;
       }
 
     UpdateGui();
 
 
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromBundle( bool checked )
 {
     if (checked)
     {
 
         if (m_StreamlineInteractor.IsNull())
         {
             this->CreateStreamlineInteractor();
 //            if (m_negativeSelectedBundles.IsNull())
 //            {
                 mitk::FiberBundle::Pointer m_negativeBundle = mitk::FiberBundle::New();
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetName("-Bundle");
                 node->SetData(m_negativeBundle);
                 m_negativeSelectedBundles = node;
                 this->GetDataStorage()->Add(m_negativeSelectedBundles);
 //            }
 
 //            if (m_positivBundlesNode.IsNull())
 //            {
 
 //                mitk::FiberBundle::Pointer m_positiveBundle = mitk::FiberBundle::New();
 //                mitk::DataNode::Pointer m_positiveSelectedBundles = mitk::DataNode::New();
 //                m_positiveSelectedBundles->SetName("+Bundle");
 //                m_positiveSelectedBundles->SetData(m_positiveBundle);
 //                this->GetDataStorage()->Add(m_positiveSelectedBundles);)
 //            }
 
             m_StreamlineInteractor->EnableInteraction(true);
             m_StreamlineInteractor->SetNegativeNode(m_negativeSelectedBundles);
             m_StreamlineInteractor->SetPositiveNode(m_positivBundlesNode);
             m_StreamlineInteractor->SetToLabelNode(m_newfibersSelectedBundles);
         }
         else
         {
             m_StreamlineInteractor->EnableInteraction(true);
             m_StreamlineInteractor->SetPositiveNode(m_positivBundlesNode);
 //            MITK_INFO << "Number of Streamlines";
 //            MITK_INFO << m_newfibersSelectedBundles->GetData()->GetFiberPolyData()->GetNumberOfCells();
             m_StreamlineInteractor->SetToLabelNode(m_newfibersSelectedBundles);
         }
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
 
 
 
 
 
 
 
 
    UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateStreamlineInteractor()
 {
 
     m_StreamlineInteractor = mitk::StreamlineInteractor::New();
 
     m_StreamlineInteractor->LoadStateMachine("Streamline3DStates.xml", us::ModuleRegistry::GetModule("MitkFiberDissection"));
     m_StreamlineInteractor->SetEventConfig("Streamline3DConfig.xml", us::ModuleRegistry::GetModule("MitkFiberDissection"));
 
 //  m_StreamlineInteractor->SetRotationEnabled(rotationEnabled);
 }
 
 void QmitkInteractiveFiberDissectionView::StartAlgorithm()
 {
 
     this->GetDataStorage()->Remove(m_UncertaintyLabelNode);
     this->GetDataStorage()->Remove(m_DistanceLabelNode);
 
     m_Controls->m_unclabeling->setChecked(false);
     m_Controls->m_distlabeling->setChecked(false);
     m_Controls->m_predlabeling->setChecked(false);
 
     clusterer.reset();
     MITK_INFO << "Extract Features";
     m_negativeBundle = dynamic_cast<mitk::FiberBundle*>(m_negativeSelectedBundles->GetData());
     clusterer = std::make_shared<mitk::StreamlineFeatureExtractor>();
     clusterer->SetTractogramPlus(m_positiveBundle);
     clusterer->SetActiveCycle(m_activeCycleCounter);
     clusterer->SetTractogramMinus(m_negativeBundle);
     clusterer->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData()), m_SelectedFB.at(0)->GetName());
 //    clusterer->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_trainbundle->GetData()), m_trainbundle->GetName());
 
 
 //    m_distances = clusterer->get
 
     clusterer->Update();
 
     m_index = clusterer->m_index;
     MITK_INFO << "Number of Cycles";
     MITK_INFO << m_activeCycleCounter;
     m_activeCycleCounter += 1;
 
 //    m_Prediction = clusterer->CreatePrediction(m_index.at(0));
 //    mitk::DataNode::Pointer node = mitk::DataNode::New();
 //    node->SetData(m_Prediction);
 //    node->SetName("Prediction");
 //    m_PredictionNode = node;
 //    this->GetDataStorage()->Add(m_PredictionNode);
 
 
 
 
 //    m_UncertaintyLabel = clusterer->m_UncertaintyLabel;
 //    mitk::DataNode::Pointer node2 = mitk::DataNode::New();
 //    node2->SetData(m_UncertaintyLabel);
 //    node2->SetName("UncertaintyLabels");
 //    m_UncertaintyLabelNode = node2;
 
 //      MITK_INFO << "Number of Streamlines in first function";
 //      MITK_INFO << m_newfibersSelectedBundles->GetData()->GetFiberPolyData()->GetNumberOfCells();
 //    this->GetDataStorage()->Add(m_UncertaintyLabelNode);
 //    this->GetDataStorage()->Add(m_PredictionNode);
 
 //    clusterer->GetData();
 //    MITK_INFO << data.at(0);
 //    MITK_INFO << data.at(1);
 //    cv::Ptr<cv::ml::TrainData> m_traindata = clusterer->GetData();
 //    MITK_INFO << clusterer->m_labels;
 //    MITK_INFO << data.at(1);
 //    MITK_INFO << "Start Classification";
 //    clusterer->CreateClassifier();
 //     cv::Mat curdata = clusterer->StartAlgorithm();
 //     MITK_INFO << curdata;
 
 
 
     MITK_INFO << "Algorithm run succesfully";
 
     m_Controls->m_CreatePrediction->setEnabled(true);
     UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::CreatePredictionNode()
 {
     MITK_INFO << "Create Prediction";
 
     m_Prediction = clusterer->CreatePrediction(m_index.at(0));
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_Prediction);
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("Prediction"+s);
     m_PredictionNode = node;
     this->GetDataStorage()->Add(m_PredictionNode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateUncertaintySampleNode()
 {
      MITK_INFO << "Create Fibers to label based on Uncertainty";
 
      std::vector<unsigned int> myvec = m_index.at(1);
      myvec.resize(m_Controls->m_Numtolabel->value());
      MITK_INFO << m_index.at(1).size();
      MITK_INFO << myvec.size();
 
 
     m_UncertaintyLabel = clusterer->CreatePrediction(myvec);
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_UncertaintyLabel);
 
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("UncertaintyLabel"+s);
     m_UncertaintyLabelNode = node;
     this->GetDataStorage()->Add(m_UncertaintyLabelNode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::CreateDistanceSampleNode()
 {
      MITK_INFO << "Create Fibers to label based on Distance in Features-Space";
      std::vector<unsigned int> myvec = m_index.at(2);
      myvec.resize(m_Controls->m_Numtolabel2->value());
      MITK_INFO << m_index.at(2).size();
      MITK_INFO << myvec.size();
 
 
     m_DistanceLabel = clusterer->CreatePrediction(myvec);
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(m_DistanceLabel);
     auto s = std::to_string(m_activeCycleCounter);
     node->SetName("DistanceLabel"+s);
     m_DistanceLabelNode = node;
     this->GetDataStorage()->Add(m_DistanceLabelNode);
     UpdateGui();
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromUncertainty( bool checked )
 {
     if (checked)
     {
 
         m_UncertaintyLabel->SetFiberColors(255, 255, 255);
         m_StreamlineInteractor->EnableInteraction(true);
         m_StreamlineInteractor->SetToLabelNode(m_UncertaintyLabelNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveFiberDissectionView::RemovefromDistance( bool checked )
 {
     if (checked)
     {
 
         m_DistanceLabel->SetFiberColors(255, 255, 255);
         m_StreamlineInteractor->EnableInteraction(true);
         m_StreamlineInteractor->SetToLabelNode(m_DistanceLabelNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkInteractiveFiberDissectionView::RemovefromPrediction( bool checked )
 {
     if (checked)
     {
 
-        m_Prediction->SetFiberColors(255, 255, 255);
+//        m_Prediction->SetFiberColors(255, 255, 255);
         m_StreamlineInteractor->EnableInteraction(true);
         m_StreamlineInteractor->SetToLabelNode(m_PredictionNode);
     }
     else
     {
       m_StreamlineInteractor->EnableInteraction(false);
 //      m_StreamlineInteractor = nullptr;
     }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.h
index e482df4..3eb0f7c 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,157 +1,158 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 
 #ifndef QmitkInteractiveFiberDissectionView_h
 #define QmitkInteractiveFiberDissectionView_h
 #include "ui_QmitkInteractiveFiberDissectionViewControls.h"
 
 #include <QInputDialog> //Pointset
 #include <QmitkPointListWidget.h>//Pointset
 
 #include <QmitkAbstractView.h>//Pointset
 #include <QmitkSingleNodeSelectionWidget.h>//Pointset
 
 
 #include <mitkFiberBundle.h>
 #include <mitkDataInteractor.h>
 #include <mitkIRenderWindowPartListener.h> //Pointset
 #include <mitkStreamlineInteractor.h>
 #include <mitkStreamlineFeatureExtractor.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 #include <vtkCellPicker.h>
 
 /*!
 \brief View to process fiber bundles. Supplies methods to extract fibers from the bundle, fiber resampling, mirroring, join and subtract bundles and much more.
 */
 class QmitkInteractiveFiberDissectionView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   typedef itk::Image< unsigned char, 3 >    ItkUCharImageType;
   typedef itk::Image< float, 3 >            ItkFloatImageType;
 
   static const std::string VIEW_ID;
 
   QmitkInteractiveFiberDissectionView();
   virtual ~QmitkInteractiveFiberDissectionView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Sets the focus to an internal widget.
   ///
   virtual void SetFocus() override;
 
 protected slots:
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override; //Pointset
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override; //Pointset
   void OnAddPointSetClicked();//Pointset
   void CreateStreamline();
   void RemovefromBundle( bool checked );
   void ExtractRandomFibersFromTractogram();
   void StartAlgorithm();
   void CreatePredictionNode();
   void CreateUncertaintySampleNode();
   void CreateDistanceSampleNode();
   void RemovefromUncertainty( bool checked );
   void RemovefromDistance( bool checked );
   void RemovefromPrediction( bool checked );
 
 
 
 
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
 
 
 
 
 protected:
   void OnCurrentSelectionChanged(QmitkSingleNodeSelectionWidget::NodeList nodes);//Pointset
 
 
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   void OnEndInteraction();
   void CreateStreamlineInteractor();
 
   Ui::QmitkInteractiveFiberDissectionViewControls* m_Controls;
 
 
 
   int m_IterationCounter;                                      ///< used for data node naming
   int m_RandomExtractionCounter;                               ///< used for random extracton of different Streamlines
   int m_activeCycleCounter;
+//  int m_thresh2;
 
 
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
 //  mitk::DataNode::Pointer              m_trainbundle;
   mitk::Image::Pointer                  m_SelectedImage;
   mitk::DataNode::Pointer               m_SelectedPS;
   mitk::DataNode::Pointer               m_SelectedImageNode;
   mitk::FiberBundle::Pointer            m_positiveBundle;
   mitk::FiberBundle::Pointer            m_newfibersBundle;
   mitk::FiberBundle::Pointer            m_negativeBundle;
   mitk::FiberBundle::Pointer            m_Prediction;
   mitk::FiberBundle::Pointer            m_UncertaintyLabel;
   mitk::FiberBundle::Pointer            m_DistanceLabel;
 
 
   mitk::DataNode::Pointer               m_positivBundlesNode;
   mitk::DataNode::Pointer               m_newfibersSelectedBundles;
   mitk::DataNode::Pointer               m_negativeSelectedBundles;
   mitk::DataNode::Pointer               m_PredictionNode;
   mitk::DataNode::Pointer               m_UncertaintyLabelNode;
   mitk::DataNode::Pointer               m_DistanceLabelNode;
 
   vtkSmartPointer<vtkPolyData>          m_positiveFibersData;
   vtkSmartPointer<vtkPolyData>          m_newfibersFibersData;
 
   vtkSmartPointer<vtkCellPicker>        m_picker1;
   mitk::StreamlineInteractor::Pointer   m_StreamlineInteractor;
 
   std::shared_ptr< mitk::StreamlineFeatureExtractor > clusterer;
 
   std::vector<std::vector<unsigned int>> m_index;
 
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui
index 4be3a22..5a210c4 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionViewControls.ui
@@ -1,683 +1,739 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkInteractiveFiberDissectionViewControls</class>
  <widget class="QWidget" name="QmitkInteractiveFiberDissectionViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>417</width>
     <height>711</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <property name="styleSheet">
    <string>QCommandLinkButton:disabled {
   border: none;
 }
 
 QGroupBox {
   background-color: transparent;
 }</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_3">
    <property name="leftMargin">
     <number>9</number>
    </property>
    <property name="topMargin">
     <number>9</number>
    </property>
    <property name="rightMargin">
     <number>9</number>
    </property>
    <property name="bottomMargin">
     <number>9</number>
    </property>
    <item row="1" column="0">
     <widget class="QToolBox" name="toolBoxx">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="font">
       <font>
        <bold>true</bold>
       </font>
      </property>
      <property name="toolTip">
       <string>Label Fibers</string>
      </property>
      <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="currentIndex">
-      <number>2</number>
+      <number>0</number>
      </property>
      <property name="tabSpacing">
       <number>6</number>
      </property>
+     <widget class="QWidget" name="page">
+      <attribute name="label">
+       <string>Generate Prototypes</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_5">
+       <item row="0" column="0">
+        <widget class="QLabel" name="inputImageOneLabel">
+         <property name="text">
+          <string>Extract from</string>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="0">
+        <widget class="QPushButton" name="pushButton_3">
+         <property name="text">
+          <string>SFF Extraction</string>
+         </property>
+        </widget>
+       </item>
+       <item row="3" column="0">
+        <widget class="QPushButton" name="pushButton_2">
+         <property name="text">
+          <string>PushButton</string>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="0">
+        <widget class="QPushButton" name="m_random">
+         <property name="text">
+          <string>Random Extraction</string>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1">
+        <widget class="QmitkDataStorageComboBox" name="m_NetworkBox"/>
+       </item>
+       <item row="4" column="0">
+        <spacer name="verticalSpacer_5">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
      <widget class="QWidget" name="page_3">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>399</width>
-        <height>464</height>
+        <height>455</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Fiber Creation</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_7">
        <item row="0" column="0">
         <widget class="QFrame" name="frame">
          <property name="frameShape">
           <enum>QFrame::StyledPanel</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_11">
           <item row="0" column="0">
            <widget class="QLabel" name="m_selectedPointSetLabel">
             <property name="text">
              <string>Selected Streamline Pointset</string>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <spacer name="horizontalSpacer_14">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="4" column="0" colspan="2">
            <widget class="QGroupBox" name="groupBox">
             <property name="title">
              <string>Streamline Points</string>
             </property>
             <layout class="QGridLayout" name="gridLayout_10">
              <item row="0" column="0">
               <widget class="QmitkPointListWidget" name="m_poinSetListWidget" native="true"/>
              </item>
              <item row="1" column="0">
               <spacer name="verticalSpacer_7">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>40</height>
                 </size>
                </property>
               </spacer>
              </item>
             </layout>
            </widget>
           </item>
           <item row="1" column="1">
            <spacer name="horizontalSpacer_13">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="0" column="1">
            <spacer name="horizontalSpacer_12">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="0">
            <widget class="QPushButton" name="m_addPointSetPushButton">
             <property name="text">
              <string>Add new Streamline Pointset</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QmitkSingleNodeSelectionWidget" name="m_selectedPointSetWidget" native="true">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimumSize">
              <size>
               <width>0</width>
               <height>40</height>
              </size>
             </property>
            </widget>
           </item>
           <item row="6" column="0">
            <spacer name="verticalSpacer_3">
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>40</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="7" column="0">
            <widget class="QPushButton" name="m_StreamlineCreation">
             <property name="text">
              <string>Create Streamline</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_2">
       <property name="enabled">
        <bool>true</bool>
       </property>
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>414</width>
-        <height>450</height>
+        <height>441</height>
        </rect>
       </property>
       <property name="accessibleName">
        <string/>
       </property>
       <attribute name="label">
        <string>Fiber Labelling</string>
       </attribute>
       <attribute name="toolTip">
        <string>Dissect/Eraze Fibers by Erasion and Highlighting</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_13">
        <item row="4" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_LabelFrame">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="cursor">
           <cursorShape>ArrowCursor</cursorShape>
          </property>
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_4">
           <item row="0" column="0">
            <widget class="QLabel" name="label">
             <property name="text">
              <string>Label individual Streamlines</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_3">
          <property name="text">
           <string>Streamlines to be labeled</string>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_ExtractionToolsFrame">
          <property name="frameShape">
           <enum>QFrame::StyledPanel</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_2">
           <item row="5" column="2">
            <widget class="QLabel" name="label_4">
             <property name="text">
              <string>Label Streamlines</string>
             </property>
            </widget>
           </item>
           <item row="5" column="3">
            <widget class="QPushButton" name="m_ErazorButton">
             <property name="maximumSize">
              <size>
               <width>30</width>
               <height>30</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="icon">
              <iconset>
               <normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberprocessing/resources/eraze.png</normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberprocessing/resources/eraze.png</iconset>
             </property>
             <property name="iconSize">
              <size>
               <width>32</width>
               <height>32</height>
              </size>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="6" column="2">
            <widget class="QLabel" name="label_6">
             <property name="text">
              <string>Reject: Rightclick + shift</string>
             </property>
            </widget>
           </item>
           <item row="2" column="7" colspan="3">
            <spacer name="horizontalSpacer_2">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="2" colspan="2">
            <widget class="QLabel" name="label_7">
             <property name="text">
              <string>Random Streamlines</string>
             </property>
            </widget>
           </item>
           <item row="7" column="3" colspan="5">
            <spacer name="horizontalSpacer_8">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="5" column="4" colspan="5">
            <spacer name="horizontalSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="6" column="3" colspan="6">
            <spacer name="horizontalSpacer_3">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="6">
            <widget class="QPushButton" name="m_AddRandomFibers">
             <property name="text">
              <string>Add</string>
             </property>
            </widget>
           </item>
           <item row="7" column="2">
            <widget class="QLabel" name="label_8">
             <property name="text">
              <string>Accept: Rightclick + alt</string>
             </property>
            </widget>
           </item>
           <item row="8" column="2">
            <spacer name="verticalSpacer_2">
             <property name="orientation">
              <enum>Qt::Vertical</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>20</width>
               <height>40</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="2" column="4">
            <widget class="QSpinBox" name="m_NumRandomFibers">
             <property name="minimum">
              <number>1</number>
             </property>
             <property name="maximum">
              <number>2000</number>
             </property>
             <property name="value">
              <number>10</number>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_4">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>399</width>
-        <height>464</height>
+        <height>455</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Active Learning</string>
       </attribute>
       <widget class="QFrame" name="frame_2">
        <property name="geometry">
         <rect>
          <x>9</x>
          <y>9</y>
          <width>341</width>
          <height>391</height>
         </rect>
        </property>
        <property name="frameShape">
         <enum>QFrame::StyledPanel</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Raised</enum>
        </property>
        <layout class="QGridLayout" name="gridLayout_6">
-        <item row="0" column="0" colspan="3">
-         <widget class="QPushButton" name="m_TrainClassifier">
-          <property name="text">
-           <string>Train Classifier</string>
+        <item row="3" column="1">
+         <widget class="QSpinBox" name="m_Numtolabel">
+          <property name="minimum">
+           <number>1</number>
+          </property>
+          <property name="maximum">
+           <number>500</number>
+          </property>
+          <property name="singleStep">
+           <number>0</number>
+          </property>
+          <property name="value">
+           <number>10</number>
           </property>
          </widget>
         </item>
-        <item row="1" column="3">
-         <spacer name="horizontalSpacer_5">
+        <item row="2" column="3">
+         <spacer name="horizontalSpacer_7">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
-        <item row="5" column="1">
-         <widget class="QPushButton" name="m_predlabeling">
-          <property name="text">
-           <string>Pred_Label</string>
-          </property>
-         </widget>
-        </item>
         <item row="5" column="0">
          <widget class="QPushButton" name="m_unclabeling">
           <property name="text">
            <string>Uncertainty_Label</string>
           </property>
           <property name="icon">
            <iconset theme="eraze.png">
             <normaloff>.</normaloff>.</iconset>
           </property>
          </widget>
         </item>
-        <item row="1" column="0" colspan="3">
-         <widget class="QPushButton" name="m_CreatePrediction">
-          <property name="text">
-           <string>Create Prediction</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="3">
-         <spacer name="horizontalSpacer_4">
+        <item row="1" column="3">
+         <spacer name="horizontalSpacer_5">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
-            <width>84</width>
-            <height>22</height>
+            <width>40</width>
+            <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
-        <item row="3" column="3">
-         <spacer name="horizontalSpacer_6">
+        <item row="3" column="2">
+         <widget class="QPushButton" name="m_AddUncertainFibers">
+          <property name="text">
+           <string>Add </string>
+          </property>
+         </widget>
+        </item>
+        <item row="5" column="1">
+         <widget class="QPushButton" name="m_predlabeling">
+          <property name="text">
+           <string>Pred_Label</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="3">
+         <spacer name="horizontalSpacer_4">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
-            <width>40</width>
-            <height>20</height>
+            <width>84</width>
+            <height>22</height>
            </size>
           </property>
          </spacer>
         </item>
-        <item row="5" column="2">
-         <widget class="QPushButton" name="m_distlabeling">
+        <item row="4" column="0">
+         <widget class="QLabel" name="label_9">
           <property name="text">
-           <string>Unc_dis_Label</string>
+           <string>Dist: to label</string>
           </property>
          </widget>
         </item>
-        <item row="2" column="0" colspan="3">
-         <widget class="QPushButton" name="m_CreateUncertantyMap">
+        <item row="1" column="0" colspan="3">
+         <widget class="QPushButton" name="m_CreatePrediction">
           <property name="text">
-           <string>Create Uncertanty Map</string>
+           <string>Create Prediction</string>
           </property>
          </widget>
         </item>
         <item row="7" column="2">
          <spacer name="verticalSpacer_6">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>40</height>
            </size>
           </property>
          </spacer>
         </item>
+        <item row="2" column="0" colspan="3">
+         <widget class="QPushButton" name="m_CreateUncertantyMap">
+          <property name="text">
+           <string>Create Uncertanty Map</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="2">
+         <widget class="QPushButton" name="m_AddDistanceFibers">
+          <property name="text">
+           <string>Add</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="0" colspan="3">
+         <widget class="QPushButton" name="m_TrainClassifier">
+          <property name="text">
+           <string>Train Classifier</string>
+          </property>
+         </widget>
+        </item>
         <item row="3" column="0">
          <widget class="QLabel" name="label_5">
           <property name="text">
            <string>Unc: to label</string>
           </property>
          </widget>
         </item>
-        <item row="3" column="1">
-         <widget class="QSpinBox" name="m_Numtolabel">
+        <item row="4" column="1">
+         <widget class="QSpinBox" name="m_Numtolabel2">
           <property name="minimum">
            <number>1</number>
           </property>
           <property name="maximum">
            <number>500</number>
           </property>
-          <property name="singleStep">
-           <number>0</number>
-          </property>
           <property name="value">
            <number>10</number>
           </property>
          </widget>
         </item>
-        <item row="2" column="3">
-         <spacer name="horizontalSpacer_7">
+        <item row="3" column="3">
+         <spacer name="horizontalSpacer_6">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
-        <item row="3" column="2">
-         <widget class="QPushButton" name="m_AddUncertainFibers">
-          <property name="text">
-           <string>Add </string>
-          </property>
-         </widget>
-        </item>
-        <item row="4" column="0">
-         <widget class="QLabel" name="label_9">
-          <property name="text">
-           <string>Dist: to label</string>
-          </property>
-         </widget>
-        </item>
-        <item row="4" column="1">
-         <widget class="QSpinBox" name="m_Numtolabel2">
-          <property name="minimum">
-           <number>1</number>
-          </property>
-          <property name="maximum">
-           <number>500</number>
-          </property>
-          <property name="value">
-           <number>10</number>
-          </property>
-         </widget>
-        </item>
-        <item row="4" column="2">
-         <widget class="QPushButton" name="m_AddDistanceFibers">
+        <item row="5" column="2">
+         <widget class="QPushButton" name="m_distlabeling">
           <property name="text">
-           <string>Add</string>
+           <string>Unc_dis_Label</string>
           </property>
          </widget>
         </item>
        </layout>
       </widget>
      </widget>
     </widget>
    </item>
    <item row="2" column="0" rowspan="2">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="0" column="0">
     <widget class="QGroupBox" name="m_InputData">
      <property name="title">
       <string>Please Select Input Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
        <widget class="QLabel" name="label_2">
         <property name="toolTip">
          <string>Input DTI</string>
         </property>
         <property name="text">
          <string>Fiber Bundle:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="m_FibLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSingleNodeSelectionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkPointListWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkPointListWidget.h</header>
   </customwidget>
+  <customwidget>
+   <class>QmitkDataStorageComboBox</class>
+   <extends>QComboBox</extends>
+   <header location="global">QmitkDataStorageComboBox.h</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>