diff --git a/Modules/Classification/CLActiveLearning/src/mitkActiveLearningInteractor.cpp b/Modules/Classification/CLActiveLearning/src/mitkActiveLearningInteractor.cpp
index 230da68305..e17131484f 100644
--- a/Modules/Classification/CLActiveLearning/src/mitkActiveLearningInteractor.cpp
+++ b/Modules/Classification/CLActiveLearning/src/mitkActiveLearningInteractor.cpp
@@ -1,245 +1,208 @@
 
 /*===================================================================
 The Medical Imaging Interaction Toolkit (MITK)
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 ===================================================================*/
 
 #include <mitkActiveLearningInteractor.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkInteractionPositionEvent.h>
 #include <mitkIOUtil.h>
 
 
 // Helper function to get an image from a data node.
 static mitk::LabelSetImage::Pointer GetImage(mitk::DataNode::Pointer dataNode)
 {
     if (dataNode.IsNull())
         mitkThrow();
 
     mitk::LabelSetImage::Pointer image = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
 
     if (image.IsNull())
         mitkThrow();
 
     return image;
 }
 
 // Helper function to get a geometry of an image for a specific time step.
 static mitk::BaseGeometry::Pointer GetGeometry(mitk::LabelSetImage::Pointer image, unsigned int timeStep)
 {
     mitk::TimeGeometry::Pointer timeGeometry = image->GetTimeGeometry();
 
     if (timeGeometry.IsNull())
         mitkThrow();
 
     auto geometry = timeGeometry->GetGeometryForTimeStep(timeStep);
 
     if (geometry.IsNull())
         mitkThrow();
 
     return geometry;
 }
 
 static std::vector<itk::Index<3>> InterpolateIndices(itk::Index<3> startIndex, itk::Index<3> endIndex, mitk::BaseGeometry* geometry)
 {
     std::vector<itk::Index<3>> resultIndices;
     mitk::Point3D startPoint;
     mitk::Point3D endPoint;
     geometry->IndexToWorld(startIndex, startPoint);
     geometry->IndexToWorld(endIndex, endPoint);
     itk::Index<3> indexDelta;
     int indexDeltaInc[3];
     for (int i=0; i<3; i++)
     {
         indexDelta[i] = endIndex[i] - startIndex[i];
         indexDeltaInc[i] = (indexDelta[i] > 0) ? 1 : (indexDelta[i] < 0) ? -1 : 0;
     }
 
     int argm[3] = {0, 1, 2};
     if (abs(indexDelta[1]) > abs(indexDelta[0]))
     {
         argm[0] = 1;
         argm[1] = 0;
     }
     if (abs(indexDelta[2]) > abs(indexDelta[argm[1]]))
     {
         argm[2] = argm[1];
         argm[1] = 2;
     }
     if (abs(indexDelta[2]) > abs(indexDelta[argm[0]]))
     {
         argm[1] = argm[0];
         argm[0] = 2;
     }
 
     double slopes[2];
     slopes[0] = (endPoint[argm[1]] - startPoint[argm[1]]) / (endPoint[argm[0]] - startPoint[argm[0]]);
     slopes[1] = (endPoint[argm[2]] - startPoint[argm[2]]) / sqrt((endPoint[argm[1]] - startPoint[argm[1]]) * (endPoint[argm[1]] - startPoint[argm[1]]) + (endPoint[argm[0]] - startPoint[argm[0]]) * (endPoint[argm[0]] - startPoint[argm[0]]));
     itk::Index<3> currentIndex = startIndex;
     mitk::Point3D currentPoint = startPoint;
 
     while (currentIndex != endIndex)
     {
         currentIndex[argm[0]] += indexDeltaInc[argm[0]];
         geometry->IndexToWorld(currentIndex, currentPoint);
         currentPoint[argm[1]] = startPoint[argm[1]] + slopes[0] * (currentPoint[argm[0]] - startPoint[argm[0]]);
         currentPoint[argm[2]] = startPoint[argm[2]] + slopes[1] * sqrt((currentPoint[argm[1]] - startPoint[argm[1]]) * (currentPoint[argm[1]] - startPoint[argm[1]]) + (currentPoint[argm[0]] - startPoint[argm[0]]) * (currentPoint[argm[0]] - startPoint[argm[0]]));
         geometry->WorldToIndex(currentPoint, currentIndex);
         resultIndices.push_back(currentIndex);
     }
 
     return resultIndices;
 }
 
-//// Helper function to multiplex the actual Paint function call for different
-//// pixel types. As it's cumbersome and ugly, you may want to avoid such
-//// functions by using ITK for the actual painting and use the ITK access
-//// macros like we did for the ActiveLearningFilter.
-//static void Paint(mitk::Image::Pointer image, itk::Index<3> index, unsigned int timeStep)
-//{
-//  switch (image->GetPixelType().GetComponentType())
-//  {
-//  case itk::ImageIOBase::CHAR:
-//    Paint<char>(image, index, timeStep);
-//    break;
-
-//  case itk::ImageIOBase::UCHAR:
-//    Paint<unsigned char>(image, index, timeStep);
-//    break;
-
-//  case itk::ImageIOBase::SHORT:
-//    Paint<short>(image, index, timeStep);
-//    break;
-
-//  case itk::ImageIOBase::USHORT:
-//    Paint<unsigned short>(image, index, timeStep);
-//    break;
-
-//  case itk::ImageIOBase::INT:
-//    Paint<int>(image, index, timeStep);
-//    break;
-
-//  case itk::ImageIOBase::UINT:
-//    Paint<unsigned int>(image, index, timeStep);
-//    break;
-
-//  default:
-//    mitkThrow();
-//  }
-//}
-
 mitk::ActiveLearningInteractor::ActiveLearningInteractor() :
     m_PaintingPixelValue(0)
 {
 }
 
 mitk::ActiveLearningInteractor::~ActiveLearningInteractor()
 {
 }
 
 void mitk::ActiveLearningInteractor::ConnectActionsAndFunctions()
 {
     CONNECT_FUNCTION("paint", Paint)
     CONNECT_FUNCTION("paint_interpolate", PaintInterpolate)
 }
 
 void mitk::ActiveLearningInteractor::DataNodeChanged()
 {
     this->ResetToStartState();
 }
 
 void mitk::ActiveLearningInteractor::Paint(mitk::StateMachineAction* /*action*/, mitk::InteractionEvent* event)
 {
     try
     {
         auto renderer = event->GetSender();
         auto image = GetImage(this->GetDataNode());
         auto timeStep = renderer->GetTimeStep();
         auto geometry = GetGeometry(image, timeStep);
         auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(event);
         auto position = positionEvent->GetPositionInWorld();
 
         if (!geometry->IsInside(position)) return;
 
         // Okay, we're safe. Convert the mouse position to the index of the pixel
         // we're pointing at.
         itk::Index<3> index;
         geometry->WorldToIndex<3>(position, index);
 
         // We don't need to paint over and over again while moving the mouse
         // pointer inside the same pixel. That's especially relevant when operating
         // on zoomed images.
         if (index != m_LastPixelIndex)
         {
             mitk::ImagePixelWriteAccessor<mitk::LabelSetImage::PixelType> writeAccessor(image.GetPointer(), image->GetVolumeData(timeStep));
             writeAccessor.SetPixelByIndexSafe(index, m_PaintingPixelValue);
             image->Modified();
             this->GetDataNode()->Modified();
 
 //            mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
             m_LastPixelIndex = index;
             m_Used = true;
         }
     }
     catch (...)
     {
         return;
     }
 }
 
 void mitk::ActiveLearningInteractor::PaintInterpolate(mitk::StateMachineAction* /*action*/, mitk::InteractionEvent* event)
 {
     try
     {
         auto renderer = event->GetSender();
         auto image = GetImage(this->GetDataNode());
         auto timeStep = renderer->GetTimeStep();
         auto geometry = GetGeometry(image, timeStep);
         auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(event);
         auto position = positionEvent->GetPositionInWorld();
 
         if (!geometry->IsInside(position)) return;
 
         // Okay, we're safe. Convert the mouse position to the index of the pixel
         // we're pointing at.
         itk::Index<3> index;
         geometry->WorldToIndex<3>(position, index);
 
         // We don't need to paint over and over again while moving the mouse
         // pointer inside the same pixel. That's especially relevant when operating
         // on zoomed images.
         if (index != m_LastPixelIndex)
         {
             // And finally...
             mitk::ImagePixelWriteAccessor<mitk::LabelSetImage::PixelType> writeAccessor(image.GetPointer(), image->GetVolumeData(timeStep));
 
             // Paint all points between current and last pixel
             auto indices = InterpolateIndices(m_LastPixelIndex, index, geometry);
             for (auto i : indices)
             {
                 writeAccessor.SetPixelByIndexSafe(i, m_PaintingPixelValue);
             }
 
             image->Modified();
             this->GetDataNode()->Modified();
 
 //            mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
             m_LastPixelIndex = index;
             m_Used = true;
         }
     }
     catch (...)
     {
         return;
     }
 }
diff --git a/Modules/Classification/CLVigraRandomForest/src/Algorithm/itkStructureTensorEigenvalueImageFilter.cpp b/Modules/Classification/CLVigraRandomForest/src/Algorithm/itkStructureTensorEigenvalueImageFilter.cpp
index aaacc7ddc2..5d438d5664 100644
--- a/Modules/Classification/CLVigraRandomForest/src/Algorithm/itkStructureTensorEigenvalueImageFilter.cpp
+++ b/Modules/Classification/CLVigraRandomForest/src/Algorithm/itkStructureTensorEigenvalueImageFilter.cpp
@@ -1,132 +1,133 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef ITKSTRUCTURETENSOREIGENVALUEIMAGEFILTER_CPP
 #define ITKSTRUCTURETENSOREIGENVALUEIMAGEFILTER_CPP
 
 #include <itkStructureTensorEigenvalueImageFilter.h>
 #include <itkImageRegionIterator.h>
 #include <vigra/tensorutilities.hxx>
 #include <vigra/convolution.hxx>
+#include <vigra/multi_array.hxx>
 
 
 template< class TInputImageType, class TOutputImageType, class TMaskImageType>
 void itk::StructureTensorEigenvalueImageFilter<TInputImageType,TOutputImageType, TMaskImageType>::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
   this->GetOutput(0)->SetDirection(this->GetInput()->GetDirection());
   this->GetOutput(0)->SetSpacing(this->GetInput()->GetSpacing());
   this->GetOutput(0)->SetRegions(this->GetInput()->GetLargestPossibleRegion());
   this->GetOutput(0)->Allocate();
 
   this->GetOutput(1)->SetDirection(this->GetInput()->GetDirection());
   this->GetOutput(1)->SetSpacing(this->GetInput()->GetSpacing());
   this->GetOutput(1)->SetRegions(this->GetInput()->GetLargestPossibleRegion());
   this->GetOutput(1)->Allocate();
 
   this->GetOutput(2)->SetDirection(this->GetInput()->GetDirection());
   this->GetOutput(2)->SetSpacing(this->GetInput()->GetSpacing());
   this->GetOutput(2)->SetRegions(this->GetInput()->GetLargestPossibleRegion());
   this->GetOutput(2)->Allocate();
 }
 
 template< class TInputImageType, class TOutputImageType, class TMaskImageType>
 void itk::StructureTensorEigenvalueImageFilter<TInputImageType,TOutputImageType, TMaskImageType>::GenerateData()
 {
 
 
 
   typedef typename TInputImageType::PixelType InputPixelType;
 
   typename TInputImageType::RegionType region = this->GetInput()->GetLargestPossibleRegion();
   unsigned int xdim = region.GetSize(0);
   unsigned int ydim = region.GetSize(1);
   unsigned int zdim = region.GetSize(2);
 
 
 
   vigra::Shape3 shape(xdim,ydim,zdim);
   vigra::MultiArrayView<3, InputPixelType, vigra::StridedArrayTag > input_image_view(
         shape ,
         this->GetInput()->GetBufferPointer());
 
   vigra::MultiArray<3, vigra::TinyVector<InputPixelType, 3> > structuretensor_image(shape);
   vigra::MultiArray<3, vigra::TinyVector<InputPixelType, 3> > eigenvalues_image(shape);
 
 
   for(int i = 0 ; i < zdim; ++i )
   {
     vigra::Shape2 slice_shape(xdim,ydim);
     vigra::MultiArrayView<2, InputPixelType, vigra::StridedArrayTag > input_image_slice_view(
           slice_shape,
           input_image_view.data()+ (i*xdim*ydim));
 
     vigra::MultiArrayView<2, vigra::TinyVector<InputPixelType, 3> > structuretensor_image_slice_view(
           slice_shape,
           structuretensor_image.data() + (i*xdim*ydim));
 
     vigra::structureTensor(input_image_slice_view, structuretensor_image_slice_view, m_InnerScale, m_OuterScale);
 
     vigra::MultiArrayView<2, vigra::TinyVector<InputPixelType, 3> > eigenvalues_image_slice_view(
           slice_shape,
           eigenvalues_image.data() + (i*xdim*ydim));
     vigra::tensorEigenRepresentation(structuretensor_image_slice_view, eigenvalues_image_slice_view);
   }
 
   vigra::MultiArrayView<3, InputPixelType, vigra::StridedArrayTag > ev1_image = eigenvalues_image.bindElementChannel(0);
   vigra::MultiArrayView<3, InputPixelType, vigra::StridedArrayTag > ev2_image = eigenvalues_image.bindElementChannel(1);
   vigra::MultiArrayView<3, InputPixelType, vigra::StridedArrayTag > ev3_image = eigenvalues_image.bindElementChannel(2);
 
   for(unsigned int x = 0 ; x < xdim; ++x)
     for(unsigned int y = 0 ; y < ydim; ++y)
       for(unsigned int z = 0 ; z < zdim; ++z)
       {
         itk::Index<3> indx = {{x,y,z}};
         this->GetOutput(0)->operator [](indx) = ev1_image(x,y,z);
         this->GetOutput(1)->operator [](indx) = ev2_image(x,y,z);
         this->GetOutput(2)->operator [](indx) = ev3_image(x,y,z);
       }
 
 
 }
 
 template< class TInputImageType, class TOutputImageType, class TMaskImageType>
 void itk::StructureTensorEigenvalueImageFilter<TInputImageType,TOutputImageType, TMaskImageType>::SetImageMask(TMaskImageType *maskimage)
 {
   this->m_ImageMask = maskimage;
 }
 
 template< class TInputImageType, class TOutputImageType, class TMaskImageType>
 itk::StructureTensorEigenvalueImageFilter<TInputImageType,TOutputImageType,TMaskImageType>::StructureTensorEigenvalueImageFilter()
 {
   this->SetNumberOfIndexedOutputs(3);
   this->SetNumberOfIndexedInputs(1);
 
   this->SetNthOutput( 0, this->MakeOutput(0) );
   this->SetNthOutput( 1, this->MakeOutput(1) );
   this->SetNthOutput( 2, this->MakeOutput(2) );
 
 }
 
 template< class TInputImageType, class TOutputImageType, class TMaskImageType>
 itk::StructureTensorEigenvalueImageFilter<TInputImageType,TOutputImageType,TMaskImageType>::~StructureTensorEigenvalueImageFilter()
 {
 
 }
 
 
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp
index 832edc158f..6e1ac9f614 100644
--- a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp
+++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp
@@ -1,854 +1,930 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qt
 #include <QColorDialog>
 #include <QMessageBox>
 #include <QFuture>
 #include <QtConcurrent>
 
 // Qmitk
 #include "QmitkActiveLearning.h"
 
 // MITK
 #include <usModuleRegistry.h>
 #include <mitkImage.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkLabel.h>
 #include <mitkBaseGeometry.h>
 #include <mitkNumericTypes.h>
 #include <mitkPixelType.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 
 // ITK
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
 #include <itkLaplacianRecursiveGaussianImageFilter.h>
 #include <itkHessianMatrixEigenvalueImageFilter.h>
 #include <itkStructureTensorEigenvalueImageFilter.h>
 #include <itkHessianRecursiveGaussianImageFilter.h>
 #include <itkSymmetricEigenAnalysisImageFilter.h>
 #include <itkImageRegionIterator.h>
 
 typedef double FeaturePixelType;
 
 // Returns true if list has at least one entry and all entries are valid mitk::Images, otherwise false
 static bool SelectionAllImages(const QList<mitk::DataNode::Pointer>& nodes)
 {
     if (nodes.empty())
     {
         return false;
     }
     for (const auto& node : nodes)
     {
         if(!(node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) != nullptr)) return false;
     }
     return true;
 }
 
 // QColor to mitk::Color
 static mitk::Color QColorToMitkColor(const QColor& qcolor)
 {
     mitk::Color color;
     color.SetRed((float)qcolor.red() / 255);
     color.SetGreen((float)qcolor.green() / 255);
     color.SetBlue((float)qcolor.blue() / 255);
     return color;
 }
 
 // For debugging
 static void PrintAllLabels(mitk::LabelSetImage* image)
 {
     for (auto it=image->GetActiveLabelSet()->IteratorBegin(); it!=image->GetActiveLabelSet()->IteratorConstEnd(); ++it)
     {
         MITK_INFO << "Key: " << it->first << " - Name: " << it->second->GetName() << " - Value: " << it->second->GetValue() << " - Color: " << it->second->GetColor();
     }
 }
 
 // Make values of labels a consistent range
 static void FillLabelValues(mitk::LabelSetImage* image)
 {
     int value(0);
     for (auto it=image->GetActiveLabelSet()->IteratorBegin(); it!=image->GetActiveLabelSet()->IteratorConstEnd(); ++it)
     {
         it->second->SetValue(value);
         value++;
     }
     image->GetActiveLabelSet()->SetActiveLabel(0);
 }
 
 // Fill image with zeros
 static void FillWithZeros(mitk::Image* image)
 {
     unsigned int size = image->GetPixelType().GetSize();
     for (unsigned int i=0; i<image->GetDimension(); i++)
     {
         size *= image->GetDimension(i);
     }
     for (unsigned int t=0; t<image->GetTimeSteps(); t++)
     {
         mitk::ImageWriteAccessor accessor(image, image->GetVolumeData(0));
         memset(accessor.GetData(), 0, size);
     }
 }
 
+template<typename MatrixElementType>
+static Eigen::Matrix<MatrixElementType, Eigen::Dynamic, Eigen::Dynamic> Transform(const std::vector<mitk::Image::Pointer> images)
+{
+    // Find size for output matrix [number of voxels, number of feature images]
+    unsigned int size = images[0]->GetDimension(0);
+    for (unsigned int i=1; i<3; ++i)
+    {
+        size *= images[0]->GetDimension(i);
+    }
+    Eigen::Matrix<MatrixElementType, Eigen::Dynamic, Eigen::Dynamic> outputMatrix(size, images.size());
+
+    int j = 0;
+    for (auto image : images)
+    {
+        int i = 0;
+        typename itk::Image<MatrixElementType, 3>::Pointer imageItk;
+        mitk::CastToItkImage(image, imageItk);
+        auto it = itk::ImageRegionConstIterator<itk::Image<MatrixElementType, 3>>(imageItk, imageItk->GetLargestPossibleRegion());
+        while (!it.IsAtEnd())
+        {
+            outputMatrix(i, j) = it.Get();
+            ++it;
+        }
+        ++j;
+    }
+
+    return outputMatrix;
+}
+
+template<typename MatrixElementType, typename OutputPixelType>
+static void Transform(const Eigen::Matrix<MatrixElementType, Eigen::Dynamic, Eigen::Dynamic> &inputMatrix, mitk::Image::Pointer outputImage)
+{
+    typename itk::Image<OutputPixelType, 3>::Pointer imageItk;
+    mitk::CastToItkImage(outputImage, imageItk);
+
+    auto it = itk::ImageRegionIterator<itk::Image<OutputPixelType, 3>>(imageItk, imageItk->GetLargestPossibleRegion());
+    int i = 0;
+    while (!it.IsAtEnd())
+    {
+        it.Set(inputMatrix(i, 0));
+        ++it;
+        ++i;
+    }
+
+    outputImage = mitk::GrabItkImageMemory(imageItk);
+}
+
 /* ==================================================================
  * FEATURES
  * =============================================================== */
 
 template<typename PixelType, unsigned int imageDimension>
-static void GaussianSmoothing(const itk::Image<PixelType, imageDimension>* inputImage, double sigma, mitk::Image::Pointer outputImage)
+static void GaussianSmoothing(const itk::Image<PixelType, imageDimension>* inputImage, const double sigma, mitk::Image::Pointer outputImage)
 {
     typedef itk::Image<PixelType, imageDimension> ImageType;
     typedef itk::Image<FeaturePixelType, imageDimension> FeatureImageType;
     auto filter = itk::DiscreteGaussianImageFilter<ImageType, FeatureImageType>::New();
     filter->SetInput(inputImage);
     filter->SetVariance(sigma*sigma);
     filter->Update();
     mitk::GrabItkImageMemory(filter->GetOutput(), outputImage);
 }
 
 template<typename PixelType, unsigned int imageDimension>
-static void GaussianGradientMagnitude(const itk::Image<PixelType, imageDimension>* inputImage, double sigma, mitk::Image::Pointer outputImage)
+static void GaussianGradientMagnitude(const itk::Image<PixelType, imageDimension>* inputImage, const double sigma, mitk::Image::Pointer outputImage)
 {
     typedef itk::Image<PixelType, imageDimension> ImageType;
     typedef itk::Image<FeaturePixelType, imageDimension> FeatureImageType;
     auto filter = itk::GradientMagnitudeRecursiveGaussianImageFilter<ImageType, FeatureImageType>::New();
     filter->SetInput(inputImage);
     filter->SetSigma(sigma);
     filter->Update();
     mitk::GrabItkImageMemory(filter->GetOutput(), outputImage);
 }
 
 template<typename PixelType, unsigned int imageDimension>
-static void LaplacianOfGaussian(const itk::Image<PixelType, imageDimension>* inputImage, double sigma, mitk::Image::Pointer outputImage)
+static void LaplacianOfGaussian(const itk::Image<PixelType, imageDimension>* inputImage, const double sigma, mitk::Image::Pointer outputImage)
 {
     typedef itk::Image<PixelType, imageDimension> ImageType;
     typedef itk::Image<FeaturePixelType, imageDimension> FeatureImageType;
     auto filter = itk::LaplacianRecursiveGaussianImageFilter<ImageType, FeatureImageType>::New();
     filter->SetInput(inputImage);
     filter->SetSigma(sigma);
     filter->Update();
     mitk::GrabItkImageMemory(filter->GetOutput(), outputImage);
 }
 
 //template<typename PixelType, unsigned int imageDimension>
 //static void StructureTensorEigenvalues(const itk::Image<PixelType, imageDimension>* inputImage, float sigma, std::vector<mitk::Image::Pointer> outputImages)
 //{
 //    typedef itk::Image<PixelType, imageDimension> ImageType;
 //    auto filter = itk::StructureTensorEigenvalueImageFilter<ImageType>::New();
 //    filter->SetInput(inputImage);
 //    filter->SetInnerScale(sigma);
 //    filter->SetOuterScale(sigma);
 //    filter->Update();
 //    for (unsigned int i=0; i<filter->GetNumberOfOutputs(); i++)
 //    {
 //        mitk::GrabItkImageMemory(filter->GetOutput(i), outputImages[i]);
 //    }
 //}
 
 //template<typename PixelType, unsigned int imageDimension>
 //static void HessianEigenvalues(const itk::Image<PixelType, imageDimension>* inputImage, float sigma, std::vector<mitk::Image::Pointer> outputImages)
 //{
 //    typedef itk::Image<PixelType, imageDimension> ImageType;
 //    typedef itk::Image<itk::SymmetricSecondRankTensor<PixelType, imageDimension>, imageDimension> TensorImageType;
 //    auto filter = itk::HessianRecursiveGaussianImageFilter<ImageType, TensorImageType>::New();
 
 //    ImageType::Pointer o1, o2, o3;
 //    o1->Allocate();
 //    o2->Allocate();
 //    o3->Allocate();
 
 //    filter->SetInput(inputImage);
 //    filter->SetSigma(sigma);
 //    filter->Update();
 //    TensorImageType::Pointer tensorImage = filter->GetOutput();
 
 //    itk::ImageRegionIterator<TensorImageType> tensorIt(tensorImage, tensorImage->GetLargestPossibleRegion());
 //    itk::ImageRegionIterator<ImageType> o1It(o1, o1->GetLargestPossibleRegion());
 //    itk::ImageRegionIterator<ImageType> o2It(o2, o2->GetLargestPossibleRegion());
 //    itk::ImageRegionIterator<ImageType> o3It(o3, o3->GetLargestPossibleRegion());
 
 //    while (!tensorIt.IsAtEnd())
 //    {
 //	itk::SymmetricSecondRankTensor<PixelType, imageDimension>::EigenValue
 
 //    for (unsigned int i=0; i<filter->GetNumberOfOutputs(); i++)
 //    {
 //        mitk::GrabItkImageMemory(filter->GetOutput(i), outputImages[i]);
 //    }
 //}
 
 /* ==================================================================
  * PUBLIC SLOTS
  * =============================================================== */
 
 
 void ActiveLearning::Initialize()
 {
     // Get selected nodes and check again if these are all images
     m_Nodes = this->GetDataManagerSelection();
     if (!SelectionAllImages(m_Nodes)) return;
 
     m_Controls.m_InitializePushButton->setDisabled(true);
 
     // Set names to the label (again)
     QString nameList = QString::fromStdString(m_Nodes[0]->GetName());
     if (m_Nodes.length() >= 2)
     {
         for (int i=1; i<m_Nodes.length(); ++i)
         {
             nameList += QString("<br />");
             nameList += QString::fromStdString(m_Nodes[i]->GetName());
         }
     }
     m_Controls.m_InitializeLabel->setText(nameList);
 
-    // =======================================
-    // ANNOTATION IMAGE
-    // =======================================
-
-    m_AnnotationImage = mitk::LabelSetImage::New();
-
-    try
-    {
-        auto referenceImage = dynamic_cast<mitk::Image*>(m_Nodes[0]->GetData());
-        m_AnnotationImage->Initialize(referenceImage);
-    }
-    catch (mitk::Exception& e)
-    {
-        MITK_ERROR << "Exception caught: " << e.GetDescription();
-        QMessageBox::information(m_Parent, "Error", "Could not initialize annotation image");
-        return;
-    }
-
-    FillWithZeros(m_AnnotationImage);
-
-    m_AnnotationNode = mitk::DataNode::New();
-    m_AnnotationNode->SetData(m_AnnotationImage);
-    m_AnnotationNode->SetName("Labels");
-    m_AnnotationNode->SetColor(0., 0., 0.);
-//    m_AnnotationNode->SetBoolProperty("helper object", true);
-    m_AnnotationImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(m_Nodes[0]->GetName().c_str()));
-    m_AnnotationImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New("Labels"));
-    this->GetDataStorage()->Add(m_AnnotationNode, m_Nodes[0]);
-
     // =======================================
     // PREDICTION IMAGE
     // =======================================
 
     m_PredictionImage = mitk::Image::New();
 
     try
     {
         mitk::Image::Pointer referenceImage = dynamic_cast<mitk::Image*>(m_Nodes[0]->GetData());
         m_PredictionImage->Initialize(referenceImage);
     }
     catch (mitk::Exception& e)
     {
         MITK_ERROR << "Exception caught: " << e.GetDescription();
         QMessageBox::information(m_Parent, "Error", "Could not initialize prediction image");
         return;
     }
 
     FillWithZeros(m_PredictionImage);
 
     m_PredictionNode = mitk::DataNode::New();
     m_PredictionNode->SetData(m_PredictionImage);
     m_PredictionNode->SetName("Predictions");
     m_PredictionNode->SetColor(0., 0., 0.);
 //    m_PredictionNode->SetBoolProperty("helper object", true);
 //    m_PredictionImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(nodes[0]->GetName().c_str()));
 //    m_PredictionImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New("Predictions"));
     this->GetDataStorage()->Add(m_PredictionNode, m_Nodes[0]);
 
     // =======================================
     // SEGMENTATION IMAGE
     // =======================================
 
     m_SegmentationImage = mitk::LabelSetImage::New();
 
     try
     {
         auto referenceImage = dynamic_cast<mitk::Image*>(m_Nodes[0]->GetData());
         m_SegmentationImage->Initialize(referenceImage);
     }
     catch (mitk::Exception& e)
     {
         MITK_ERROR << "Exception caught: " << e.GetDescription();
         QMessageBox::information(m_Parent, "Error", "Could not initialize segmentation image");
         return;
     }
 
     FillWithZeros(m_SegmentationImage);
 
     m_SegmentationNode = mitk::DataNode::New();
     m_SegmentationNode->SetData(m_SegmentationImage);
     m_SegmentationNode->SetName("Segmentation");
     m_SegmentationNode->SetColor(0., 0., 0.);
 //    m_PredictionNode->SetBoolProperty("helper object", true);
     m_SegmentationImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(m_Nodes[0]->GetName().c_str()));
     m_SegmentationImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New("Segmentation"));
     this->GetDataStorage()->Add(m_SegmentationNode, m_Nodes[0]);
 
+    // =======================================
+    // ANNOTATION IMAGE
+    // =======================================
+
+    m_AnnotationImage = mitk::LabelSetImage::New();
+
+    try
+    {
+        auto referenceImage = dynamic_cast<mitk::Image*>(m_Nodes[0]->GetData());
+        m_AnnotationImage->Initialize(referenceImage);
+    }
+    catch (mitk::Exception& e)
+    {
+        MITK_ERROR << "Exception caught: " << e.GetDescription();
+        QMessageBox::information(m_Parent, "Error", "Could not initialize annotation image");
+        return;
+    }
+
+    FillWithZeros(m_AnnotationImage);
+
+    m_AnnotationNode = mitk::DataNode::New();
+    m_AnnotationNode->SetData(m_AnnotationImage);
+    m_AnnotationNode->SetName("Labels");
+    m_AnnotationNode->SetColor(0., 0., 0.);
+//    m_AnnotationNode->SetBoolProperty("helper object", true);
+    m_AnnotationImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(m_Nodes[0]->GetName().c_str()));
+    m_AnnotationImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New("Labels"));
+    this->GetDataStorage()->Add(m_AnnotationNode, m_Nodes[0]);
+
     // Convert input images to FeaturePixelType
     for (auto node : m_Nodes)
     {
         mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
         auto itkImage = itk::Image<FeaturePixelType, 3>::New();
         mitk::CastToItkImage(image, itkImage);
         image = mitk::GrabItkImageMemory(itkImage);
         node->SetData(image);
     }
 
     // Calculate features
     for (const auto node : m_Nodes)
     {
         mitk::Image::Pointer currentImage = dynamic_cast<mitk::Image*>(node->GetData());
         QFuture<std::vector<std::pair<mitk::Image::Pointer, std::string>>> future;
         future = QtConcurrent::run(this, &ActiveLearning::CalculateFeatures, currentImage);
         auto futureWatcher = new QFutureWatcher<std::vector<std::pair<mitk::Image::Pointer, std::string>>>();
         futureWatcher->setFuture(future);
         connect(futureWatcher, SIGNAL(finished()), this, SLOT(OnInitializationFinished()));
         m_FeatureCalculationWatchers.push_back(futureWatcher);
     }
 
     // Interactor
     auto activeLearningLib = us::ModuleRegistry::GetModule("MitkCLActiveLearning");
     m_Interactor = mitk::ActiveLearningInteractor::New();
     m_Interactor->LoadStateMachine("Paint.xml", activeLearningLib);
     m_Interactor->SetEventConfig("PaintConfig.xml", activeLearningLib);
     m_Interactor->SetDataNode(m_AnnotationNode);
 
     // Classifier
-//    m_Classifier = mitk::VigraRandomForestClassifier::New();
-//    m_Classifier->SetTreeCount(50);
-//    m_Classifier->SetMaximumTreeDepth(10);
+    m_Classifier = mitk::VigraRandomForestClassifier::New();
+    m_Classifier->SetTreeCount(m_NumberOfTrees);
+    m_Classifier->SetMaximumTreeDepth(m_MaximumTreeDepth);
 
     // Automatically add first label
     OnAddLabelPushButtonClicked();
 
     m_Active = true;
 }
 
 
 /* ==================================================================
  * PUBLIC
  * =============================================================== */
 
 
 ActiveLearning::ActiveLearning() :
     m_Parent(nullptr),
     m_AnnotationImage(nullptr),
     m_AnnotationNode(nullptr),
     m_PredictionImage(nullptr),
     m_PredictionNode(nullptr),
     m_SegmentationImage(nullptr),
     m_SegmentationNode(nullptr),
-    m_Active(false)
+    m_Active(false),
+    m_NumberOfTrees(50),
+    m_MaximumTreeDepth(10),
+    m_PredictionMatrix(nullptr)
 {
 
 }
 
 ActiveLearning::~ActiveLearning()
 {
 
 }
 
 void ActiveLearning::CreateQtPartControl( QWidget *parent )
 {
     m_Controls.setupUi(parent);
     m_Parent = parent;
 
     // Label model
     m_LabelListModel = new QStandardItemModel(0, 3, this);
     m_Controls.m_LabelTableView->setModel(m_LabelListModel);
     m_Controls.m_LabelTableView->horizontalHeader()->setDefaultSectionSize(20);
     m_Controls.m_LabelTableView->verticalHeader()->setDefaultSectionSize(20);
     NotEditableDelegate* itemDelegate = new NotEditableDelegate(parent);
     m_Controls.m_LabelTableView->setItemDelegateForColumn(1, itemDelegate);
     connect(m_Controls.m_LabelTableView, SIGNAL(doubleClicked(QModelIndex)),
             this, SLOT(OnColorIconDoubleClicked(QModelIndex)));
     connect(m_Controls.m_LabelTableView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
             this, SLOT(OnLabelListSelectionChanged(QItemSelection, QItemSelection)));
     connect(m_LabelListModel, SIGNAL(dataChanged(QModelIndex, QModelIndex)),
             this, SLOT(OnLabelNameChanged(QModelIndex, QModelIndex)));
 
     // Buttons
     connect(m_Controls.m_InitializePushButton, SIGNAL(clicked()),
             this, SLOT(Initialize()));
     connect(m_Controls.m_AddLabelPushButton, SIGNAL(clicked()),
             this, SLOT(OnAddLabelPushButtonClicked()));
     connect(m_Controls.m_RemoveLabelPushButton, SIGNAL(clicked()),
             this, SLOT(OnRemoveLabelPushButtonClicked()));
     connect(m_Controls.m_PaintToolButton, SIGNAL(clicked()),
             this, SLOT(OnPaintToolButtonClicked()));
     connect(m_Controls.m_EraseToolButton, SIGNAL(clicked()),
             this, SLOT(OnEraseToolButtonClicked()));
+    connect(m_Controls.m_UpdatePredictionsPushButton, SIGNAL(clicked()),
+            this, SLOT(OnUpdatePredictionsPushButtonClicked()));
 
     // Set start configuration
     m_Controls.m_LabelControlsFrame->setVisible(false);
     SetInitializeReady(false);
 }
 
 void ActiveLearning::ResetLabels()
 {
     // Remove all labels but the first
     for (auto it=m_AnnotationImage->GetActiveLabelSet()->IteratorBegin(); it!=m_AnnotationImage->GetActiveLabelSet()->IteratorConstEnd(); it++)
     {
         if (it->first != 0)
         {
             m_AnnotationImage->GetActiveLabelSet()->RemoveLabel(it->first);
         }
     }
 
     // Fill with labels from list
     for (int i=0; i<m_LabelListModel->rowCount(); i++)
     {
         QString name = m_LabelListModel->item(i, 2)->text();
         m_LabelListModel->item(i, 1)->setText(QString::number(i + 1));
         QColor color = m_LabelListModel->item(i)->background().color();
         m_AnnotationImage->GetActiveLabelSet()->AddLabel(name.toStdString(), QColorToMitkColor(color));
     }
 }
 
 std::vector<std::pair<mitk::Image::Pointer, std::string> > ActiveLearning::CalculateFeatures(const mitk::Image::Pointer inputImage)
 {
     std::vector<std::pair<mitk::Image::Pointer, std::string>> result;
 
     // TODO: Get features from preference page
     std::vector<float> sigmas = {0.7, 1.6};
 
     for (auto sigma : sigmas)
     {
         std::stringstream ss;
 
         auto gaussImage = mitk::Image::New();
         AccessByItk_n(inputImage, GaussianSmoothing, (sigma, gaussImage));
         ss << "GaussianSmoothing (" << std::fixed << std::setprecision(2) << sigma << ")";
         result.push_back(std::pair<mitk::Image::Pointer, std::string>(gaussImage, ss.str()));
         ss.str("");
 
         auto gradMagImage = mitk::Image::New();
         AccessByItk_n(inputImage, GaussianGradientMagnitude, (sigma, gradMagImage));
         ss << "GaussianGradientMagnitude (" << std::fixed << std::setprecision(2) << sigma << ")";
         result.push_back(std::pair<mitk::Image::Pointer, std::string>(gradMagImage, ss.str()));
         ss.str("");
 
         auto logImage = mitk::Image::New();
         AccessByItk_n(inputImage, LaplacianOfGaussian, (sigma, logImage));
         ss << "LaplacianOfGaussian (" << std::fixed << std::setprecision(2) << sigma << ")";
         result.push_back(std::pair<mitk::Image::Pointer, std::string>(logImage, ss.str()));
         ss.str("");
 
 //        auto structImage1 = mitk::Image::New();
 //        auto structImage2 = mitk::Image::New();
 //        auto structImage3 = mitk::Image::New();
 //        std::vector<mitk::Image::Pointer> structImages = {structImage1, structImage2, structImage3};
 //        AccessByItk_n(inputImage, StructureTensorEigenvalues, (sigma, structImages));
 //        ss << "StructureTensorEigenvalue1 (" << std::fixed << std::setprecision(2) << sigma << ")";
 //        result.push_back(std::pair<mitk::Image::Pointer, std::string>(structImage1, ss.str()));
 //        ss.str("");
 //        ss << "StructureTensorEigenvalue2 (" << std::fixed << std::setprecision(2) << sigma << ")";
 //        result.push_back(std::pair<mitk::Image::Pointer, std::string>(structImage2, ss.str()));
 //        ss.str("");
 //        if (inputImage->GetDimension() == 3)
 //        {
 //            ss << "StructureTensorEigenvalue3 (" << std::fixed << std::setprecision(2) << sigma << ")";
 //            result.push_back(std::pair<mitk::Image::Pointer, std::string>(structImage3, ss.str()));
 //            ss.str("");
 //        }
 
 //        auto hessianImage1 = mitk::Image::New();
 //        auto hessianImage2 = mitk::Image::New();
 //        auto hessianImage3 = mitk::Image::New();
 //        std::vector<mitk::Image::Pointer> hessianImages = {hessianImage1, hessianImage2, hessianImage3};
 //        AccessByItk_n(inputImage, HessianEigenvalues, (sigma, hessianImages));
 //        ss << "HessianEigenvalue1 (" << std::fixed << std::setprecision(2) << sigma << ")";
 //        result.push_back(std::pair<mitk::Image::Pointer, std::string>(hessianImage1, ss.str()));
 //        ss.str("");
 //        ss << "HessianEigenvalue2 (" << std::fixed << std::setprecision(2) << sigma << ")";
 //        result.push_back(std::pair<mitk::Image::Pointer, std::string>(hessianImage2, ss.str()));
 //        ss.str("");
 //        if (inputImage->GetDimension() == 3)
 //        {
 //            ss << "HessianEigenvalue3 (" << std::fixed << std::setprecision(2) << sigma << ")";
 //            result.push_back(std::pair<mitk::Image::Pointer, std::string>(hessianImage3, ss.str()));
 //            ss.str("");
 //        }
     }
 
     return result;
 }
 
-std::pair<Eigen::VectorXi*, Eigen::MatrixXd*> ActiveLearning::GetTrainingData(const mitk::LabelSetImage::Pointer annotationImage, const std::vector<mitk::Image::Pointer> featureImageVector)
+std::pair<std::shared_ptr<Eigen::VectorXi>, std::shared_ptr<Eigen::MatrixXd>> ActiveLearning::GetTrainingData(const mitk::LabelSetImage::Pointer annotationImage, const std::vector<mitk::Image::Pointer> featureImageVector)
 {
     // Get indices and labels
     std::vector<itk::Index<3>> indices;
     std::vector<int> labels;
     itk::Image<mitk::LabelSetImage::PixelType, 3>::Pointer annotationImageItk;
     mitk::CastToItkImage(annotationImage, annotationImageItk);
 
     itk::ImageRegionIteratorWithIndex<itk::Image<mitk::LabelSetImage::PixelType, 3>> it(annotationImageItk, annotationImageItk->GetLargestPossibleRegion());
     while (!it.IsAtEnd())
     {
         if (it.Get() != 0)
         {
             indices.push_back(it.GetIndex());
             labels.push_back(it.Get());
         }
+        ++it;
     }
 
     Eigen::MatrixXd trainingData(indices.size(), featureImageVector.size());
     Eigen::VectorXi trainingLabels = Eigen::VectorXi::Map(labels.data(), labels.size());
 
-    int i = 0;
     int j = 0;
     for (mitk::Image::Pointer feature : featureImageVector)
     {
+        int i = 0;
         mitk::ImagePixelReadAccessor<FeaturePixelType> access(feature, feature->GetVolumeData());
         for (auto index : indices)
         {
             trainingData(i, j) = access.GetPixelByIndexSafe(index);
             i++;
         }
         j++;
     }
 
-    return std::pair<Eigen::VectorXi*, Eigen::MatrixXd*>(&trainingLabels, &trainingData);
+    auto trainingLabelsPtr = std::make_shared<Eigen::VectorXi>(trainingLabels);
+    auto trainingDataPtr = std::make_shared<Eigen::MatrixXd>(trainingData);
+    std::pair<std::shared_ptr<Eigen::VectorXi>, std::shared_ptr<Eigen::MatrixXd>> result = std::make_pair(trainingLabelsPtr, trainingDataPtr);
+
+    return result;
 }
 
 const std::string ActiveLearning::VIEW_ID = "org.mitk.views.activelearning";
 
 
 /* ==================================================================
  * PROTECTED SLOTS
  * =============================================================== */
 
 
 void ActiveLearning::OnAddLabelPushButtonClicked()
 {
     QString labelName = QString("Label ") + QString::number(m_AnnotationImage->GetActiveLabelSet()->ReverseIteratorBegin()->first + 1);
     QColor labelColor = Qt::GlobalColor(m_LabelListModel->rowCount() % 12 + 7); // We only want Qt default colors 7 to 18
 
     // Create icon
     QStandardItem* colorSquare = new QStandardItem;
     colorSquare->setBackground(labelColor);
     colorSquare->setEditable(false);
     QPixmap colorPixmap(20, 20);
     colorPixmap.fill(labelColor);
     colorSquare->setIcon(QIcon(colorPixmap));
 
     // Key is the highest existing key + 1
     int value = (int)m_AnnotationImage->GetActiveLabelSet()->ReverseIteratorBegin()->first + 1;
     QStandardItem* valueItem = new QStandardItem();
     valueItem->setText(QString::number(value));
 
     // Create label item
     QStandardItem* label = new QStandardItem(labelName);
 
     // Add to image
     m_AnnotationImage->GetActiveLabelSet()->AddLabel(labelName.toStdString(), QColorToMitkColor(labelColor));
     PrintAllLabels(m_AnnotationImage);
 
     // Make list and insert
     QList<QStandardItem*> list;
     list.append(colorSquare);
     list.append(valueItem);
     list.append(label);
     m_LabelListModel->appendRow(list);
 
     // If this is the first label, we activate the paint button
     // We also have to set the data node color for this one, because for 1 values that color seems to define the rendered color
     if (m_LabelListModel->rowCount() == 1)
     {
         OnPaintToolButtonClicked();
         m_AnnotationNode->SetColor(QColorToMitkColor(labelColor));
     }
 
     // Select newly added label
     m_Controls.m_LabelTableView->selectRow(m_LabelListModel->rowCount() - 1);
 }
 
 void ActiveLearning::OnRemoveLabelPushButtonClicked()
 {
     QItemSelectionModel* selection = m_Controls.m_LabelTableView->selectionModel();
     if (selection->hasSelection())
     {
         unsigned int removeIndex = selection->selectedRows().first().row();
         QString removeMessage = QString("Remove label '") + m_LabelListModel->item(removeIndex, 2)->text() + QString("'?");
         QMessageBox::StandardButton removeReply;
         removeReply = QMessageBox::question(m_Parent,
                                             "Remove Label",
                                             removeMessage,
                                             QMessageBox::Yes | QMessageBox::No);
         if (removeReply == QMessageBox::Yes)
         {
             // if there are no annotations, reset labels
             if (m_Interactor->IsUsed())
             {
                 std::vector<mitk::LabelSetImage::PixelType> labels;
                 labels.push_back(m_LabelListModel->item(removeIndex, 1)->text().toInt());
                 m_AnnotationImage->RemoveLabels(labels);
                 m_LabelListModel->removeRow(removeIndex);
             }
             else
             {
                 m_LabelListModel->removeRow(removeIndex);
                 ResetLabels();
             }
             PrintAllLabels(m_AnnotationImage);
         }
     }
 }
 
 void ActiveLearning::OnPaintToolButtonClicked()
 {
     m_Controls.m_PaintToolButton->setChecked(true);
     QItemSelectionModel* selection = m_Controls.m_LabelTableView->selectionModel();
     int row(0);
     if (selection->hasSelection())
     {
         row = selection->selectedRows().first().row();
     }
     else
     {
         m_Controls.m_LabelTableView->selectRow(0);
     }
     m_Interactor->SetPaintingPixelValue(m_LabelListModel->item(row, 1)->text().toInt());
     m_AnnotationImage->GetActiveLabelSet()->SetActiveLabel(m_LabelListModel->item(row, 1)->text().toInt());
 }
 
 void ActiveLearning::OnEraseToolButtonClicked()
 {
     m_Controls.m_EraseToolButton->setChecked(true);
     m_Interactor->SetPaintingPixelValue(0);
     m_AnnotationImage->GetActiveLabelSet()->SetActiveLabel(0);
 }
 
 void ActiveLearning::OnActivateGuidancePushButtonToggled(bool toggled)
 {
 
 }
 
 void ActiveLearning::OnSaveSegmentationPushButtonClicked()
 {
 
 }
 
 void ActiveLearning::OnSavePredictionsPushButtonClicked()
 {
 
 }
 
 void ActiveLearning::OnExportSegmentationPushButtonClicked()
 {
 
 }
 
 void ActiveLearning::OnExportPredictionsPushButtonClicked()
 {
 
 }
 
 void ActiveLearning::OnColorIconDoubleClicked(const QModelIndex& index)
 {
     // Check if click is really from color icon
     if (index.column() != 0)
     {
         return;
     }
     else
     {
         // Color change dialog
         QColor setColor = QColorDialog::getColor(m_LabelListModel->itemFromIndex(index)->background().color(), m_Parent, "Select Label Color");
         if (setColor.isValid())
         {
             m_LabelListModel->itemFromIndex(index)->setBackground(setColor);
             QPixmap colorPixmap(20, 20);
             colorPixmap.fill(setColor);
             m_LabelListModel->itemFromIndex(index)->setIcon(QIcon(colorPixmap));
 
             // Set color on label
             m_AnnotationImage->GetActiveLabelSet()->GetLabel(m_LabelListModel->item(index.row(), 1)->text().toInt())->SetColor(QColorToMitkColor(setColor));
             m_AnnotationImage->GetActiveLabelSet()->UpdateLookupTable(m_LabelListModel->item(index.row(), 1)->text().toInt());
             PrintAllLabels(m_AnnotationImage);
 
             // If this is the label with value 1 we have to change the data node color
             if (m_LabelListModel->item(index.row(), 1)->text().toInt() == 1)
             {
                 m_AnnotationNode->SetColor(QColorToMitkColor(setColor));
             }
         }
     }
 }
 
 void ActiveLearning::OnLabelListSelectionChanged(const QItemSelection& selected, const QItemSelection& /*deselected*/)
 {
     if (selected.empty()) return;
     // This assumes that only one item can be selected (single selection table view)
     try
     {
         int labelValue = m_LabelListModel->item(selected.indexes()[0].row(), 1)->text().toInt();
         m_Interactor->SetPaintingPixelValue(labelValue);
         m_AnnotationImage->GetActiveLabelSet()->SetActiveLabel(labelValue);
     }
     catch (...)
     {
         m_Interactor->SetPaintingPixelValue(0);
         m_AnnotationImage->GetActiveLabelSet()->SetActiveLabel(0);
     }
 }
 
 void ActiveLearning::OnLabelNameChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/)
 {
     auto item = m_LabelListModel->itemFromIndex(topLeft);
     if (item->column() != 2) return;
     m_AnnotationImage->GetActiveLabelSet()->GetLabel(m_LabelListModel->item(item->row(), 1)->text().toInt())->SetName(item->text().toStdString());
 }
 
 void ActiveLearning::OnInitializationFinished()
 {
     // Check if all futures are finished
     for (auto watcher : m_FeatureCalculationWatchers)
     {
         if (watcher->isFinished() == false) {return;}
     }
 
     // Empty feature vector
     m_FeatureImageVector.clear();
 
     // Insert features into feature vector and data storage
     for (unsigned int i=0; i<m_FeatureCalculationWatchers.size(); i++)
     {
         auto result = m_FeatureCalculationWatchers[i]->result();
         for (unsigned int j=0; j<result.size(); j++)
         {
             m_FeatureImageVector.push_back(result[j].first);
             auto node = mitk::DataNode::New();
             node->SetData(result[j].first);
             node->SetName(result[j].second);
             node->SetBoolProperty("helper object", true);
             node->SetVisibility(false);
             this->GetDataStorage()->Add(node, m_Nodes[i]);
         }
     }
 
     // Show controls
     m_Controls.m_LabelControlsFrame->setVisible(true);
     m_Controls.m_InitializePushButton->setHidden(true);
     MITK_INFO << "Features: " << m_FeatureImageVector.size();
 
     // Delete watchers
     for (auto watcher : m_FeatureCalculationWatchers)
     {
         delete watcher;
     }
     m_FeatureCalculationWatchers.clear();
 }
 
 void ActiveLearning::OnUpdatePredictionsPushButtonClicked()
 {
+    if (m_PredictionMatrix == nullptr)
+    {
+        auto mat = Transform<FeaturePixelType>(m_FeatureImageVector);
+        m_PredictionMatrix = std::make_shared<Eigen::MatrixXd>(mat);
+    }
+    MITK_INFO << "Made test data";
+    auto training = GetTrainingData(m_AnnotationImage, m_FeatureImageVector);
+    MITK_INFO << "Got training data";
+
+    m_Classifier->Train(*training.second, *training.first);
+    MITK_INFO << "Trained";
+
+    Eigen::MatrixXi prediction = m_Classifier->Predict(*m_PredictionMatrix);
+    MITK_INFO << "Predicted";
+
+    Transform<int, mitk::LabelSetImage::PixelType>(prediction, m_SegmentationImage->GetLayerImage(m_SegmentationImage->GetActiveLayer()));
+    m_SegmentationImage->Modified();
+    m_SegmentationNode->Modified();
 
+    this->RequestRenderWindowUpdate();
 }
 
 /* ==================================================================
  * PROTECTED
  * =============================================================== */
 
 
 void ActiveLearning::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                         const QList<mitk::DataNode::Pointer>& nodes)
 {
     if (!SelectionAllImages(nodes))
     {
         SetInitializeReady(false);
         return;
     }
 
     if (nodes.length() >= 2)
     {
         // First selection is the reference (could be any other)
         mitk::Image::Pointer referenceImage = dynamic_cast<mitk::Image*>(nodes[0]->GetData());
         mitk::BaseGeometry* referenceGeometry = referenceImage->GetTimeGeometry()->GetGeometryForTimeStep(0); // Adjust for multiple timesteps
 
         for (int i=1; i<nodes.length(); ++i)
         {
             mitk::Image::Pointer currentImage = dynamic_cast<mitk::Image*>(nodes[i]->GetData());
             mitk::BaseGeometry* currentGeometry = currentImage->GetTimeGeometry()->GetGeometryForTimeStep(0); // Adjust for multiple timesteps
 
             if (!mitk::Equal(*currentGeometry, *referenceGeometry, mitk::eps, true))
             {
                 SetInitializeReady(false);
                 return;
             }
         }
     }
 
     // All nodes have the same geometry, allow init
     SetInitializeReady(true);
 }
 
 void ActiveLearning::SetFocus()
 {
 }
 
 
 /* ==================================================================
  * PRIVATE
  * =============================================================== */
 
 
 void ActiveLearning::SetInitializeReady(bool ready)
 {
     if (ready)
     {
         // get selection, check again just to be sure
         auto nodes = this->GetDataManagerSelection();
         if (!SelectionAllImages(nodes)) return;
 
         m_Controls.m_InitializePushButton->setEnabled(true);
 
         if (!m_Active)
         {
             QString nameList = QString::fromStdString(nodes[0]->GetName());
             if (nodes.length() >= 2)
             {
                 for (int i=1; i<nodes.length(); ++i)
                 {
                     nameList += QString("<br />");
                     nameList += QString::fromStdString(nodes[i]->GetName());
                 }
             }
             m_Controls.m_InitializeLabel->setText(nameList);
         }
     }
     else
     {
         m_Controls.m_InitializePushButton->setDisabled(true);
         if (!m_Active)
         {
             m_Controls.m_InitializeLabel->setText("<font color='red'>Selected images must have matching geometries</font>");
 
         }
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h
index e0ce932d75..010a04dd14 100644
--- a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h
+++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h
@@ -1,148 +1,153 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef ActiveLearning_h
 #define ActiveLearning_h
 
 #include <berryISelectionListener.h>
 #include <QmitkAbstractView.h>
 #include "ui_QmitkActiveLearningControls.h"
 
 // Qt
 #include <QItemDelegate>
 #include <QStandardItemModel>
 #include <QWidget>
 #include <QFutureWatcher>
 
 // MITK
 #include <mitkLabelSetImage.h>
 #include <mitkActiveLearningInteractor.h>
 #include <mitkVigraRandomForestClassifier.h>
 
 #include <Eigen/Dense>
 
 /**
 \brief ActiveLearning
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkAbstractView
 \ingroup ${plugin_target}_internal
 */
 
 // Just a helper class
 class NotEditableDelegate : public QItemDelegate
 {
     Q_OBJECT
 public:
     explicit NotEditableDelegate(QObject* parent = nullptr) : QItemDelegate(parent) {}
 protected:
     QWidget* createEditor(QWidget*, const QStyleOptionViewItem&, const QModelIndex&) const {return Q_NULLPTR;}
 };
 
 class ActiveLearning : public QmitkAbstractView
 {
 
     Q_OBJECT
 
 public slots:
 
     void Initialize();
 
 public:
 
     ActiveLearning();
     ~ActiveLearning();
 
     void CreateQtPartControl(QWidget *parent) override;
 
     std::vector<std::pair<mitk::Image::Pointer, std::string>> CalculateFeatures(const mitk::Image::Pointer inputImage);
 
-    std::pair<Eigen::VectorXi*, Eigen::MatrixXd*> GetTrainingData(const mitk::LabelSetImage::Pointer annotationImage, const std::vector<mitk::Image::Pointer> featureImageVector);
+    std::pair<std::shared_ptr<Eigen::VectorXi>, std::shared_ptr<Eigen::MatrixXd> > GetTrainingData(const mitk::LabelSetImage::Pointer annotationImage, const std::vector<mitk::Image::Pointer> featureImageVector);
 
     static const std::string VIEW_ID;
 
 protected slots:
 
     void OnAddLabelPushButtonClicked();
 
     void OnRemoveLabelPushButtonClicked();
 
     void OnPaintToolButtonClicked();
 
     void OnEraseToolButtonClicked();
 
     void OnActivateGuidancePushButtonToggled(bool toggled);
 
     void OnSaveSegmentationPushButtonClicked();
 
     void OnSavePredictionsPushButtonClicked();
 
     void OnExportSegmentationPushButtonClicked();
 
     void OnExportPredictionsPushButtonClicked();
 
     void OnColorIconDoubleClicked(const QModelIndex& index);
 
     void OnLabelListSelectionChanged(const QItemSelection& selected, const QItemSelection& /*deselected*/);
 
     void OnLabelNameChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/);
 
     void OnUpdatePredictionsPushButtonClicked();
 
     void OnInitializationFinished();
 
 protected:
 
     void OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                             const QList<mitk::DataNode::Pointer>& nodes) override;
 
     void SetFocus() override;
 
     void ResetLabels();
 
     void SetInitializeReady(bool ready);
 
     Ui::ActiveLearningControls m_Controls;
     QWidget* m_Parent;
 
     mitk::LabelSetImage::Pointer m_AnnotationImage;
     mitk::DataNode::Pointer m_AnnotationNode;
 
     mitk::Image::Pointer m_PredictionImage;
     mitk::DataNode::Pointer m_PredictionNode;
 
     mitk::LabelSetImage::Pointer m_SegmentationImage;
     mitk::DataNode::Pointer m_SegmentationNode;
 
     std::vector<mitk::Image::Pointer> m_FeatureImageVector;
     std::vector<QFutureWatcher<std::vector<std::pair<mitk::Image::Pointer, std::string>>>*> m_FeatureCalculationWatchers;
 
     QStandardItemModel* m_LabelListModel;
 
     mitk::ActiveLearningInteractor::Pointer m_Interactor;
 
     QList<mitk::DataNode::Pointer> m_Nodes;
 
-//    mitk::VigraRandomForestClassifier::Pointer m_Classifier;
+    mitk::VigraRandomForestClassifier::Pointer m_Classifier;
 
 private:
 
     bool m_Active;
 
+    int m_NumberOfTrees;
+    int m_MaximumTreeDepth;
+
+    std::shared_ptr<Eigen::MatrixXd> m_PredictionMatrix;
+
 };
 
 #endif // ActiveLearning_h