diff --git a/Modules/Classification/CLActiveLearning/test/mitkActiveLearningTest.cpp b/Modules/Classification/CLActiveLearning/test/mitkActiveLearningTest.cpp
index 9cb7db4754..fef8f68353 100644
--- a/Modules/Classification/CLActiveLearning/test/mitkActiveLearningTest.cpp
+++ b/Modules/Classification/CLActiveLearning/test/mitkActiveLearningTest.cpp
@@ -1,190 +1,258 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // ITK
 #include <itkRandomImageSource.h>
 #include <itkImageFileWriter.h>
 #include <itkThresholdImageFilter.h>
 #include <itkLabelShapeKeepNObjectsImageFilter.h>
 #include <itkConnectedComponentImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImageRegionConstIterator.h>
+#include <itkVectorImage.h>
 
 // MITK
 #include <mitkTestingMacros.h>
 #include <mitkTestFixture.h>
 #include <mitkIOUtil.h>
 #include <mitkImageGenerator.h>
 
 // To be tested
 #include <mitkActiveLearningSuggestRegionFilter.h>
 #include <mitkPredictionConfidenceFilter.h>
 #include <mitkPredictionEntropyFilter.h>
 #include <mitkPredictionMarginFilter.h>
 #include <mitkSelectHighestUncertaintyRegionFilter.h>
 
 
 
 class mitkActiveLearningTestSuite : public mitk::TestFixture
 {
     CPPUNIT_TEST_SUITE(mitkActiveLearningTestSuite);
     MITK_TEST(SuggestRegionFilterTest);
     CPPUNIT_TEST_SUITE_END();
 
 public:
 
     typedef itk::Image<float, 3> ImageType;
     typedef itk::Image<unsigned short, 3> BinaryImageType;
+    typedef itk::VectorImage<float, 3> VectorImageType;
     typedef typename ImageType::PixelType PixelType;
     typedef typename ImageType::IndexType IndexType;
     typedef typename ImageType::RegionType RegionType;
+    typedef typename VectorImageType::IndexType VectorIndexType;
+    typedef itk::VariableLengthVector<float> VectorType;
 
     void setUp()
     {
         // Create random test image
         int dim = 100;
         itk::Size<3> size;
         size.Fill(dim);
         auto randImageSource = itk::RandomImageSource<ImageType>::New();
         randImageSource->SetNumberOfThreads(1); // so results are not random
         randImageSource->SetSize(size);
         randImageSource->Update();
         m_TestImageRandom = randImageSource->GetOutput();
 
         // Create gradient test image
         dim = 100;
         size.Fill(dim);
         RegionType region;
         region.SetSize(size);
         m_TestImageGradient = ImageType::New();
         m_TestImageGradient->SetRegions(region);
         m_TestImageGradient->Allocate();
+
         float val = 0.0;
         itk::ImageRegionIterator<ImageType> it(m_TestImageGradient, region);
+
         while (!it.IsAtEnd())
         {
             auto index = it.GetIndex();
             float max = static_cast<float>(dim);
             float sum = index[0] + index[1] + index[2];
 
             // Linear gradient [0, 1]
 //            val = sum / (3*max);
 
             // soft spheres
             if ((index[0] / max) > 0.5 && (index[1] / max) > 0.5 && (index[2] / max) > 0.5)
             {
                 val = (-std::sin(2 * 3.14 * index[0] / max) * std::sin(2 * 3.14 * index[1] / max) * std::sin(2 * 3.14 * index[2] / max) + 1) / 2.;
             }
             else
             {
                 val = (std::sin(4 * 3.14 * index[0] / max) * std::sin(4 * 3.14 * index[1] / max) * std::sin(4 * 3.14 * index[2] / max) + 1) / 2.;
             }
 
             it.Set(static_cast<PixelType>(val));
             ++it;
         }
+
+        // Create vector image & fill manually
+        dim = 2;
+        size.Fill(dim);
+        region.SetSize(size);
+        m_TestImageVector = VectorImageType::New();
+        m_TestImageVector->SetRegions(region);
+        m_TestImageVector->SetVectorLength(3);
+        m_TestImageVector->Allocate();
+
+        VectorIndexType index;
+        VectorType vector;
+        vector.SetSize(3);
+
+        // Absolute certainty
+        index[0] = 0; index[1] = 0; index[2] = 0;
+        vector[0] = 1.0; vector[1] = 0.0; vector[2] = 0.0;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // certain
+        index[0] = 0; index[1] = 0; index[2] = 1;
+        vector[0] = 0.9; vector[1] = 0.05; vector[2] = 0.05;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // fairly certain
+        index[0] = 0; index[1] = 1; index[2] = 0;
+        vector[0] = 0.6; vector[1] = 0.3; vector[2] = 0.1;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // zero margin
+        index[0] = 0; index[1] = 1; index[2] = 1;
+        vector[0] = 0.45; vector[1] = 0.45; vector[2] = 0.1;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // absolute uncertainty
+        index[0] = 1; index[1] = 0; index[2] = 0;
+        vector[0] = 0.333; vector[1] = 0.333; vector[2] = 0.333;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // normal not normalized
+        index[0] = 1; index[1] = 0; index[2] = 1;
+        vector[0] = 1.2; vector[1] = 0.6; vector[2] = 0.1;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // error case...
+        index[0] = 1; index[1] = 1; index[2] = 0;
+        vector[0] = 0.0; vector[1] = 0.0; vector[2] = 0.0;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // Absolute uncertainty & certainty
+        index[0] = 1; index[1] = 1; index[2] = 1;
+        vector[0] = 1.0; vector[1] = 1.0; vector[2] = 1.0;
+        m_TestImageVector->SetPixel(index, vector);
+
+        // Save gradient image
+        auto writer = itk::ImageFileWriter<ImageType>::New();
+        writer->SetFileName("/home/jens/Desktop/ALtest/gradientImage.nrrd");
+        writer->SetInput(m_TestImageGradient);
+        writer->Update();
+
+        // Save gradient image
+        auto writer = itk::ImageFileWriter<ImageType>::New();
+        writer->SetFileName("/home/jens/Desktop/ALtest/gradientImage.nrrd");
+        writer->SetInput(m_TestImageGradient);
+        writer->Update();
     }
 
     void tearDown()
     {
         m_TestImageRandom = nullptr;
         m_TestImageGradient = nullptr;
         m_TestImageVector = nullptr;
     }
 
     void SuggestRegionFilterTest()
     {
         PixelType threshold = 0.7;
 
-        // Save gradient image
-        auto writer = itk::ImageFileWriter<ImageType>::New();
-        writer->SetFileName("/home/jens/Desktop/ALtest/gradientImage.nrrd");
-        writer->SetInput(m_TestImageGradient);
-        writer->Update();
-
         // Threshold filter
         auto thresholdFilter = itk::BinaryThresholdImageFilter<ImageType, BinaryImageType>::New();
         thresholdFilter->SetOutsideValue(0);
         thresholdFilter->SetInsideValue(1);
         thresholdFilter->SetLowerThreshold(threshold);
         thresholdFilter->SetInput(m_TestImageGradient);
         thresholdFilter->Update();
 
         // Save thresholded image
         auto binaryWriter = itk::ImageFileWriter<BinaryImageType>::New();
         binaryWriter->SetFileName("/home/jens/Desktop/ALtest/gradientImageThresholded.nrrd");
         binaryWriter->SetInput(thresholdFilter->GetOutput());
         binaryWriter->Update();
 
         // Connected component filter
         auto ccFilter = itk::ConnectedComponentImageFilter<BinaryImageType, BinaryImageType>::New();
         ccFilter->SetInput(thresholdFilter->GetOutput());
         ccFilter->Update();
 
         // Save image with connected components
         binaryWriter->SetFileName("/home/jens/Desktop/ALtest/gradientImageCC.nrrd");
         binaryWriter->SetInput(ccFilter->GetOutput());
         binaryWriter->Update();
 
         // Select the one with greatest uncertainty sum
         int ccCount = static_cast<int>(ccFilter->GetObjectCount());
         MITK_INFO << "Number of components: " << ccCount;
         std::map<unsigned short, float> componentSize;
         for (int a=1; a<=ccCount; ++a) {componentSize[a] = 0.0;}
         auto imageIterator = itk::ImageRegionConstIterator<ImageType>(m_TestImageGradient, m_TestImageGradient->GetLargestPossibleRegion());
         auto binaryImageIterator = itk::ImageRegionConstIterator<BinaryImageType>(ccFilter->GetOutput(), ccFilter->GetOutput()->GetLargestPossibleRegion());
         while (!binaryImageIterator.IsAtEnd())
         {
             unsigned short binVal = binaryImageIterator.Get();
             float val = imageIterator.Get();
             if (binVal != 0) {componentSize[binVal] += val;}
             ++binaryImageIterator;
             ++imageIterator;
         }
         using PairType = decltype(componentSize)::value_type;
         auto maxComp = std::max_element(componentSize.begin(), componentSize.end(), [](const PairType& lhs, const PairType& rhs){return lhs.second < rhs.second;});
 
         auto thresholdFilter2 = itk::BinaryThresholdImageFilter<BinaryImageType, BinaryImageType>::New();
         thresholdFilter2->SetOutsideValue(0);
         thresholdFilter2->SetInsideValue(1);
         thresholdFilter2->SetLowerThreshold(maxComp->first);
         thresholdFilter2->SetUpperThreshold(maxComp->first);
         thresholdFilter2->SetInput(ccFilter->GetOutput());
         thresholdFilter2->Update();
 
         // Save optimal region
         binaryWriter->SetFileName("/home/jens/Desktop/ALtest/gradientImageSuggestedRegionReference.nrrd");
         binaryWriter->SetInput(thresholdFilter2->GetOutput());
         binaryWriter->Update();
 
         // Doe the same with suggestion filter
         auto suggestFilter = mitk::ActiveLearningSuggestRegionFilter<ImageType, BinaryImageType>::New();
         suggestFilter->SetThreshold(threshold);
         suggestFilter->SetInput(m_TestImageGradient);
         suggestFilter->Update();
 
         // Save suggested region
         binaryWriter->SetFileName("/home/jens/Desktop/ALtest/gradientImageSuggestedRegion.nrrd");
         binaryWriter->SetInput(suggestFilter->GetOutput());
         binaryWriter->Update();
     }
     typename ImageType::Pointer m_TestImageRandom;
     typename ImageType::Pointer m_TestImageGradient;
     typename ImageType::Pointer m_TestImageVector;
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkActiveLearning)
+
+
+