diff --git a/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp b/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp
index 32f2de0..bcf7c4a 100644
--- a/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp
+++ b/Modules/FiberDissection/Interactor/mitkStreamlineInteractor.cpp
@@ -1,344 +1,322 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkStreamlineInteractor.h"
 //#include "mitkStreamlineMapper2D.h"
 
 // MITK includes
 #include <mitkInteractionConst.h>
 #include <mitkInteractionPositionEvent.h>
 #include <mitkInternalEvent.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkOperationEvent.h>
 #include <mitkRotationOperation.h>
 #include <mitkScaleOperation.h>
 #include <mitkSurface.h>
 #include <mitkUndoController.h>
 #include <mitkVtkMapper.h>
 
 // VTK includes
 #include <vtkCamera.h>
 #include <vtkInteractorObserver.h>
 #include <vtkInteractorStyle.h>
 #include <vtkMath.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkVector.h>
 #include <vtkPolyLine.h>
 #include <vtkVectorOperators.h>
 
 mitk::StreamlineInteractor::StreamlineInteractor()
 {
     m_ColorForHighlight[0] = 1.0;
     m_ColorForHighlight[1] = 0.5;
     m_ColorForHighlight[2] = 0.0;
     m_ColorForHighlight[3] = 1.0;
 
     // TODO if we want to get this configurable, the this is the recipe:
     // - make the 2D mapper add corresponding properties to control "enabled" and "color"
     // - make the interactor evaluate those properties
     // - in an ideal world, modify the state machine on the fly and skip mouse move handling
 }
 
 mitk::StreamlineInteractor::~StreamlineInteractor()
 {
 }
 
 void mitk::StreamlineInteractor::ConnectActionsAndFunctions()
 {
 //  CONNECT_CONDITION("isoverstreamline", HasPickedHandle);
   CONNECT_FUNCTION("addnegstreamline", AddStreamlineNegBundle);
   CONNECT_FUNCTION("addposstreamline", AddStreamlinePosBundle);
 //  CONNECT_FUNCTION("FeedUndoStack", FeedUndoStack);
 }
 
 void mitk::StreamlineInteractor::SetNegativeNode(DataNode *node)
 {
 
-  DataInteractor::SetDataNode(node);
-
-  m_NegStreamline= dynamic_cast<mitk::FiberBundle *>(node->GetData());
-  MITK_INFO << "Negative Node added";
+    DataInteractor::SetDataNode(node);
+    m_NegStreamline= dynamic_cast<mitk::FiberBundle *>(node->GetData());
+    MITK_INFO << "Negative Node added";
 }
 
 void mitk::StreamlineInteractor::SetToLabelNode(DataNode *node)
 {
     DataInteractor::SetDataNode(node);
-
-  if (node && node->GetData())
-  {
     m_manStreamline = dynamic_cast<mitk::FiberBundle *>(node->GetData());
     MITK_INFO << "Label node added";
-  }
+
 }
 
 void mitk::StreamlineInteractor::SetPositiveNode(DataNode *node)
 {
 
     DataInteractor::SetDataNode(node);
     m_PosStreamline= dynamic_cast<mitk::FiberBundle *>(node->GetData());
-
-
     MITK_INFO << "Positive Node added";
   }
 
 void mitk::StreamlineInteractor::AddStreamlinePosBundle(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     MITK_INFO << "PositiveBundle clicked";
-//     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
-//     if (positionEvent == nullptr)
-//     {
-//       return;
-//     }
-//    return true;
+
     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent == nullptr)
     {
         MITK_INFO << "no position";
     }
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
 //      m_PickedHandle = PickFrom2D(positionEvent);
         MITK_INFO << "2D";
     }
     else
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
-        if (picker == nullptr)
-        {
+//        if (picker == nullptr)
+//        {
+
 
 
           picker = vtkSmartPointer<vtkCellPicker>::New();
           picker->SetTolerance(0.01);
           auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
-        }
+//        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
-//        MITK_INFO << displayPosition;
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
         vtkIdType pickedCellID = picker->GetCellId();
 
-        MITK_INFO << picker->GetCellId();
-        MITK_INFO << "Number of Cells";
-//        MITK_INFO << m_PosStreamline->GetFiberPolyData()->GetNumberOfCells();
-
 
 
         if (picker->GetCellId()==-1)
         {
             MITK_INFO << "Nothing picked";
         }
         else {
 
 
             vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
-            MITK_INFO << vNewPolyData->GetNumberOfLines ();
             vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             unsigned int counter = 0;
             for ( int i=0; i<m_PosStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
               vtkCell* cell = m_PosStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned int j=0; j<numPoints; j++)
               {
                 double p[3];
                 points->GetPoint(j, p);
 
                 vtkIdType id = vNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
               }
           //    weights->InsertValue(counter, fib->GetFiberWeight(i));
               vNewLines->InsertNextCell(container);
               counter++;
 
             }
 
 
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(pickedCellID);
+
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
 
             vNewPolyData->SetPoints(vNewPoints);
             vNewPolyData->SetLines(vNewLines);
 
     //        m_PosStreamline = mitk::FiberBundle::New(vNewPolyData);
             m_PosStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
             m_PosStreamline->GetFiberPolyData()->SetLines(vNewLines);
             m_PosStreamline->SetFiberColors(0, 255, 0);
 
             m_manStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
             m_manStreamline->GetFiberPolyData()->RemoveDeletedCells();
-
-            MITK_INFO << m_manStreamline->GetFiberPolyData()->GetNumberOfCells();
-            MITK_INFO << m_PosStreamline->GetFiberPolyData()->GetNumberOfCells();
         }
     }
   }
 
 void mitk::StreamlineInteractor::AddStreamlineNegBundle(StateMachineAction *, InteractionEvent *interactionEvent)
 {
     MITK_INFO << "NegativeBundle clicked";
 //     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
 //     if (positionEvent == nullptr)
 //     {
 //       return;
 //     }
 //    return true;
     auto positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
     if (positionEvent == nullptr)
     {
         MITK_INFO << "no position";
     }
 
     if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D)
     {
 //      m_PickedHandle = PickFrom2D(positionEvent);
         MITK_INFO << "2D";
     }
     else
     {
         BaseRenderer *renderer = positionEvent->GetSender();
 
         auto &picker = m_Picker[renderer];
-        if (picker == nullptr)
-        {
+//        if (picker == nullptr)
+//        {
 
 
           picker = vtkSmartPointer<vtkCellPicker>::New();
           picker->SetTolerance(0.01);
           auto mapper = GetDataNode()->GetMapper(BaseRenderer::Standard3D);
 
 
           auto vtk_mapper = dynamic_cast<VtkMapper *>(mapper);
           if (vtk_mapper)
           { // doing this each time is bizarre
             picker->AddPickList(vtk_mapper->GetVtkProp(renderer));
             picker->PickFromListOn();
           }
-        }
+//        }
 
         auto displayPosition = positionEvent->GetPointerPositionOnScreen();
-//        MITK_INFO << displayPosition;
+
         picker->Pick(displayPosition[0], displayPosition[1], 0, positionEvent->GetSender()->GetVtkRenderer());
 
         vtkIdType pickedCellID = picker->GetCellId();
 
-        MITK_INFO << picker->GetCellId();
 
         if (picker->GetCellId()==-1)
         {
             MITK_INFO << "Nothing picked";
         }
         else
         {
             vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
-            MITK_INFO << vNewPolyData->GetNumberOfLines ();
             vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
             vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             unsigned int counter = 0;
             for ( int i=0; i<m_NegStreamline->GetFiberPolyData()->GetNumberOfCells(); i++)
             {
               vtkCell* cell = m_NegStreamline->GetFiberPolyData()->GetCell(i);
               auto numPoints = cell->GetNumberOfPoints();
               vtkPoints* points = cell->GetPoints();
 
               vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
               for (unsigned int j=0; j<numPoints; j++)
               {
                 double p[3];
                 points->GetPoint(j, p);
 
                 vtkIdType id = vNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
               }
           //    weights->InsertValue(counter, fib->GetFiberWeight(i));
               vNewLines->InsertNextCell(container);
               counter++;
 
             }
 
 
 
             vtkCell* cell = m_manStreamline->GetFiberPolyData()->GetCell(pickedCellID);
             auto numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (unsigned int j=0; j<numPoints; j++)
             {
               double p[3];
               points->GetPoint(j, p);
 
               vtkIdType id = vNewPoints->InsertNextPoint(p);
               container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
 
             vNewPolyData->SetPoints(vNewPoints);
             vNewPolyData->SetLines(vNewLines);
 
     //        m_NegStreamline = mitk::FiberBundle::New(vNewPolyData);
             m_NegStreamline->GetFiberPolyData()->SetPoints(vNewPoints);
             m_NegStreamline->GetFiberPolyData()->SetLines(vNewLines);
             m_NegStreamline->SetFiberColors(255, 0, 0);
 
             m_manStreamline->GetFiberPolyData()->DeleteCell(pickedCellID);
             m_manStreamline->GetFiberPolyData()->RemoveDeletedCells();
 
-            MITK_INFO << m_manStreamline->GetFiberPolyData()->GetNumberOfCells();
-            MITK_INFO << m_NegStreamline->GetFiberPolyData()->GetNumberOfCells();
         }
 
 
 
 
 
 
 
 
 
     }
 
 
 
   }
diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
index 22d0da8..a94d058 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.cpp
@@ -1,279 +1,281 @@
 /*===================================================================
 
 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(20)
 {
 
 }
 
 StreamlineFeatureExtractor::~StreamlineFeatureExtractor()
 {
 
 }
 
 
 
-void StreamlineFeatureExtractor::SetTractogram(const mitk::FiberBundle::Pointer &Tractogram)
+void StreamlineFeatureExtractor::SetTractogramPlus(const mitk::FiberBundle::Pointer &TractogramPlus)
 {
-  m_Tractogram = Tractogram;
+  m_TractogramPlus = TractogramPlus;
+}
+
+
+void StreamlineFeatureExtractor::SetTractogramMinus(const mitk::FiberBundle::Pointer &TractogramMinus)
+{
+  m_TractogramMinus = TractogramMinus;
+}
+
+void StreamlineFeatureExtractor::SetTractogramTest(const mitk::FiberBundle::Pointer &TractogramTest)
+{
+  m_TractogramTest = TractogramTest;
 }
 
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::ResampleFibers(mitk::FiberBundle::Pointer tractogram)
 {
   mitk::FiberBundle::Pointer temp_fib = tractogram->GetDeepCopy();
   temp_fib->ResampleToNumPoints(m_NumPoints);
 
   std::vector< vnl_matrix<float> > out_fib;
 
   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);
   }
 
   return out_fib;
 }
 
 std::vector<vnl_matrix<float> > StreamlineFeatureExtractor::CalculateDmdf(std::vector<vnl_matrix<float> > tractogram, std::vector<vnl_matrix<float> > prototypes)
 {
     std::vector< vnl_matrix<float> >  dist_vec;
-    MITK_INFO << tractogram.size();
-    MITK_INFO << prototypes.size();
-    MITK_INFO << tractogram.at(0).cols();
 
 
     for (unsigned int i=0; i<tractogram.size(); i++)
     {
 
         vnl_matrix<float> distances;
         distances.set_size(1, prototypes.size());
         distances.fill(0.0);
 
 
         for (unsigned int j=0; j<prototypes.size(); j++)
         {
             vnl_matrix<float> single_distances;
             single_distances.set_size(1, tractogram.at(0).cols());
             single_distances.fill(0.0);
             vnl_matrix<float> single_distances_flip;
             single_distances_flip.set_size(1, tractogram.at(0).cols());
             single_distances_flip.fill(0.0);
             for (unsigned int ik=0; ik<tractogram.at(0).cols(); ik++)
             {
                 double cur_dist;
                 double cur_dist_flip;
 
                 cur_dist = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,ik), 2.0) +
                                        pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,ik), 2.0) +
                                        pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,ik), 2.0));
-//                cur_dist_flip = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,ik), 2.0) +
-//                                       pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,ik), 2.0) +
-//                                       pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,ik), 2.0));
 
                 cur_dist_flip = sqrt(pow(tractogram.at(i).get(0,ik) - prototypes.at(j).get(0,prototypes.at(0).cols()-(ik+1)), 2.0) +
                                        pow(tractogram.at(i).get(1,ik) - prototypes.at(j).get(1,prototypes.at(0).cols()-(ik+1)), 2.0) +
                                        pow(tractogram.at(i).get(2,ik) - prototypes.at(j).get(2,prototypes.at(0).cols()-(ik+1)), 2.0));
 
                 single_distances.put(0,ik, cur_dist);
                 single_distances_flip.put(0,ik, cur_dist_flip);
 
             }
 
             if (single_distances_flip.mean()> single_distances.mean())
             {
                 distances.put(0,j, single_distances.mean());
             }
             else {
                 distances.put(0,j, single_distances_flip.mean());
             }
 
 
 
         }
         dist_vec.push_back(distances);
     }
-//    MITK_INFO << dist_vec;
+
     return dist_vec;
 }
 
+void StreamlineFeatureExtractor::GetData()
+{
+    MITK_INFO << "Start Function Ged Data";
+    int labels_arr [m_DistancesPlus.size()+m_DistancesMinus.size()];
+    float data_arr [m_DistancesPlus.size()+m_DistancesMinus.size()][m_DistancesPlus.at(0).size()];
+
+
+    int size_plus = 0;
+    for ( unsigned int i=0; i<m_DistancesPlus.size(); i++)
+    {
+        MITK_INFO << "Plus: Print i";
+        MITK_INFO << i;
+        MITK_INFO << "Adding 1";
+        labels_arr[i]=1;
+        for ( unsigned int j=0; j<m_DistancesPlus.at(0).cols(); j++)
+        {
+            data_arr[i][j] = m_DistancesPlus.at(i).get(0,j);
+        }
+        size_plus++;
+    }
+    MITK_INFO << "Positive Labels added";
+    for ( unsigned int i=m_DistancesPlus.size(); i<m_DistancesPlus.size()+m_DistancesMinus.size(); i++)
+    {
+        int it = i - size_plus;
+        MITK_INFO << "Minus: Print i";
+        MITK_INFO << it;
+        labels_arr[i]=0;
+        MITK_INFO << "Adding 0";
+        for ( unsigned int j=0; j<m_DistancesMinus.at(0).cols(); j++)
+        {
+            data_arr[i][j] = m_DistancesMinus.at(it).get(0,j);
+        }
+    }
+    MITK_INFO << "Negavtive Labels added";
+
+
+
+    cv::Mat labels(m_DistancesPlus.size()+m_DistancesMinus.size(), 1, CV_32S, labels_arr);
+    cv::Mat data(m_DistancesPlus.size()+m_DistancesMinus.size(), m_DistancesPlus.at(0).size(), CV_32F, data_arr);
+
+    MITK_INFO << "data";
+    MITK_INFO << data;
+    MITK_INFO << "labels";
+    MITK_INFO << labels;
+    cv::Ptr<cv::ml::TrainData> m_traindata = cv::ml::TrainData::create(data, cv::ml::ROW_SAMPLE, labels);
+
+    cv::Ptr<cv::ml::RTrees> m_rtrees;
+    m_rtrees = cv::ml::RTrees::create();
+    m_rtrees->setMaxDepth(3000);
+    m_rtrees->setMinSampleCount(1);
+    m_rtrees->setUse1SERule(false);
+    m_rtrees->setUseSurrogates(false);
+    m_rtrees->setPriors(cv::Mat());
+    m_rtrees->setCVFolds(1);
+
+    MITK_INFO << "Start Training";
+    m_rtrees->train(m_traindata);
+
+    MITK_INFO << "Predicting";
+//    std::vector<std::vector<float>> test_arr(m_DistancesTest.size(), std::vector<float> (m_DistancesPlus.at(0).size(), 0));
+//    MITK_INFO << "test_arr";
+//    for ( unsigned int i=m_DistancesTest.size(); i<m_DistancesTest.size(); i++)
+//    {
+//        for ( unsigned int j=0; j<m_DistancesTest.at(0).cols(); j++)
+//        {
+//            test_arr[i][j] = m_DistancesTest.at(i).get(0,j);
+//        }
+//    }
+//    cv::Mat dataTest(m_DistancesTest.size(), m_DistancesPlus.at(0).size(), CV_32F);
+//        for ( unsigned int i=m_DistancesTest.size(); i<m_DistancesTest.size(); i++)
+//        {
+//               for ( unsigned int j=0; j<m_DistancesTest.at(0).cols(); j++)
+//                    {
+//                        dataTest[i][j] = m_DistancesTest.at(i).get(0,j);
+//                    }
+//        }
+
+//    int val;
+//    for (int i = 0; i < 20; i++)
+//    {
+//        //val = m_rtrees->predict(testingMat.row(i), predictLabels);
+//        val = std::lround(m_rtrees->predict(dataTest.row(i)));
+//        MITK_INFO << val;
+//    }
+
+
+
+
+
+}
+
+//void StreamlineFeatureExtractor::CreateClassifier()
+//{
+//    MITK_INFO << m_traindata->getResponses();
+
+
+//}
+
 
 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");
 
   T_Prototypes = ResampleFibers(inputPrototypes);
-  T_Tractogram = ResampleFibers(m_Tractogram);
-
-  m_distances = CalculateDmdf(T_Tractogram, T_Prototypes);
-
-  MITK_INFO << m_distances.at(0);
-
-//  if (m_Metrics.empty())
-//  {
-//    mitkThrow() << "No metric selected!";
-//    return;
-//  }
-
-//  T = ResampleFibers(m_Tractogram);
-//  if (T.empty())
-//  {
-//    MITK_INFO << "No fibers in tractogram!";
-//    return;
-//  }
-
-//  std::vector< unsigned int > f_indices;
-//  for (unsigned int i=0; i<T.size(); ++i)
-//    f_indices.push_back(i);
-//  //  std::random_shuffle(f_indices.begin(), f_indices.end());
-
-//  Cluster no_match;
-//  std::vector< Cluster > clusters;
-//  if (m_InCentroids.IsNull())
-//  {
-//    MITK_INFO << "Clustering fibers";
-//    clusters = ClusterStep(f_indices, m_Distances);
-//    MITK_INFO << "Number of clusters: " << clusters.size();
-//    clusters = MergeDuplicateClusters2(clusters);
-//    std::sort(clusters.begin(),clusters.end());
-//  }
-//  else
-//  {
-//    std::vector<vnl_matrix<float> > centroids = ResampleFibers(m_InCentroids);
-//    if (centroids.empty())
-//    {
-//      MITK_INFO << "No fibers in centroid tractogram!";
-//      return;
-//    }
-//    MITK_INFO << "Clustering with input centroids";
-//    clusters = AddToKnownClusters(f_indices, centroids);
-//    no_match = clusters.back();
-//    clusters.pop_back();
-//    MITK_INFO << "Number of clusters: " << clusters.size();
-//    clusters = MergeDuplicateClusters2(clusters);
-//  }
-
-//  MITK_INFO << "Clustering finished";
-//  int max = clusters.size()-1;
-//  if (m_MaxClusters>0 && clusters.size()-1>m_MaxClusters)
-//    max = m_MaxClusters;
-//  m_DiscardedClusters = 0;
-//  for (int i=clusters.size()-1; i>=0; --i)
-//  {
-//    Cluster c = clusters.at(i);
-//    if ( c.n>=(int)m_MinClusterSize && !(m_MaxClusters>0 && clusters.size()-i>m_MaxClusters) )
-//    {
-//      m_OutClusters.push_back(c);
-
-//      vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
-//      vtkSmartPointer<vtkPolyData> pTmp = m_Tractogram->GeneratePolyDataByIds(c.I, weights);
-//      mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
-//      if (max>0)
-//        fib->SetFiberWeights((float)i/max);
-//      m_OutTractograms.push_back(fib);
-//      m_OutFiberIndices.push_back(c.I);
-
-//      // create centroid
-//      vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
-//      vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
-//      vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
-//      vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-//      vnl_matrix<float> centroid_points = c.h / c.n;
-//      for (unsigned int j=0; j<centroid_points.cols(); j++)
-//      {
-//        double p[3];
-//        p[0] = centroid_points.get(0,j);
-//        p[1] = centroid_points.get(1,j);
-//        p[2] = centroid_points.get(2,j);
-
-//        vtkIdType id = vtkNewPoints->InsertNextPoint(p);
-//        container->GetPointIds()->InsertNextId(id);
-//      }
-//      vtkNewCells->InsertNextCell(container);
-//      polyData->SetPoints(vtkNewPoints);
-//      polyData->SetLines(vtkNewCells);
-//      mitk::FiberBundle::Pointer centroid = mitk::FiberBundle::New(polyData);
-//      centroid->SetFiberColors(255, 255, 255);
-//      m_OutCentroids.push_back(centroid);
-//    }
-//    else
-//    {
-//      m_DiscardedClusters++;
-//    }
-//  }
-//  MITK_INFO << "Final number of clusters: " << m_OutTractograms.size() << " (discarded " << m_DiscardedClusters << " clusters)";
+  T_TractogramMinus= ResampleFibers(m_TractogramMinus);
+  T_TractogramPlus= ResampleFibers(m_TractogramPlus);
+  T_TractogramTest= ResampleFibers(m_TractogramTest);
+
+  MITK_INFO << "Calculate Features...";
+  m_DistancesPlus = CalculateDmdf(T_TractogramPlus, T_Prototypes);
+  m_DistancesMinus = CalculateDmdf(T_TractogramMinus, T_Prototypes);
+  m_DistancesTest= CalculateDmdf(T_TractogramTest, T_Prototypes);
+
+  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";
 
-//  int w = 0;
-//  for (auto fib : m_OutTractograms)
-//  {
-//    if (m_OutTractograms.size()>1)
-//    {
-//      fib->SetFiberWeights((float)w/(m_OutTractograms.size()-1));
-//      m_OutCentroids.at(w)->SetFiberWeights((float)w/(m_OutTractograms.size()-1));
-//    }
-//    else
-//    {
-//      fib->SetFiberWeights(1);
-//      m_OutCentroids.at(w)->SetFiberWeights(1);
-//    }
-//    fib->ColorFibersByFiberWeights(false, mitk::LookupTable::JET);
-//    ++w;
-//  }
-
-//  if (no_match.n>0)
-//  {
-//    vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
-//    vtkSmartPointer<vtkPolyData> pTmp = m_Tractogram->GeneratePolyDataByIds(no_match.I, weights);
-//    mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
-//    fib->SetFiberColors(0, 0, 0);
-//    m_OutFiberIndices.push_back(no_match.I);
-//    m_OutTractograms.push_back(fib);
-//  }
 }
 
+
+void StreamlineFeatureExtractor::StartAlgorithm()
+{
+    MITK_INFO << "Printing";
+
+//    MITK_INFO << dataset->getResponses();
+}
+
+
+
 }
 
 
 
 
diff --git a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
index da20707..8ec9816 100644
--- a/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
+++ b/Modules/FiberDissection/MachineLearning/mitkStreamlineFeatureExtractor.h
@@ -1,75 +1,95 @@
 /*===================================================================
 
 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 SetTractogram(const mitk::FiberBundle::Pointer &Tractogram);
+  void SetTractogramPlus(const mitk::FiberBundle::Pointer &Tractogram);
+  void SetTractogramMinus(const mitk::FiberBundle::Pointer &Tractogram);
+
+  void SetTractogramTest(const mitk::FiberBundle::Pointer &Tractogram);
+  void CreateClassifier();
+  void GetData();
+//  void GetData();
+//  cv::Ptr<cv::ml::TrainData> GetData();
 
+  void StartAlgorithm();
 
 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);
 
 
 
   unsigned int                                m_NumPoints;
-  mitk::FiberBundle::Pointer                  m_Tractogram;
+  mitk::FiberBundle::Pointer                  m_TractogramPlus;
+  mitk::FiberBundle::Pointer                  m_TractogramMinus;
+  mitk::FiberBundle::Pointer                  m_TractogramTest;
   std::vector<vnl_matrix<float> >             T_Prototypes;
-  std::vector<vnl_matrix<float> >             T_Tractogram;
-  std::vector<vnl_matrix<float> >             m_distances;
+  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/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkInteractiveFiberDissectionView.cpp
index abf8884..e6648cf 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,593 +1,621 @@
 /*===================================================================
 
 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_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
 
     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_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_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_addPointSetPushButton->setEnabled(false);
   m_Controls->m_AddRandomFibers->setEnabled(false);
   m_Controls->m_AddUncertainFibers->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_positivSelectedBundles.empty();
   bool nfibSelected = m_newfibersSelectedBundles.IsNotNull();
 //  bool posSelected = !m_positivSelectedBundles.IsNotNull();
 //  bool negSelected = !m_negativeSelectedBundles.IsNotNull();
     bool posSelected = this->GetDataStorage()->Exists(m_positivSelectedBundles);
     bool negSelected = this->GetDataStorage()->Exists(m_negativeSelectedBundles);
 
 
 
   // 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)
+  if (nfibSelected && posSelected)
   {
       m_Controls->m_ErazorButton->setEnabled(true);
   }
 
 
   if (posSelected && negSelected)
   {
-      MITK_INFO << "Enable Algortihm";
       m_Controls->m_TrainClassifier->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();
 
   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_positivSelectedBundles.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_positivSelectedBundles = node;
         this->GetDataStorage()->Add(m_positivSelectedBundles);
       MITK_INFO << "Create Bundle";
     }
 
     if (!m_positivSelectedBundles.IsNull())
     {
         this->GetDataStorage()->Remove(m_positivSelectedBundles);
         MITK_INFO << "Adding fibers";
     }
 
 
     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);
     }
 
 
 
 
     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)
     {
       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++;
     }
 
       // 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);
       }
       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_positivSelectedBundles= node;
 
 
 
 
       MITK_INFO << "The + Bundle has Streamlines:";
       auto m_NegStreamline= dynamic_cast<mitk::FiberBundle *>(m_positivSelectedBundles->GetData());
       MITK_INFO << m_NegStreamline->GetFiberPolyData()->GetNumberOfCells();
 
       this->GetDataStorage()->Add(m_positivSelectedBundles);
 
       UpdateGui();
 
 }
 
 void QmitkInteractiveFiberDissectionView::ExtractRandomFibersFromTractogram()
 {
+    m_Controls->m_ErazorButton->setChecked(false);
+
+
      MITK_INFO << "Number of Fibers to extract from Tractogram: ";
      MITK_INFO << m_Controls->m_NumRandomFibers->value();
-     if (m_newfibersSelectedBundles.IsNull())
+     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_newfibersFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
          m_newfibersBundle = mitk::FiberBundle:: New(m_newfibersFibersData);
+         m_newfibersFibersData->SetLines(vtkSmartPointer<vtkCellArray>::New());
 
-         node->SetData( m_newfibersBundle );
-         m_newfibersSelectedBundles = node ;
+//         node->SetData( m_newfibersBundle );
+//         m_newfibersSelectedBundles = node ;
 
        MITK_INFO << "Create Bundle";
      }
 
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
 
       vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
 
       unsigned int counter = 0;
-      for ( int i=0; i<m_Controls->m_NumRandomFibers->value(); i++)
+      for ( int i=m_Controls->m_NumRandomFibers->value()*m_RandomExtractionCounter; i<m_Controls->m_NumRandomFibers->value()*(m_RandomExtractionCounter+1); 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++;
-        MITK_INFO << counter;
-        MITK_INFO << vNewLines;
 
       }
 
 
       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_positivSelectedBundles.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_positivSelectedBundles);
             m_StreamlineInteractor->SetToLabelNode(m_newfibersSelectedBundles);
         }
         else
         {
             m_StreamlineInteractor->EnableInteraction(true);
+//            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()
 {
+//    m_traindata.clear();
+    MITK_INFO << "Extract Features";
+    m_negativeBundle = dynamic_cast<mitk::FiberBundle*>(m_negativeSelectedBundles->GetData());
     std::shared_ptr< mitk::StreamlineFeatureExtractor > clusterer = std::make_shared<mitk::StreamlineFeatureExtractor>();
-    clusterer->SetTractogram(m_positiveBundle);
+    clusterer->SetTractogramPlus(m_positiveBundle);
+    clusterer->SetTractogramMinus(m_negativeBundle);
+    clusterer->SetTractogramTest(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData()));
     clusterer->Update();
+    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();
+    clusterer->StartAlgorithm();
+
+
 
-    MITK_INFO << "HI";
+    MITK_INFO << "Algorithm run succesfully";
 }
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 cb97dd7..0d56cc7 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,141 +1,143 @@
 /*===================================================================
 
 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 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
 
 
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
 
   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::DataNode::Pointer               m_positivSelectedBundles;
   mitk::DataNode::Pointer               m_newfibersSelectedBundles;
   mitk::DataNode::Pointer               m_negativeSelectedBundles;
 
   vtkSmartPointer<vtkPolyData>          m_positiveFibersData;
   vtkSmartPointer<vtkPolyData>          m_newfibersFibersData;
 
   vtkSmartPointer<vtkCellPicker>        m_picker1;
   mitk::StreamlineInteractor::Pointer   m_StreamlineInteractor;
 
 
+
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED