diff --git a/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp b/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
index 8637823ce0..97516291b0 100644
--- a/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
+++ b/Modules/Multilabel/Testing/mitkLabelSetImageTest.cpp
@@ -1,435 +1,442 @@
 /*============================================================================
 
 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 <mitkIOUtil.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkLabelSetImage.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 class mitkLabelSetImageTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkLabelSetImageTestSuite);
   MITK_TEST(TestInitialize);
   MITK_TEST(TestAddLayer);
   MITK_TEST(TestGetActiveLabelSet);
   MITK_TEST(TestGetActiveLabel);
   MITK_TEST(TestInitializeByLabeledImage);
   MITK_TEST(TestGetLabelSet);
   MITK_TEST(TestGetLabel);
   MITK_TEST(TestSetExteriorLabel);
   MITK_TEST(TestGetTotalNumberOfLabels);
   MITK_TEST(TestExistsLabel);
   MITK_TEST(TestExistsLabelSet);
   MITK_TEST(TestSetActiveLayer);
   MITK_TEST(TestRemoveLayer);
   MITK_TEST(TestRemoveLabels);
   MITK_TEST(TestMergeLabel);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   mitk::LabelSetImage::Pointer m_LabelSetImage;
 
 public:
   void setUp() override
   {
     // Create a new labelset image
     m_LabelSetImage = mitk::LabelSetImage::New();
     mitk::Image::Pointer regularImage = mitk::Image::New();
     unsigned int dimensions[3] = { 96, 128, 52 };
     regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
     m_LabelSetImage->Initialize(regularImage);
   }
 
   void tearDown() override
   {
     // Delete LabelSetImage
     m_LabelSetImage = nullptr;
   }
 
   void TestInitialize()
   {
     // LabelSet image should always has the pixel type mitk::Label::PixelType
     CPPUNIT_ASSERT_MESSAGE("LabelSetImage has wrong pixel type",
                            m_LabelSetImage->GetPixelType() == mitk::MakeScalarPixelType<mitk::Label::PixelType>());
 
     mitk::Image::Pointer regularImage = mitk::Image::New();
     unsigned int dimensions[3] = { 96, 128, 52 };
     regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
 
     mitk::BaseGeometry::Pointer regularImageGeo = regularImage->GetGeometry();
     mitk::BaseGeometry::Pointer labelImageGeo = m_LabelSetImage->GetGeometry();
     MITK_ASSERT_EQUAL(labelImageGeo, regularImageGeo, "LabelSetImage has wrong geometry");
 
     // By default one layer containing the exterior label should be added
     CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - number of layers is not one",
                            m_LabelSetImage->GetNumberOfLayers() == 1);
     CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - active layer has wrong ID",
                            m_LabelSetImage->GetActiveLayer() == 0);
 
     CPPUNIT_ASSERT_MESSAGE("Image was not correctly initialized - active label is not the exterior label",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == 0);
   }
 
   void TestAddLayer()
   {
     CPPUNIT_ASSERT_MESSAGE("Number of layers is not zero", m_LabelSetImage->GetNumberOfLayers() == 1);
 
     m_LabelSetImage->AddLayer();
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - number of layers is not one",
                            m_LabelSetImage->GetNumberOfLayers() == 2);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active layer has wrong ID",
                            m_LabelSetImage->GetActiveLayer() == 1);
 
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is not the exterior label",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == 0);
 
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - number of layers is not two",
                            m_LabelSetImage->GetNumberOfLayers() == 3);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active layer has wrong ID",
                            m_LabelSetImage->GetActiveLayer() == layerID);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
                            m_LabelSetImage->GetActiveLabel(layerID)->GetValue() == 200);
   }
 
   void TestGetActiveLabelSet()
   {
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
 
     mitk::LabelSet::Pointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     CPPUNIT_ASSERT_MESSAGE("Wrong layer ID was returned", layerID == 1);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned", mitk::Equal(*newlayer, *activeLayer, 0.00001, true));
+
+    mitk::LabelSet::ConstPointer constActiveLayer = const_cast<const mitk::LabelSetImage*>(m_LabelSetImage.GetPointer())->GetActiveLabelSet();
+    CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned", mitk::Equal(*newlayer, *constActiveLayer, 0.00001, true));
   }
 
   void TestGetActiveLabel()
   {
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     mitk::Label::PixelType value1 = 1;
     label1->SetValue(value1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     mitk::Label::PixelType value2 = 200;
     label2->SetValue(value2);
 
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label2);
     m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(1);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == value1);
     m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(value2);
     CPPUNIT_ASSERT_MESSAGE("Layer was not added correctly to image - active label is wrong",
                            m_LabelSetImage->GetActiveLabel()->GetValue() == value2);
+
+    CPPUNIT_ASSERT_MESSAGE("Active Label was not correctly retreived with const getter",
+      const_cast<const mitk::LabelSetImage*>(m_LabelSetImage.GetPointer())->GetActiveLabel()->GetValue() == value2);
+
   }
 
   void TestInitializeByLabeledImage()
   {
     mitk::Image::Pointer image =
       mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
     m_LabelSetImage->InitializeByLabeledImage(image);
     CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
   }
 
   void TestGetLabelSet()
   {
     // Test get non existing lset
     mitk::LabelSet::ConstPointer lset = m_LabelSetImage->GetLabelSet(10000);
     CPPUNIT_ASSERT_MESSAGE("Non existing labelset is not nullptr", lset.IsNull());
 
     lset = m_LabelSetImage->GetLabelSet(0);
     CPPUNIT_ASSERT_MESSAGE("Existing labelset is nullptr", lset.IsNotNull());
   }
 
   void TestGetLabel()
   {
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     mitk::Label::PixelType value1 = 1;
     label1->SetValue(value1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     mitk::Label::PixelType value2 = 200;
     label2->SetValue(value2);
 
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
     m_LabelSetImage->AddLayer();
     m_LabelSetImage->GetLabelSet(1)->AddLabel(label2);
 
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for active layer",
                            mitk::Equal(*m_LabelSetImage->GetLabel(1), *label1, 0.0001, true));
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
                            mitk::Equal(*m_LabelSetImage->GetLabel(200, 1), *label2, 0.0001, true));
 
     // Try to get a non existing label
     mitk::Label *label3 = m_LabelSetImage->GetLabel(1000);
     CPPUNIT_ASSERT_MESSAGE("Non existing label should be nullptr", label3 == nullptr);
 
     // Try to get a label from a non existing layer
     label3 = m_LabelSetImage->GetLabel(200, 1000);
     CPPUNIT_ASSERT_MESSAGE("Label from non existing layer should be nullptr", label3 == nullptr);
   }
 
   void TestSetExteriorLabel()
   {
     mitk::Label::Pointer exteriorLabel = mitk::Label::New();
     exteriorLabel->SetName("MyExteriorSpecialLabel");
     mitk::Label::PixelType value1 = 10000;
     exteriorLabel->SetValue(value1);
 
     m_LabelSetImage->SetExteriorLabel(exteriorLabel);
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
                            mitk::Equal(*m_LabelSetImage->GetExteriorLabel(), *exteriorLabel, 0.0001, true));
 
     // Exterior label should be set automatically for each new layer
     m_LabelSetImage->AddLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong label retrieved for layer 1",
                            mitk::Equal(*m_LabelSetImage->GetLabel(10000, 1), *exteriorLabel, 0.0001, true));
   }
 
   void TestGetTotalNumberOfLabels()
   {
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     mitk::Label::PixelType value1 = 1;
     label1->SetValue(value1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     mitk::Label::PixelType value2 = 200;
     label2->SetValue(value2);
 
     m_LabelSetImage->GetActiveLabelSet()->AddLabel(label1);
     m_LabelSetImage->AddLayer();
     m_LabelSetImage->GetLabelSet(1)->AddLabel(label2);
     CPPUNIT_ASSERT_MESSAGE(
       "Wrong total number of labels",
       m_LabelSetImage->GetTotalNumberOfLabels() == 4); // added 2 labels + 2 exterior default labels
   }
 
   void TestExistsLabel()
   {
     mitk::Label::Pointer label = mitk::Label::New();
     label->SetName("Label2");
     mitk::Label::PixelType value = 200;
     label->SetValue(value);
 
     m_LabelSetImage->AddLayer();
     m_LabelSetImage->GetLabelSet(1)->AddLabel(label);
     m_LabelSetImage->SetActiveLayer(0);
     CPPUNIT_ASSERT_MESSAGE("Existing label was not found", m_LabelSetImage->ExistLabel(value) == true);
 
     CPPUNIT_ASSERT_MESSAGE("Non existing label was found", m_LabelSetImage->ExistLabel(10000) == false);
   }
 
   void TestExistsLabelSet()
   {
     // Cache active layer
     mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     // Add new layer
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     m_LabelSetImage->AddLayer(newlayer);
 
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == true);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(20) == false);
   }
 
   void TestSetActiveLayer()
   {
     // Cache active layer
     mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     // Add new layer
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     unsigned int layerID = m_LabelSetImage->AddLayer(newlayer);
 
     // Set initial layer as active layer
     m_LabelSetImage->SetActiveLayer(0);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*activeLayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     // Set previously added layer as active layer
     m_LabelSetImage->SetActiveLayer(layerID);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     // Set a non existing layer as active layer - nothing should change
     m_LabelSetImage->SetActiveLayer(10000);
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
   }
 
   void TestRemoveLayer()
   {
     // Cache active layer
     mitk::LabelSet::ConstPointer activeLayer = m_LabelSetImage->GetActiveLabelSet();
 
     // Add new layers
     m_LabelSetImage->AddLayer();
 
     mitk::LabelSet::Pointer newlayer = mitk::LabelSet::New();
     mitk::Label::Pointer label1 = mitk::Label::New();
     label1->SetName("Label1");
     label1->SetValue(1);
 
     mitk::Label::Pointer label2 = mitk::Label::New();
     label2->SetName("Label2");
     label2->SetValue(200);
 
     newlayer->AddLabel(label1);
     newlayer->AddLabel(label2);
     newlayer->SetActiveLabel(200);
 
     m_LabelSetImage->AddLayer(newlayer);
 
     CPPUNIT_ASSERT_MESSAGE("Wrong active labelset returned",
                            mitk::Equal(*newlayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     m_LabelSetImage->RemoveLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
                            m_LabelSetImage->GetNumberOfLayers() == 2);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(2) == false);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == true);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
 
     m_LabelSetImage->RemoveLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
                            m_LabelSetImage->GetNumberOfLayers() == 1);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(1) == false);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == true);
     CPPUNIT_ASSERT_MESSAGE("Wrong active layer",
                            mitk::Equal(*activeLayer, *m_LabelSetImage->GetActiveLabelSet(), 0.00001, true));
 
     m_LabelSetImage->RemoveLayer();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of layers, after a layer was removed",
                            m_LabelSetImage->GetNumberOfLayers() == 0);
     CPPUNIT_ASSERT_MESSAGE("Check for existing layer failed", m_LabelSetImage->ExistLabelSet(0) == false);
     CPPUNIT_ASSERT_MESSAGE("Active layers is not nullptr although all layer have been removed",
                            m_LabelSetImage->GetActiveLabelSet() == nullptr);
   }
 
   void TestRemoveLabels()
   {
     mitk::Image::Pointer image =
       mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
     m_LabelSetImage->InitializeByLabeledImage(image);
 
     CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
     // 2ndMin because of the exterior label = 0
     CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 was not remove from the image",
                            m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 1);
     CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image",
                            m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
 
     CPPUNIT_ASSERT_MESSAGE("Label with ID 3 does not exists after initialization",
                            m_LabelSetImage->ExistLabel(3) == true);
     CPPUNIT_ASSERT_MESSAGE("Label with ID 7 does not exists after initialization",
                            m_LabelSetImage->ExistLabel(7) == true);
 
     std::vector<mitk::Label::PixelType> labelsToBeRemoved;
     labelsToBeRemoved.push_back(1);
     labelsToBeRemoved.push_back(3);
     labelsToBeRemoved.push_back(7);
     m_LabelSetImage->RemoveLabels(labelsToBeRemoved);
 
     CPPUNIT_ASSERT_MESSAGE("Wrong number of labels after some have been removed",
                            m_LabelSetImage->GetNumberOfLabels() == 3);
     // Values within the image are 0, 1, 3, 5, 6, 7 - New Min/Max value should be 5 / 6
     // 2ndMin because of the exterior label = 0
     CPPUNIT_ASSERT_MESSAGE("Labels with value 1 and 3 was not remove from the image",
                            m_LabelSetImage->GetStatistics()->GetScalarValue2ndMin() == 5);
     CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image",
                            m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
   }
 
   void TestMergeLabel()
   {
     mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("Multilabel/LabelSetTestInitializeImage.nrrd"));
     m_LabelSetImage = nullptr;
     m_LabelSetImage = mitk::LabelSetImage::New();
     m_LabelSetImage->InitializeByLabeledImage(image);
 
     CPPUNIT_ASSERT_MESSAGE("Image - number of labels is not 6", m_LabelSetImage->GetNumberOfLabels() == 6);
 
     // 2ndMin because of the exterior label = 0
     CPPUNIT_ASSERT_MESSAGE("Wrong MIN value", m_LabelSetImage->GetStatistics()->GetScalarValueMin() == 0);
     CPPUNIT_ASSERT_MESSAGE("Wrong MAX value", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 7);
 
     m_LabelSetImage->GetActiveLabelSet()->SetActiveLabel(6);
     // Merge label 7 with label 0. Result should be that label 7 is not present any more
     m_LabelSetImage->MergeLabel(6, 7);
     CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image", m_LabelSetImage->GetStatistics()->GetScalarValueMax() == 6);
     m_LabelSetImage->GetStatistics()->GetScalarValue2ndMax();
 
     // Count all pixels with value 7 = 823
     // Count all pixels with value 6 = 507
     // Check if merge label has 507 + 823 = 1330 pixels
     CPPUNIT_ASSERT_MESSAGE("Label with value 7 was not remove from the image", m_LabelSetImage->GetStatistics()->GetCountOfMaxValuedVoxels() == 1330);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkLabelSetImage)
diff --git a/Modules/Multilabel/mitkLabelSetImage.cpp b/Modules/Multilabel/mitkLabelSetImage.cpp
index 71a099210e..507157853d 100644
--- a/Modules/Multilabel/mitkLabelSetImage.cpp
+++ b/Modules/Multilabel/mitkLabelSetImage.cpp
@@ -1,989 +1,1005 @@
 /*============================================================================
 
 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 "mitkLabelSetImage.h"
 
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkImagePixelWriteAccessor.h"
 #include "mitkInteractionConst.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkPadImageFilter.h"
 #include "mitkRenderingManager.h"
 #include "mitkDICOMSegmentationPropertyHelper.h"
 #include "mitkDICOMQIPropertyHelper.h"
 
 #include <vtkCell.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <itkImageRegionIterator.h>
 #include <itkQuadEdgeMesh.h>
 #include <itkTriangleMeshToBinaryImageFilter.h>
 //#include <itkRelabelComponentImageFilter.h>
 
 #include <itkCommand.h>
 
 template <typename TPixel, unsigned int VDimensions>
 void SetToZero(itk::Image<TPixel, VDimensions> *source)
 {
   source->FillBuffer(0);
 }
 
 template <unsigned int VImageDimension = 3>
 void CreateLabelMaskProcessing(mitk::Image *layerImage, mitk::Image *mask, mitk::LabelSet::PixelType index)
 {
   mitk::ImagePixelReadAccessor<mitk::LabelSet::PixelType, VImageDimension> readAccessor(layerImage);
   mitk::ImagePixelWriteAccessor<mitk::LabelSet::PixelType, VImageDimension> writeAccessor(mask);
 
   std::size_t numberOfPixels = 1;
   for (int dim = 0; dim < static_cast<int>(VImageDimension); ++dim)
     numberOfPixels *= static_cast<std::size_t>(readAccessor.GetDimension(dim));
 
   auto src = readAccessor.GetData();
   auto dest = writeAccessor.GetData();
 
   for (std::size_t i = 0; i < numberOfPixels; ++i)
   {
     if (index == *(src + i))
       *(dest + i) = 1;
   }
 }
 
 mitk::LabelSetImage::LabelSetImage()
   : mitk::Image(), m_ActiveLayer(0), m_activeLayerInvalid(false), m_ExteriorLabel(nullptr)
 {
   // Iniitlaize Background Label
   mitk::Color color;
   color.Set(0, 0, 0);
   m_ExteriorLabel = mitk::Label::New();
   m_ExteriorLabel->SetColor(color);
   m_ExteriorLabel->SetName("Exterior");
   m_ExteriorLabel->SetOpacity(0.0);
   m_ExteriorLabel->SetLocked(false);
   m_ExteriorLabel->SetValue(0);
 
   // Add some DICOM Tags as properties to segmentation image
   DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
 }
 
 mitk::LabelSetImage::LabelSetImage(const mitk::LabelSetImage &other)
   : Image(other),
     m_ActiveLayer(other.GetActiveLayer()),
     m_activeLayerInvalid(false),
     m_ExteriorLabel(other.GetExteriorLabel()->Clone())
 {
   for (unsigned int i = 0; i < other.GetNumberOfLayers(); i++)
   {
     // Clone LabelSet data
     mitk::LabelSet::Pointer lsClone = other.GetLabelSet(i)->Clone();
     // add modified event listener to LabelSet (listen to LabelSet changes)
     itk::SimpleMemberCommand<Self>::Pointer command = itk::SimpleMemberCommand<Self>::New();
     command->SetCallbackFunction(this, &mitk::LabelSetImage::OnLabelSetModified);
     lsClone->AddObserver(itk::ModifiedEvent(), command);
     m_LabelSetContainer.push_back(lsClone);
 
     // clone layer Image data
     mitk::Image::Pointer liClone = other.GetLayerImage(i)->Clone();
     m_LayerContainer.push_back(liClone);
   }
 
   // Add some DICOM Tags as properties to segmentation image
   DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
 }
 
 void mitk::LabelSetImage::OnLabelSetModified()
 {
   Superclass::Modified();
 }
 
 void mitk::LabelSetImage::SetExteriorLabel(mitk::Label *label)
 {
   m_ExteriorLabel = label;
 }
 
 mitk::Label *mitk::LabelSetImage::GetExteriorLabel()
 {
   return m_ExteriorLabel;
 }
 
 const mitk::Label *mitk::LabelSetImage::GetExteriorLabel() const
 {
   return m_ExteriorLabel;
 }
 
 void mitk::LabelSetImage::Initialize(const mitk::Image *other)
 {
   mitk::PixelType pixelType(mitk::MakeScalarPixelType<LabelSetImage::PixelType>());
   if (other->GetDimension() == 2)
   {
     const unsigned int dimensions[] = {other->GetDimension(0), other->GetDimension(1), 1};
     Superclass::Initialize(pixelType, 3, dimensions);
   }
   else
   {
     Superclass::Initialize(pixelType, other->GetDimension(), other->GetDimensions());
   }
 
   auto originalGeometry = other->GetTimeGeometry()->Clone();
   this->SetTimeGeometry(originalGeometry);
 
   // initialize image memory to zero
   if (4 == this->GetDimension())
   {
     AccessFixedDimensionByItk(this, SetToZero, 4);
   }
   else
   {
     AccessByItk(this, SetToZero);
   }
 
   // Transfer some general DICOM properties from the source image to derived image (e.g. Patient information,...)
   DICOMQIPropertyHelper::DeriveDICOMSourceProperties(other, this);
 
   // Add a inital LabelSet ans corresponding image data to the stack
   AddLayer();
 }
 
 mitk::LabelSetImage::~LabelSetImage()
 {
   m_LabelSetContainer.clear();
 }
 
 mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer)
 {
   return m_LayerContainer[layer];
 }
 
 const mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer) const
 {
   return m_LayerContainer[layer];
 }
 
 unsigned int mitk::LabelSetImage::GetActiveLayer() const
 {
   return m_ActiveLayer;
 }
 
 unsigned int mitk::LabelSetImage::GetNumberOfLayers() const
 {
   return m_LabelSetContainer.size();
 }
 
 void mitk::LabelSetImage::RemoveLayer()
 {
   int layerToDelete = GetActiveLayer();
   // remove all observers from active label set
   GetLabelSet(layerToDelete)->RemoveAllObservers();
 
   // set the active layer to one below, if exists.
   if (layerToDelete != 0)
   {
     SetActiveLayer(layerToDelete - 1);
   }
   else
   {
     // we are deleting layer zero, it should not be copied back into the vector
     m_activeLayerInvalid = true;
   }
 
   // remove labelset and image data
   m_LabelSetContainer.erase(m_LabelSetContainer.begin() + layerToDelete);
   m_LayerContainer.erase(m_LayerContainer.begin() + layerToDelete);
 
   if (layerToDelete == 0)
   {
     this->SetActiveLayer(layerToDelete);
   }
 
   this->Modified();
 }
 
 unsigned int mitk::LabelSetImage::AddLayer(mitk::LabelSet::Pointer lset)
 {
   mitk::Image::Pointer newImage = mitk::Image::New();
   newImage->Initialize(this->GetPixelType(),
                        this->GetDimension(),
                        this->GetDimensions(),
                        this->GetImageDescriptor()->GetNumberOfChannels());
   newImage->SetTimeGeometry(this->GetTimeGeometry()->Clone());
 
   if (newImage->GetDimension() < 4)
   {
     AccessByItk(newImage, SetToZero);
   }
   else
   {
     AccessFixedDimensionByItk(newImage, SetToZero, 4);
   }
 
   unsigned int newLabelSetId = this->AddLayer(newImage, lset);
 
   return newLabelSetId;
 }
 
 unsigned int mitk::LabelSetImage::AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset)
 {
   unsigned int newLabelSetId = m_LayerContainer.size();
 
   // Add labelset to layer
   mitk::LabelSet::Pointer ls;
   if (lset.IsNotNull())
   {
     ls = lset;
   }
   else
   {
     ls = mitk::LabelSet::New();
     ls->AddLabel(GetExteriorLabel());
     ls->SetActiveLabel(0 /*Exterior Label*/);
   }
 
   ls->SetLayer(newLabelSetId);
   // Add exterior Label to label set
   // mitk::Label::Pointer exteriorLabel = CreateExteriorLabel();
 
   // push a new working image for the new layer
   m_LayerContainer.push_back(layerImage);
 
   // push a new labelset for the new layer
   m_LabelSetContainer.push_back(ls);
 
   // add modified event listener to LabelSet (listen to LabelSet changes)
   itk::SimpleMemberCommand<Self>::Pointer command = itk::SimpleMemberCommand<Self>::New();
   command->SetCallbackFunction(this, &mitk::LabelSetImage::OnLabelSetModified);
   ls->AddObserver(itk::ModifiedEvent(), command);
 
   SetActiveLayer(newLabelSetId);
   // MITK_INFO << GetActiveLayer();
   this->Modified();
   return newLabelSetId;
 }
 
 void mitk::LabelSetImage::AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet)
 {
   if (m_LayerContainer.size() <= layerIdx)
   {
     mitkThrow() << "Trying to add labelSet to non-existing layer.";
   }
 
   if (layerIdx < m_LabelSetContainer.size())
   {
     m_LabelSetContainer[layerIdx] = labelSet;
   }
   else
   {
     while (layerIdx >= m_LabelSetContainer.size())
     {
       mitk::LabelSet::Pointer defaultLabelSet = mitk::LabelSet::New();
       defaultLabelSet->AddLabel(GetExteriorLabel());
       defaultLabelSet->SetActiveLabel(0 /*Exterior Label*/);
       defaultLabelSet->SetLayer(m_LabelSetContainer.size());
       m_LabelSetContainer.push_back(defaultLabelSet);
     }
     m_LabelSetContainer.push_back(labelSet);
   }
 }
 
 void mitk::LabelSetImage::SetActiveLayer(unsigned int layer)
 {
   try
   {
     if (4 == this->GetDimension())
     {
       if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
       {
         BeforeChangeLayerEvent.Send();
 
         if (m_activeLayerInvalid)
         {
           // We should not write the invalid layer back to the vector
           m_activeLayerInvalid = false;
         }
         else
         {
           AccessFixedDimensionByItk_n(this, ImageToLayerContainerProcessing, 4, (GetActiveLayer()));
         }
         m_ActiveLayer = layer; // only at this place m_ActiveLayer should be manipulated!!! Use Getter and Setter
         AccessFixedDimensionByItk_n(this, LayerContainerToImageProcessing, 4, (GetActiveLayer()));
 
         AfterChangeLayerEvent.Send();
       }
     }
     else
     {
       if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
       {
         BeforeChangeLayerEvent.Send();
 
         if (m_activeLayerInvalid)
         {
           // We should not write the invalid layer back to the vector
           m_activeLayerInvalid = false;
         }
         else
         {
           AccessByItk_1(this, ImageToLayerContainerProcessing, GetActiveLayer());
         }
         m_ActiveLayer = layer; // only at this place m_ActiveLayer should be manipulated!!! Use Getter and Setter
         AccessByItk_1(this, LayerContainerToImageProcessing, GetActiveLayer());
 
         AfterChangeLayerEvent.Send();
       }
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   this->Modified();
 }
 
 void mitk::LabelSetImage::Concatenate(mitk::LabelSetImage *other)
 {
   const unsigned int *otherDims = other->GetDimensions();
   const unsigned int *thisDims = this->GetDimensions();
   if ((otherDims[0] != thisDims[0]) || (otherDims[1] != thisDims[1]) || (otherDims[2] != thisDims[2]))
     mitkThrow() << "Dimensions do not match.";
 
   try
   {
     int numberOfLayers = other->GetNumberOfLayers();
     for (int layer = 0; layer < numberOfLayers; ++layer)
     {
       this->SetActiveLayer(layer);
       AccessByItk_1(this, ConcatenateProcessing, other);
       mitk::LabelSet *ls = other->GetLabelSet(layer);
       auto it = ls->IteratorConstBegin();
       auto end = ls->IteratorConstEnd();
       it++; // skip exterior
       while (it != end)
       {
         GetLabelSet()->AddLabel((it->second));
         // AddLabelEvent.Send();
         it++;
       }
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   this->Modified();
 }
 
 void mitk::LabelSetImage::ClearBuffer()
 {
   try
   {
     AccessByItk(this, ClearBufferProcessing);
     this->Modified();
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
 }
 
 bool mitk::LabelSetImage::ExistLabel(PixelType pixelValue) const
 {
   bool exist = false;
   for (unsigned int lidx = 0; lidx < GetNumberOfLayers(); lidx++)
     exist |= m_LabelSetContainer[lidx]->ExistLabel(pixelValue);
   return exist;
 }
 
 bool mitk::LabelSetImage::ExistLabel(PixelType pixelValue, unsigned int layer) const
 {
   bool exist = m_LabelSetContainer[layer]->ExistLabel(pixelValue);
   return exist;
 }
 
 bool mitk::LabelSetImage::ExistLabelSet(unsigned int layer) const
 {
   return layer < m_LabelSetContainer.size();
 }
 
 void mitk::LabelSetImage::MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer)
 {
   try
   {
     AccessByItk_2(this, MergeLabelProcessing, pixelValue, sourcePixelValue);
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   GetLabelSet(layer)->SetActiveLabel(pixelValue);
   Modified();
 }
 
 void mitk::LabelSetImage::MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer)
 {
   try
   {
     for (unsigned int idx = 0; idx < vectorOfSourcePixelValues.size(); idx++)
     {
       AccessByItk_2(this, MergeLabelProcessing, pixelValue, vectorOfSourcePixelValues[idx]);
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   GetLabelSet(layer)->SetActiveLabel(pixelValue);
   Modified();
 }
 
 void mitk::LabelSetImage::RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer)
 {
   for (unsigned int idx = 0; idx < VectorOfLabelPixelValues.size(); idx++)
   {
     GetLabelSet(layer)->RemoveLabel(VectorOfLabelPixelValues[idx]);
     EraseLabel(VectorOfLabelPixelValues[idx], layer);
   }
 }
 
 void mitk::LabelSetImage::EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer)
 {
   for (unsigned int i = 0; i < VectorOfLabelPixelValues.size(); i++)
   {
     this->EraseLabel(VectorOfLabelPixelValues[i], layer);
   }
 }
 
 void mitk::LabelSetImage::EraseLabel(PixelType pixelValue, unsigned int layer)
 {
   try
   {
     AccessByItk_2(this, EraseLabelProcessing, pixelValue, layer);
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   Modified();
 }
 
 mitk::Label *mitk::LabelSetImage::GetActiveLabel(unsigned int layer)
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
-    return m_LabelSetContainer[layer]->GetActiveLabel();;
+    return m_LabelSetContainer[layer]->GetActiveLabel();
+}
+
+const mitk::Label* mitk::LabelSetImage::GetActiveLabel(unsigned int layer) const
+{
+  if (m_LabelSetContainer.size() <= layer)
+    return nullptr;
+  else
+    return m_LabelSetContainer[layer]->GetActiveLabel();
 }
 
 mitk::Label *mitk::LabelSetImage::GetLabel(PixelType pixelValue, unsigned int layer) const
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer]->GetLabel(pixelValue);
 }
 
 mitk::LabelSet *mitk::LabelSetImage::GetLabelSet(unsigned int layer)
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer].GetPointer();
 }
 
 const mitk::LabelSet *mitk::LabelSetImage::GetLabelSet(unsigned int layer) const
 {
   if (m_LabelSetContainer.size() <= layer)
     return nullptr;
   else
     return m_LabelSetContainer[layer].GetPointer();
 }
 
 mitk::LabelSet *mitk::LabelSetImage::GetActiveLabelSet()
 {
   if (m_LabelSetContainer.size() == 0)
     return nullptr;
   else
     return m_LabelSetContainer[GetActiveLayer()].GetPointer();
 }
 
+const mitk::LabelSet* mitk::LabelSetImage::GetActiveLabelSet() const
+{
+  if (m_LabelSetContainer.size() == 0)
+    return nullptr;
+  else
+    return m_LabelSetContainer[GetActiveLayer()].GetPointer();
+}
+
 void mitk::LabelSetImage::UpdateCenterOfMass(PixelType pixelValue, unsigned int layer)
 {
   if (4 == this->GetDimension())
   {
     AccessFixedDimensionByItk_2(this, CalculateCenterOfMassProcessing, 4, pixelValue, layer);
   }
   else
   {
     AccessByItk_2(this, CalculateCenterOfMassProcessing, pixelValue, layer);
   }
 }
 
 unsigned int mitk::LabelSetImage::GetNumberOfLabels(unsigned int layer) const
 {
   return m_LabelSetContainer[layer]->GetNumberOfLabels();
 }
 
 unsigned int mitk::LabelSetImage::GetTotalNumberOfLabels() const
 {
   unsigned int totalLabels(0);
   auto layerIter = m_LabelSetContainer.begin();
   for (; layerIter != m_LabelSetContainer.end(); ++layerIter)
     totalLabels += (*layerIter)->GetNumberOfLabels();
   return totalLabels;
 }
 
 void mitk::LabelSetImage::MaskStamp(mitk::Image *mask, bool forceOverwrite)
 {
   try
   {
     mitk::PadImageFilter::Pointer padImageFilter = mitk::PadImageFilter::New();
     padImageFilter->SetInput(0, mask);
     padImageFilter->SetInput(1, this);
     padImageFilter->SetPadConstant(0);
     padImageFilter->SetBinaryFilter(false);
     padImageFilter->SetLowerThreshold(0);
     padImageFilter->SetUpperThreshold(1);
 
     padImageFilter->Update();
 
     mitk::Image::Pointer paddedMask = padImageFilter->GetOutput();
 
     if (paddedMask.IsNull())
       return;
 
     AccessByItk_2(this, MaskStampProcessing, paddedMask, forceOverwrite);
   }
   catch (...)
   {
     mitkThrow() << "Could not stamp the provided mask on the selected label.";
   }
 }
 
 mitk::Image::Pointer mitk::LabelSetImage::CreateLabelMask(PixelType index, bool useActiveLayer, unsigned int layer)
 {
   auto previousActiveLayer = this->GetActiveLayer();
   auto mask = mitk::Image::New();
 
   try
   {
     mask->Initialize(this);
 
     auto byteSize = sizeof(LabelSetImage::PixelType);
     for (unsigned int dim = 0; dim < mask->GetDimension(); ++dim)
       byteSize *= mask->GetDimension(dim);
 
     {
       ImageWriteAccessor accessor(mask);
       memset(accessor.GetData(), 0, byteSize);
     }
 
     if (!useActiveLayer)
       this->SetActiveLayer(layer);
 
     if (4 == this->GetDimension())
     {
       ::CreateLabelMaskProcessing<4>(this, mask, index);
     }
     else if (3 == this->GetDimension())
     {
       ::CreateLabelMaskProcessing(this, mask, index);
     }
     else
     {
       mitkThrow();
     }
   }
   catch (...)
   {
     if (!useActiveLayer)
       this->SetActiveLayer(previousActiveLayer);
 
     mitkThrow() << "Could not create a mask out of the selected label.";
   }
 
   if (!useActiveLayer)
     this->SetActiveLayer(previousActiveLayer);
 
   return mask;
 }
 
 void mitk::LabelSetImage::InitializeByLabeledImage(mitk::Image::Pointer image)
 {
   if (image.IsNull() || image->IsEmpty() || !image->IsInitialized())
     mitkThrow() << "Invalid labeled image.";
 
   try
   {
     this->Initialize(image);
 
     unsigned int byteSize = sizeof(LabelSetImage::PixelType);
     for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
     {
       byteSize *= image->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor *accessor = new mitk::ImageWriteAccessor(static_cast<mitk::Image *>(this));
     memset(accessor->GetData(), 0, byteSize);
     delete accessor;
 
     auto geometry = image->GetTimeGeometry()->Clone();
     this->SetTimeGeometry(geometry);
 
     if (image->GetDimension() == 3)
     {
       AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 3);
     }
     else if (image->GetDimension() == 4)
     {
       AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 4);
     }
     else
     {
       mitkThrow() << image->GetDimension() << "-dimensional label set images not yet supported";
     }
   }
   catch (...)
   {
     mitkThrow() << "Could not intialize by provided labeled image.";
   }
   this->Modified();
 }
 
 template <typename LabelSetImageType, typename ImageType>
 void mitk::LabelSetImage::InitializeByLabeledImageProcessing(LabelSetImageType *labelSetImage, ImageType *image)
 {
   typedef itk::ImageRegionConstIteratorWithIndex<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<LabelSetImageType> TargetIteratorType;
 
   TargetIteratorType targetIter(labelSetImage, labelSetImage->GetRequestedRegion());
   targetIter.GoToBegin();
 
   SourceIteratorType sourceIter(image, image->GetRequestedRegion());
   sourceIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     auto sourceValue = static_cast<PixelType>(sourceIter.Get());
     targetIter.Set(sourceValue);
 
     if (!this->ExistLabel(sourceValue))
     {
       std::stringstream name;
       name << "object-" << sourceValue;
 
       double rgba[4];
       m_LabelSetContainer[this->GetActiveLayer()]->GetLookupTable()->GetTableValue(sourceValue, rgba);
 
       mitk::Color color;
       color.SetRed(rgba[0]);
       color.SetGreen(rgba[1]);
       color.SetBlue(rgba[2]);
 
       auto label = mitk::Label::New();
       label->SetName(name.str().c_str());
       label->SetColor(color);
       label->SetOpacity(rgba[3]);
       label->SetValue(sourceValue);
 
       this->GetLabelSet()->AddLabel(label);
 
       if (GetActiveLabelSet()->GetNumberOfLabels() >= mitk::Label::MAX_LABEL_VALUE ||
           sourceValue >= mitk::Label::MAX_LABEL_VALUE)
         this->AddLayer();
     }
 
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::MaskStampProcessing(ImageType *itkImage, mitk::Image *mask, bool forceOverwrite)
 {
   typename ImageType::Pointer itkMask;
   mitk::CastToItkImage(mask, itkMask);
 
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(itkMask, itkMask->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(itkImage, itkImage->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   int activeLabel = this->GetActiveLabel(GetActiveLayer())->GetValue();
 
   while (!sourceIter.IsAtEnd())
   {
     PixelType sourceValue = sourceIter.Get();
     PixelType targetValue = targetIter.Get();
 
     if ((sourceValue != 0) &&
         (forceOverwrite || !this->GetLabel(targetValue)->GetLocked())) // skip exterior and locked labels
     {
       targetIter.Set(activeLabel);
     }
     ++sourceIter;
     ++targetIter;
   }
 
   this->Modified();
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::CalculateCenterOfMassProcessing(ImageType *itkImage, PixelType pixelValue, unsigned int layer)
 {
   // for now, we just retrieve the voxel in the middle
   typedef itk::ImageRegionConstIterator<ImageType> IteratorType;
   IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
   iter.GoToBegin();
 
   std::vector<typename ImageType::IndexType> indexVector;
 
   while (!iter.IsAtEnd())
   {
     // TODO fix comparison warning more effective
     if (iter.Get() == pixelValue)
     {
       indexVector.push_back(iter.GetIndex());
     }
     ++iter;
   }
 
   mitk::Point3D pos;
   pos.Fill(0.0);
 
   if (!indexVector.empty())
   {
     typename itk::ImageRegionConstIteratorWithIndex<ImageType>::IndexType centerIndex;
     centerIndex = indexVector.at(indexVector.size() / 2);
     if (centerIndex.GetIndexDimension() == 3)
     {
       pos[0] = centerIndex[0];
       pos[1] = centerIndex[1];
       pos[2] = centerIndex[2];
     }
     else
       return;
   }
 
   GetLabelSet(layer)->GetLabel(pixelValue)->SetCenterOfMassIndex(pos);
   this->GetSlicedGeometry()->IndexToWorld(pos, pos); // TODO: TimeGeometry?
   GetLabelSet(layer)->GetLabel(pixelValue)->SetCenterOfMassCoordinates(pos);
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::ClearBufferProcessing(ImageType *itkImage)
 {
   itkImage->FillBuffer(0);
 }
 
 // todo: concatenate all layers and not just the active one
 template <typename ImageType>
 void mitk::LabelSetImage::ConcatenateProcessing(ImageType *itkTarget, mitk::LabelSetImage *other)
 {
   typename ImageType::Pointer itkSource = ImageType::New();
   mitk::CastToItkImage(other, itkSource);
 
   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
   typedef itk::ImageRegionIterator<ImageType> IteratorType;
 
   ConstIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
   IteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
 
   int numberOfTargetLabels = this->GetNumberOfLabels(GetActiveLayer()) - 1; // skip exterior
   sourceIter.GoToBegin();
   targetIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     PixelType sourceValue = sourceIter.Get();
     PixelType targetValue = targetIter.Get();
     if ((sourceValue != 0) && !this->GetLabel(targetValue)->GetLocked()) // skip exterior and locked labels
     {
       targetIter.Set(sourceValue + numberOfTargetLabels);
     }
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::LabelSetImage::LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *target,
                                                           unsigned int layer)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename ImageType::Pointer itkSource;
   // mitk::CastToItkImage(m_LayerContainer[layer], itkSource);
   itkSource = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(target, target->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     targetIter.Set(sourceIter.Get());
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::LabelSetImage::ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source,
                                                           unsigned int layer) const
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename ImageType::Pointer itkTarget;
   // mitk::CastToItkImage(m_LayerContainer[layer], itkTarget);
   itkTarget = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
 
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(source, source->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     targetIter.Set(sourceIter.Get());
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue, unsigned int /*layer*/)
 {
   typedef itk::ImageRegionIterator<ImageType> IteratorType;
 
   IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
   iter.GoToBegin();
 
   while (!iter.IsAtEnd())
   {
     PixelType value = iter.Get();
 
     if (value == pixelValue)
     {
       iter.Set(0);
     }
     ++iter;
   }
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::MergeLabelProcessing(ImageType *itkImage, PixelType pixelValue, PixelType index)
 {
   typedef itk::ImageRegionIterator<ImageType> IteratorType;
 
   IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
   iter.GoToBegin();
 
   while (!iter.IsAtEnd())
   {
     if (iter.Get() == index)
     {
       iter.Set(pixelValue);
     }
     ++iter;
   }
 }
 
 bool mitk::Equal(const mitk::LabelSetImage &leftHandSide,
                  const mitk::LabelSetImage &rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   bool returnValue = true;
 
   /* LabelSetImage members */
 
   MITK_INFO(verbose) << "--- LabelSetImage Equal ---";
 
   // number layers
   returnValue = leftHandSide.GetNumberOfLayers() == rightHandSide.GetNumberOfLayers();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Number of layers not equal.";
     return false;
   }
 
   // total number labels
   returnValue = leftHandSide.GetTotalNumberOfLabels() == rightHandSide.GetTotalNumberOfLabels();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Total number of labels not equal.";
     return false;
   }
 
   // active layer
   returnValue = leftHandSide.GetActiveLayer() == rightHandSide.GetActiveLayer();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Active layer not equal.";
     return false;
   }
 
   if (4 == leftHandSide.GetDimension())
   {
     MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
   }
   else
   {
     // working image data
     returnValue = mitk::Equal((const mitk::Image &)leftHandSide, (const mitk::Image &)rightHandSide, eps, verbose);
     if (!returnValue)
     {
       MITK_INFO(verbose) << "Working image data not equal.";
       return false;
     }
   }
 
   for (unsigned int layerIndex = 0; layerIndex < leftHandSide.GetNumberOfLayers(); layerIndex++)
   {
     if (4 == leftHandSide.GetDimension())
     {
       MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
     }
     else
     {
       // layer image data
       returnValue =
         mitk::Equal(*leftHandSide.GetLayerImage(layerIndex), *rightHandSide.GetLayerImage(layerIndex), eps, verbose);
       if (!returnValue)
       {
         MITK_INFO(verbose) << "Layer image data not equal.";
         return false;
       }
     }
     // layer labelset data
 
     returnValue =
       mitk::Equal(*leftHandSide.GetLabelSet(layerIndex), *rightHandSide.GetLabelSet(layerIndex), eps, verbose);
     if (!returnValue)
     {
       MITK_INFO(verbose) << "Layer labelset data not equal.";
       return false;
     }
   }
 
   return returnValue;
 }
diff --git a/Modules/Multilabel/mitkLabelSetImage.h b/Modules/Multilabel/mitkLabelSetImage.h
index e65e6752e8..2d02b05287 100644
--- a/Modules/Multilabel/mitkLabelSetImage.h
+++ b/Modules/Multilabel/mitkLabelSetImage.h
@@ -1,340 +1,342 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 #ifndef __mitkLabelSetImage_H_
 #define __mitkLabelSetImage_H_
 
 #include <mitkImage.h>
 #include <mitkLabelSet.h>
 
 #include <MitkMultilabelExports.h>
 
 namespace mitk
 {
   //##Documentation
   //## @brief LabelSetImage class for handling labels and layers in a segmentation session.
   //##
   //## Handles operations for adding, removing, erasing and editing labels and layers.
   //## @ingroup Data
 
   class MITKMULTILABEL_EXPORT LabelSetImage : public Image
   {
   public:
     mitkClassMacro(LabelSetImage, Image);
     itkNewMacro(Self);
 
       typedef mitk::Label::PixelType PixelType;
 
     /**
     * \brief BeforeChangeLayerEvent (e.g. used for GUI integration)
     * As soon as active labelset should be changed, the signal emits.
     * Emitted by SetActiveLayer(int layer);
     */
     Message<> BeforeChangeLayerEvent;
 
     /**
     * \brief AfterchangeLayerEvent (e.g. used for GUI integration)
     * As soon as active labelset was changed, the signal emits.
     * Emitted by SetActiveLayer(int layer);
     */
     Message<> AfterChangeLayerEvent;
 
     /**
      * @brief Initialize an empty mitk::LabelSetImage using the information
      *        of an mitk::Image
      * @param image the image which is used for initializing the mitk::LabelSetImage
      */
     using mitk::Image::Initialize;
     void Initialize(const mitk::Image *image) override;
 
     /**
       * \brief  */
     void Concatenate(mitk::LabelSetImage *image);
 
     /**
       * \brief  */
     void ClearBuffer();
 
     /**
      * @brief Merges the mitk::Label with a given target value with the active label
      *
      * @param pixelValue          the value of the label that should be the new merged label
      * @param sourcePixelValue    the value of the label that should be merged into the specified one
      * @param layer               the layer in which the merge should be performed
      */
     void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer = 0);
 
     /**
      * @brief Merges a list of mitk::Labels with the mitk::Label that has a specific value
      *
      * @param pixelValue                  the value of the label that should be the new merged label
      * @param vectorOfSourcePixelValues   the list of label values that should be merge into the specified one
      * @param layer                       the layer in which the merge should be performed
      */
     void MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer = 0);
 
     /**
       * \brief  */
     void UpdateCenterOfMass(PixelType pixelValue, unsigned int layer = 0);
 
     /**
      * @brief Removes labels from the mitk::LabelSet of given layer.
      *        Calls mitk::LabelSetImage::EraseLabels() which also removes the labels from within the image.
      * @param VectorOfLabelPixelValues a list of labels to be removed
      * @param layer the layer in which the labels should be removed
      */
     void RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);
 
     /**
      * @brief Erases the label with the given value in the given layer from the underlying image.
      *        The label itself will not be erased from the respective mitk::LabelSet. In order to
      *        remove the label itself use mitk::LabelSetImage::RemoveLabels()
      * @param pixelValue the label which will be remove from the image
      * @param layer the layer in which the label should be removed
      */
     void EraseLabel(PixelType pixelValue, unsigned int layer = 0);
 
     /**
      * @brief Similar to mitk::LabelSetImage::EraseLabel() this funtion erase a list of labels from the image
      * @param VectorOfLabelPixelValues the list of labels that should be remove
      * @param layer the layer for which the labels should be removed
      */
     void EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);
 
     /**
       * \brief  Returns true if the value exists in one of the labelsets*/
     bool ExistLabel(PixelType pixelValue) const;
 
     /**
      * @brief Checks if a label exists in a certain layer
      * @param pixelValue the label value
      * @param layer the layer in which should be searched for the label
      * @return true if the label exists otherwise false
      */
     bool ExistLabel(PixelType pixelValue, unsigned int layer) const;
 
     /**
       * \brief  Returns true if the labelset exists*/
     bool ExistLabelSet(unsigned int layer) const;
 
     /**
      * @brief Returns the active label of a specific layer
      * @param layer the layer ID for which the active label should be returned
      * @return the active label of the specified layer
      */
     mitk::Label *GetActiveLabel(unsigned int layer = 0);
+    const mitk::Label* GetActiveLabel(unsigned int layer = 0) const;
 
     /**
      * @brief Returns the mitk::Label with the given pixelValue and for the given layer
      * @param pixelValue the pixel value of the label
      * @param layer the layer in which the labels should be located
      * @return the mitk::Label if available otherwise nullptr
      */
     mitk::Label *GetLabel(PixelType pixelValue, unsigned int layer = 0) const;
 
     /**
      * @brief Returns the currently active mitk::LabelSet
      * @return the mitk::LabelSet of the active layer or nullptr if non is present
      */
     mitk::LabelSet *GetActiveLabelSet();
+    const mitk::LabelSet* GetActiveLabelSet() const;
 
     /**
      * @brief Gets the mitk::LabelSet for the given layer
      * @param layer the layer for which the mitk::LabelSet should be retrieved
      * @return the respective mitk::LabelSet or nullptr if non exists for the given layer
      */
     mitk::LabelSet *GetLabelSet(unsigned int layer = 0);
     const mitk::LabelSet *GetLabelSet(unsigned int layer = 0) const;
 
     /**
      * @brief Gets the ID of the currently active layer
      * @return the ID of the active layer
      */
     unsigned int GetActiveLayer() const;
 
     /**
      * @brief Get the number of all existing mitk::Labels for a given layer
      * @param layer the layer ID for which the active mitk::Labels should be retrieved
      * @return the number of all existing mitk::Labels for the given layer
      */
     unsigned int GetNumberOfLabels(unsigned int layer = 0) const;
 
     /**
      * @brief Returns the number of all labels summed up across all layers
      * @return the overall number of labels across all layers
      */
     unsigned int GetTotalNumberOfLabels() const;
 
     // This function will need to be ported to an external class
     // it requires knowledge of pixeltype and dimension and includes
     // too much algorithm to be sensibly part of a data class
     ///**
     //  * \brief  */
     // void SurfaceStamp(mitk::Surface* surface, bool forceOverwrite);
 
     /**
       * \brief  */
     mitk::Image::Pointer CreateLabelMask(PixelType index, bool useActiveLayer = true, unsigned int layer = 0);
 
     /**
      * @brief Initialize a new mitk::LabelSetImage by an given image.
      * For all distinct pixel values of the parameter image new labels will
      * be created. If the number of distinct pixel values exceeds mitk::Label::MAX_LABEL_VALUE
      * a new layer will be created
      * @param image the image which is used for initialization
      */
     void InitializeByLabeledImage(mitk::Image::Pointer image);
 
     /**
       * \brief  */
     void MaskStamp(mitk::Image *mask, bool forceOverwrite);
 
     /**
       * \brief  */
     void SetActiveLayer(unsigned int layer);
 
     /**
       * \brief  */
     unsigned int GetNumberOfLayers() const;
 
     /**
      * @brief Adds a new layer to the LabelSetImage. The new layer will be set as the active one
      * @param layer a mitk::LabelSet which will be set as new layer.
      * @return the layer ID of the new layer
      */
     unsigned int AddLayer(mitk::LabelSet::Pointer layer = nullptr);
 
     /**
     * \brief Add a layer based on a provided mitk::Image
     * \param layerImage is added to the vector of label images
     * \param lset a label set that will be added to the new layer if provided
     *\return the layer ID of the new layer
     */
     unsigned int AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset = nullptr);
 
     /**
     * \brief Add a LabelSet to an existing layer
     *
     * This will replace an existing labelSet if one exists. Throws an exceptions if you are trying
     * to add a labelSet to a non-existing layer.
     *
     * If there are no labelSets for layers with an id less than layerIdx default ones will be added
     * for them.
     *
     * \param layerIdx The index of the layer the LabelSet should be added to
     * \param labelSet The LabelSet that should be added
     */
     void AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet);
 
     /**
      * @brief Removes the active layer and the respective mitk::LabelSet and image information.
      *        The new active layer is the one below, if exists
      */
     void RemoveLayer();
 
     /**
       * \brief  */
     mitk::Image *GetLayerImage(unsigned int layer);
 
     const mitk::Image *GetLayerImage(unsigned int layer) const;
 
     void OnLabelSetModified();
 
     /**
      * @brief Sets the label which is used as default exterior label when creating a new layer
      * @param label the label which will be used as new exterior label
      */
     void SetExteriorLabel(mitk::Label *label);
 
     /**
      * @brief Gets the mitk::Label which is used as default exterior label
      * @return the exterior mitk::Label
      */
     mitk::Label *GetExteriorLabel();
 
     const mitk::Label *GetExteriorLabel() const;
 
   protected:
     mitkCloneMacro(Self);
 
       LabelSetImage();
     LabelSetImage(const LabelSetImage &other);
     ~LabelSetImage() override;
 
     template <typename ImageType1, typename ImageType2>
     void ChangeLayerProcessing(ImageType1 *source, ImageType2 *target);
 
     template <typename TPixel, unsigned int VImageDimension>
     void LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer);
 
     template <typename TPixel, unsigned int VImageDimension>
     void ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
 
     template <typename ImageType>
     void CalculateCenterOfMassProcessing(ImageType *input, PixelType index, unsigned int layer);
 
     template <typename ImageType>
     void ClearBufferProcessing(ImageType *input);
 
     template <typename ImageType>
     void EraseLabelProcessing(ImageType *input, PixelType index, unsigned int layer);
 
     //  template < typename ImageType >
     //  void ReorderLabelProcessing( ImageType* input, int index, int layer);
 
     template <typename ImageType>
     void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);
 
     template <typename ImageType>
     void ConcatenateProcessing(ImageType *input, mitk::LabelSetImage *other);
 
     template <typename ImageType>
     void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);
 
     template <typename LabelSetImageType, typename ImageType>
     void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);
 
     std::vector<LabelSet::Pointer> m_LabelSetContainer;
     std::vector<Image::Pointer> m_LayerContainer;
 
     int m_ActiveLayer;
 
     bool m_activeLayerInvalid;
 
     mitk::Label::Pointer m_ExteriorLabel;
   };
 
   /**
   * @brief Equal A function comparing two label set images for beeing equal in meta- and imagedata
   *
   * @ingroup MITKTestingAPI
   *
   * Following aspects are tested for equality:
   *  - LabelSetImage members
   *  - working image data
   *  - layer image data
   *  - labels in label set
   *
   * @param rightHandSide An image to be compared
   * @param leftHandSide An image to be compared
   * @param eps Tolerance for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return true, if all subsequent comparisons are true, false otherwise
   */
   MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
                                    const mitk::LabelSetImage &rightHandSide,
                                    ScalarType eps,
                                    bool verbose);
 
 } // namespace mitk
 
 #endif // __mitkLabelSetImage_H_