diff --git a/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp b/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp
index 4764497413..ac53fc9dd6 100644
--- a/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp
+++ b/Modules/Core/src/DataManagement/mitkTemporoSpatialStringProperty.cpp
@@ -1,426 +1,425 @@
 /*============================================================================
 
 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 <iterator>
 #include <set>
 #include <type_traits>
 
 #include "mitkTemporoSpatialStringProperty.h"
 
 #include <nlohmann/json.hpp>
 
 using CondensedTimeKeyType = std::pair<mitk::TimeStepType, mitk::TimeStepType>;
 using CondensedTimePointsType = std::map<CondensedTimeKeyType, std::string>;
 
 using CondensedSliceKeyType = std::pair<mitk::TemporoSpatialStringProperty::IndexValueType, mitk::TemporoSpatialStringProperty::IndexValueType>;
 using CondensedSlicesType = std::map<CondensedSliceKeyType, CondensedTimePointsType>;
 
 namespace
 {
   /** Helper function that checks if between an ID and a successive ID is no gap.*/
   template<typename TValue>
   bool isGap(const TValue& value, const TValue& successor)
   {
     return value<successor || value > successor + 1;
   }
 
 
   template<typename TNewKey, typename TNewValue, typename TMasterKey, typename TMasterValue, typename TCondensedContainer>
   void CheckAndCondenseElement(const TNewKey& newKeyMinID, const TNewValue& newValue, TMasterKey& masterKey, TMasterValue& masterValue, TCondensedContainer& condensedContainer)
   {
     if (newValue != masterValue
       || isGap(newKeyMinID, masterKey.second))
     {
       condensedContainer[masterKey] = masterValue;
       masterValue = newValue;
       masterKey.first = newKeyMinID;
     }
     masterKey.second = newKeyMinID;
   }
 
   /** Helper function that tries to condense the values of time points for a slice as much as possible and returns all slices with condensed timepoint values.*/
   CondensedSlicesType CondenseTimePointValuesOfProperty(const mitk::TemporoSpatialStringProperty* tsProp)
   {
     CondensedSlicesType uncondensedSlices;
 
     auto zs = tsProp->GetAvailableSlices();
     for (const auto z : zs)
     {
       CondensedTimePointsType condensedTimePoints;
       auto timePointIDs = tsProp->GetAvailableTimeSteps(z);
       CondensedTimeKeyType condensedKey = { timePointIDs.front(),timePointIDs.front() };
       auto refValue = tsProp->GetValue(timePointIDs.front(), z);
 
       for (const auto timePointID : timePointIDs)
       {
         const auto& newVal = tsProp->GetValue(timePointID, z);
         CheckAndCondenseElement(timePointID, newVal, condensedKey, refValue, condensedTimePoints);
       }
       condensedTimePoints[condensedKey] = refValue;
       uncondensedSlices[{ z, z }] = condensedTimePoints;
     }
     return uncondensedSlices;
   }
 }
 
 mitk::TemporoSpatialStringProperty::TemporoSpatialStringProperty(const char *s)
 {
   if (s)
   {
     SliceMapType slices{{0, s}};
 
     m_Values.insert(std::make_pair(0, slices));
   }
 }
 
 mitk::TemporoSpatialStringProperty::TemporoSpatialStringProperty(const std::string &s)
 {
   SliceMapType slices{{0, s}};
 
   m_Values.insert(std::make_pair(0, slices));
 }
 
 mitk::TemporoSpatialStringProperty::TemporoSpatialStringProperty(const TemporoSpatialStringProperty &other)
   : BaseProperty(other), m_Values(other.m_Values)
 {
 }
 
 bool mitk::TemporoSpatialStringProperty::IsEqual(const BaseProperty &property) const
 {
   return this->m_Values == static_cast<const Self &>(property).m_Values;
 }
 
 bool mitk::TemporoSpatialStringProperty::Assign(const BaseProperty &property)
 {
   this->m_Values = static_cast<const Self &>(property).m_Values;
   return true;
 }
 
 std::string mitk::TemporoSpatialStringProperty::GetValueAsString() const
 {
   return GetValue();
 }
 
 bool mitk::TemporoSpatialStringProperty::IsUniform() const
 {
   auto refValue = this->GetValue();
 
   for (const auto& timeStep : m_Values)
   {
     auto finding = std::find_if_not(timeStep.second.begin(), timeStep.second.end(), [&refValue](const mitk::TemporoSpatialStringProperty::SliceMapType::value_type& val) { return val.second == refValue; });
     if (finding != timeStep.second.end())
     {
       return false;
     }
   }
 
   return true;
 }
 
 itk::LightObject::Pointer mitk::TemporoSpatialStringProperty::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   result->UnRegister();
   return result;
 }
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValue() const
 {
   std::string result = "";
 
   if (!m_Values.empty())
   {
     if (!m_Values.begin()->second.empty())
     {
       result = m_Values.begin()->second.begin()->second;
     }
   }
   return result;
 };
 
 std::pair<bool, mitk::TemporoSpatialStringProperty::ValueType> mitk::TemporoSpatialStringProperty::CheckValue(
   const TimeStepType &timeStep, const IndexValueType &zSlice, bool allowCloseTime, bool allowCloseSlice) const
 {
   std::string value = "";
   bool found = false;
 
   auto timeIter = m_Values.find(timeStep);
   auto timeEnd = m_Values.end();
   if (timeIter == timeEnd && allowCloseTime)
   { // search for closest time step (earlier preverd)
     timeIter = m_Values.upper_bound(timeStep);
     if (timeIter != m_Values.begin())
     { // there is a key lower than time step
       timeIter = std::prev(timeIter);
     }
   }
 
   if (timeIter != timeEnd)
   {
     const SliceMapType &slices = timeIter->second;
 
     auto sliceIter = slices.find(zSlice);
     auto sliceEnd = slices.end();
     if (sliceIter == sliceEnd && allowCloseSlice)
     { // search for closest slice (earlier preverd)
       sliceIter = slices.upper_bound(zSlice);
       if (sliceIter != slices.begin())
       { // there is a key lower than slice
         sliceIter = std::prev(sliceIter);
       }
     }
 
     if (sliceIter != sliceEnd)
     {
       value = sliceIter->second;
       found = true;
     }
   }
 
   return std::make_pair(found, value);
 };
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValue(const TimeStepType &timeStep,
                                                                                            const IndexValueType &zSlice,
                                                                                            bool allowCloseTime,
                                                                                            bool allowCloseSlice) const
 {
   return CheckValue(timeStep, zSlice, allowCloseTime, allowCloseSlice).second;
 };
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValueBySlice(
   const IndexValueType &zSlice, bool allowClose) const
 {
   return GetValue(0, zSlice, true, allowClose);
 };
 
 mitk::TemporoSpatialStringProperty::ValueType mitk::TemporoSpatialStringProperty::GetValueByTimeStep(
   const TimeStepType &timeStep, bool allowClose) const
 {
   return GetValue(timeStep, 0, allowClose, true);
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValue() const
 {
   return !m_Values.empty();
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValue(const TimeStepType &timeStep,
                                                   const IndexValueType &zSlice,
                                                   bool allowCloseTime,
                                                   bool allowCloseSlice) const
 {
   return CheckValue(timeStep, zSlice, allowCloseTime, allowCloseSlice).first;
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValueBySlice(const IndexValueType &zSlice, bool allowClose) const
 {
   return HasValue(0, zSlice, true, allowClose);
 };
 
 bool mitk::TemporoSpatialStringProperty::HasValueByTimeStep(const TimeStepType &timeStep, bool allowClose) const
 {
   return HasValue(timeStep, 0, allowClose, true);
 };
 
 std::vector<mitk::TemporoSpatialStringProperty::IndexValueType> mitk::TemporoSpatialStringProperty::GetAvailableSlices() const
 {
   std::set<IndexValueType> uniqueSlices;
 
   for (const auto& timeStep : m_Values)
   {
     for (const auto& slice : timeStep.second)
     {
       uniqueSlices.insert(slice.first);
     }
   }
 
   return std::vector<IndexValueType>(std::begin(uniqueSlices), std::end(uniqueSlices));
 }
 
 std::vector<mitk::TemporoSpatialStringProperty::IndexValueType> mitk::TemporoSpatialStringProperty::GetAvailableSlices(
   const TimeStepType &timeStep) const
 {
   std::vector<IndexValueType> result;
 
   auto timeIter = m_Values.find(timeStep);
   auto timeEnd = m_Values.end();
 
   if (timeIter != timeEnd)
   {
     for (auto const &element : timeIter->second)
     {
       result.push_back(element.first);
     }
   }
 
   return result;
 };
 
 std::vector<mitk::TimeStepType> mitk::TemporoSpatialStringProperty::GetAvailableTimeSteps() const
 {
   std::vector<mitk::TimeStepType> result;
 
   for (auto const &element : m_Values)
   {
     result.push_back(element.first);
   }
 
   return result;
 };
 
 std::vector<mitk::TimeStepType> mitk::TemporoSpatialStringProperty::GetAvailableTimeSteps(const IndexValueType& slice) const
 {
   std::vector<mitk::TimeStepType> result;
 
   for (const auto& timeStep : m_Values)
   {
     if (timeStep.second.find(slice) != std::end(timeStep.second))
     {
       result.push_back(timeStep.first);
     }
   }
   return result;
 }
 
 
 void mitk::TemporoSpatialStringProperty::SetValue(const TimeStepType &timeStep,
                                                   const IndexValueType &zSlice,
                                                   const ValueType &value)
 {
   auto timeIter = m_Values.find(timeStep);
   auto timeEnd = m_Values.end();
 
   if (timeIter == timeEnd)
   {
     SliceMapType slices{{zSlice, value}};
     m_Values.insert(std::make_pair(timeStep, slices));
   }
   else
   {
     timeIter->second[zSlice] = value;
   }
   this->Modified();
 };
 
 void mitk::TemporoSpatialStringProperty::SetValue(const ValueType &value)
 {
-  this->Modified();
   m_Values.clear();
   this->SetValue(0, 0, value);
 };
 
 bool mitk::TemporoSpatialStringProperty::ToJSON(nlohmann::json& j) const
 {
   // We condense the content of the property to have a compact serialization.
   // We start with condensing time points and then slices (in difference to the
   // internal layout). Reason: There is more entropy in slices (looking at DICOM)
   // than across time points for one slice, so we can "compress" at a higher rate.
   // We didn't want to change the internal structure of the property as it would
   // introduce API inconvenience and subtle changes in behavior.
   auto uncondensedSlices = CondenseTimePointValuesOfProperty(this);
   CondensedSlicesType condensedSlices;
 
   if(!uncondensedSlices.empty())
   {
     auto& masterSlice = uncondensedSlices.begin()->second;
     auto masterSliceKey = uncondensedSlices.begin()->first;
 
     for (const auto& uncondensedSlice : uncondensedSlices)
     {
       const auto& uncondensedSliceID = uncondensedSlice.first.first;
       CheckAndCondenseElement(uncondensedSliceID, uncondensedSlice.second, masterSliceKey, masterSlice, condensedSlices);
     }
 
     condensedSlices[masterSliceKey] = masterSlice;
   }
 
   auto values = nlohmann::json::array();
 
   for (const auto& z : condensedSlices)
   {
     for (const auto& t : z.second)
     {
       const auto& minSliceID = z.first.first;
       const auto& maxSliceID = z.first.second;
       const auto& minTimePointID = t.first.first;
       const auto& maxTimePointID = t.first.second;
 
       auto value = nlohmann::json::object();
       value["z"] = minSliceID;
 
       if (minSliceID != maxSliceID)
         value["zmax"] = maxSliceID;
 
       value["t"] = minTimePointID;
 
       if (minTimePointID != maxTimePointID)
         value["tmax"] = maxTimePointID;
 
       value["value"] = t.second;
 
       values.push_back(value);
     }
   }
 
   j = nlohmann::json{{"values", values}};
 
   return true;
 }
 
 bool mitk::TemporoSpatialStringProperty::FromJSON(const nlohmann::json& j)
 {
   for (const auto& element : j["values"])
   {
     auto value = element.value("value", "");
     auto z = element.value<TemporoSpatialStringProperty::IndexValueType>("z", 0);
     auto zmax = element.value<TemporoSpatialStringProperty::IndexValueType>("zmax", z);
     auto t = element.value<TimeStepType>("t", 0);
     auto tmax = element.value<TimeStepType>("tmax", t);
 
     for (auto currentT = t; currentT <= tmax; ++currentT)
     {
       for (auto currentZ = z; currentZ <= zmax; ++currentZ)
       {
         this->SetValue(currentT, currentZ, value);
       }
     }
   }
 
   return true;
 }
 
 std::string mitk::PropertyPersistenceSerialization::serializeTemporoSpatialStringPropertyToJSON(const mitk::BaseProperty *prop)
 {
   const auto *tsProp = dynamic_cast<const mitk::TemporoSpatialStringProperty *>(prop);
 
   if (!tsProp)
     mitkThrow() << "Cannot serialize properties of types other than TemporoSpatialStringProperty.";
 
   nlohmann::json j;
   tsProp->ToJSON(j);
 
   return j.dump();
 }
 
 mitk::BaseProperty::Pointer mitk::PropertyPersistenceDeserialization::deserializeJSONToTemporoSpatialStringProperty(const std::string &value)
 {
   if (value.empty())
     return nullptr;
 
   auto prop = mitk::TemporoSpatialStringProperty::New();
 
   auto root = nlohmann::json::parse(value);
   prop->FromJSON(root);
 
   return prop.GetPointer();
 }
diff --git a/Modules/Multilabel/files.cmake b/Modules/Multilabel/files.cmake
index 3253bf602b..cc5f29c1e5 100644
--- a/Modules/Multilabel/files.cmake
+++ b/Modules/Multilabel/files.cmake
@@ -1,22 +1,23 @@
 set(CPP_FILES
   mitkLabel.cpp
   mitkLabelSetImage.cpp
   mitkLabelSetImageConverter.cpp
   mitkLabelSetImageSource.cpp
   mitkLabelSetImageHelper.cpp
   mitkLabelSetImageSurfaceStampFilter.cpp
   mitkLabelSetImageToSurfaceFilter.cpp
   mitkLabelSetImageToSurfaceThreadedFilter.cpp
   mitkLabelSetImageVtkMapper2D.cpp
   mitkMultilabelObjectFactory.cpp
   mitkMultiLabelIOHelper.cpp
   mitkMultiLabelEvents.cpp
   mitkMultiLabelPredicateHelper.cpp
   mitkDICOMSegmentationPropertyHelper.cpp
   mitkDICOMSegmentationConstants.cpp
   mitkSegmentationTaskList.cpp
+  mitkMultiLabelSegmentationVtkMapper3D.cpp
 )
 
 set(RESOURCE_FILES
 
 )
diff --git a/Modules/Multilabel/mitkLabelSetImage.cpp b/Modules/Multilabel/mitkLabelSetImage.cpp
index c53eaec19d..bfb1fdb3b3 100644
--- a/Modules/Multilabel/mitkLabelSetImage.cpp
+++ b/Modules/Multilabel/mitkLabelSetImage.cpp
@@ -1,1719 +1,1722 @@
 /*============================================================================
 
 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 <mitkImagePixelWriteAccessor.h>
 #include <mitkPadImageFilter.h>
 #include <mitkDICOMSegmentationPropertyHelper.h>
 #include <mitkDICOMQIPropertyHelper.h>
 #include <mitkNodePredicateGeometry.h>
 
 #include <itkLabelGeometryImageFilter.h>
 #include <itkCommand.h>
 #include <itkBinaryFunctorImageFilter.h>
 
 
 namespace mitk
 {
   template <typename ImageType>
   void ClearBufferProcessing(ImageType* itkImage)
   {
     itkImage->FillBuffer(0);
   }
 
   void ClearImageBuffer(mitk::Image* image)
   {
     if (image->GetDimension() == 4)
     { //remark: this extra branch was added, because LabelSetImage instances can be
       //dynamic (4D), but AccessByItk by support only supports 2D and 3D.
       //The option to change the CMake default dimensions for AccessByItk was
       //dropped (for details see discussion in T28756)
       AccessFixedDimensionByItk(image, ClearBufferProcessing, 4);
     }
     else
     {
       AccessByItk(image, ClearBufferProcessing);
     }
   }
 }
 
 const mitk::LabelSetImage::LabelValueType mitk::LabelSetImage::UNLABELED_VALUE = 0;
 
 mitk::LabelSetImage::LabelSetImage()
   : mitk::Image(), m_ActiveLabelValue(0), m_UnlabeledLabelLock(false), m_ActiveLayer(0), m_activeLayerInvalid(false)
 {
   m_LookupTable = mitk::LookupTable::New();
   m_LookupTable->SetType(mitk::LookupTable::MULTILABEL);
 
   // Add some DICOM Tags as properties to segmentation image
   DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
 }
 
 mitk::LabelSetImage::LabelSetImage(const mitk::LabelSetImage &other)
   : Image(other),
     m_ActiveLabelValue(other.m_ActiveLabelValue),
     m_LookupTable(other.m_LookupTable->Clone()),
     m_UnlabeledLabelLock(other.m_UnlabeledLabelLock),
     m_ActiveLayer(other.GetActiveLayer()),
     m_activeLayerInvalid(false)
 {
   GroupIndexType i = 0;
   for (auto groupImage : other.m_LayerContainer)
   {
     this->AddLayer(groupImage->Clone(), other.GetConstLabelsByValue(other.GetLabelValuesByGroup(i)));
     i++;
   }
   m_Groups = other.m_Groups;
 
   // Add some DICOM Tags as properties to segmentation image
   DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
 }
 
 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
   ClearImageBuffer(this);
 
   // 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
   if (this->GetNumberOfLayers() == 0)
   {
     AddLayer();
   }
 }
 
 mitk::LabelSetImage::~LabelSetImage()
 {
   for (auto [value, label] : m_LabelMap)
   {
     this->ReleaseLabel(label);
   }
   m_LabelMap.clear();
 }
 
 unsigned int mitk::LabelSetImage::GetActiveLayer() const
 {
   if (m_LayerContainer.size() == 0) mitkThrow() << "Cannot return active layer index. No layer is available.";
 
   return m_ActiveLayer;
 }
 
 unsigned int mitk::LabelSetImage::GetNumberOfLayers() const
 {
   return m_LayerContainer.size();
 }
 
 void mitk::LabelSetImage::RemoveGroup(GroupIndexType indexToDelete)
 {
   if (!this->ExistGroup(indexToDelete)) mitkThrow() << "Cannot remove group. Group does not exist. Invalid group index: "<<indexToDelete;
 
   const auto activeIndex = GetActiveLayer();
 
   auto newActiveIndex = activeIndex;
   auto newActiveIndexBeforeDeletion = activeIndex;
   //determine new active group index (after the group will be removed);
   if (indexToDelete < activeIndex)
   { //lower the index because position in m_LayerContainer etc has changed
     newActiveIndex = activeIndex-1;
   }
   else if (indexToDelete == activeIndex)
   {
     if (this->GetNumberOfLayers() == 1)
     { //last layer is about to be deleted
       newActiveIndex = 0;
     }
     else
     {
       //we have to add/subtract one more because we have not removed the layer yet, thus the group count is to 1 high.
       newActiveIndex = indexToDelete+1 < GetNumberOfLayers() ? indexToDelete : GetNumberOfLayers() - 2;
       newActiveIndexBeforeDeletion = indexToDelete + 1 < GetNumberOfLayers() ? indexToDelete+1 : indexToDelete -1;
     }
   }
 
   if (activeIndex == indexToDelete)
   {
     // we are deleting the active layer, it should not be copied back into the vector
     m_activeLayerInvalid = true;
     //copy the image content of the upcoming new active layer; 
     SetActiveLayer(newActiveIndexBeforeDeletion);
   }
 
   auto relevantLabels = m_GroupToLabelMap[indexToDelete];
 
   {
     std::lock_guard<std::shared_mutex> guard(m_LabelNGroupMapsMutex);
     // remove labels of group
     for (auto labelValue : relevantLabels)
     {
       auto label = m_LabelMap[labelValue];
       this->ReleaseLabel(label);
       m_LabelToGroupMap.erase(labelValue);
       m_LabelMap.erase(labelValue);
       this->InvokeEvent(LabelRemovedEvent(labelValue));
     }
     // remove the group entries in the maps and the image.
     m_Groups.erase(m_Groups.begin() + indexToDelete);
     m_GroupToLabelMap.erase(m_GroupToLabelMap.begin() + indexToDelete);
     m_LayerContainer.erase(m_LayerContainer.begin() + indexToDelete);
   }
 
   //update old indexes in m_GroupToLabelMap to new layer indexes
   for (auto& element : m_LabelToGroupMap)
   {
     if (element.second > indexToDelete) element.second = element.second -1;
   }
 
   //correct active layer index
   m_ActiveLayer = newActiveIndex;
 
   this->InvokeEvent(LabelsChangedEvent(relevantLabels));
   this->InvokeEvent(GroupRemovedEvent(indexToDelete));
   this->Modified();
 }
 
 mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::ExtractLabelValuesFromLabelVector(const LabelVectorType& labels)
 {
   LabelValueVectorType result;
 
   for (auto label : labels)
   {
     result.emplace_back(label->GetValue());
   }
   return result;
 }
 
 mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::ExtractLabelValuesFromLabelVector(const ConstLabelVectorType& labels)
 {
   LabelValueVectorType result;
 
   for (auto label : labels)
   {
     result.emplace_back(label->GetValue());
   }
   return result;
 }
 
 mitk::LabelSetImage::ConstLabelVectorType mitk::LabelSetImage::ConvertLabelVectorConst(const LabelVectorType& labels)
 {
   ConstLabelVectorType result(labels.begin(), labels.end());
   return result;
 };
 
 const mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetAllLabelValues() const
 {
   LabelValueVectorType result;
 
   for (auto [value, label] : m_LabelMap)
   {
     result.emplace_back(value);
   }
   return result;
 }
 
 mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetUsedLabelValues() const
 {
   LabelValueVectorType result = { UNLABELED_VALUE };
 
   for (auto [value, label] : m_LabelMap)
   {
     result.emplace_back(value);
   }
 
   return result;
 }
 
 mitk::LabelSetImage::GroupIndexType mitk::LabelSetImage::AddLayer(ConstLabelVector labels)
 {
   mitk::Image::Pointer newImage = mitk::Image::New();
   newImage->Initialize(this->GetPixelType(),
                        this->GetDimension(),
                        this->GetDimensions(),
                        this->GetImageDescriptor()->GetNumberOfChannels());
   newImage->SetTimeGeometry(this->GetTimeGeometry()->Clone());
 
   ClearImageBuffer(newImage);
 
   return this->AddLayer(newImage, labels);
 }
 
 mitk::LabelSetImage::GroupIndexType mitk::LabelSetImage::AddLayer(mitk::Image* layerImage, ConstLabelVector labels)
 {
   GroupIndexType newGroupID = m_Groups.size();
 
   if (nullptr == layerImage)
     mitkThrow() << "Cannot add group. Passed group image is nullptr.";
 
   bool equalGeometries = Equal(
     *(this->GetTimeGeometry()),
     *(layerImage->GetTimeGeometry()),
     NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION,
     NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION,
     false);
 
   if (!equalGeometries)
     mitkThrow() << "Cannot add group. Passed group image has not the same geometry like segmentation.";
 
   if (layerImage->GetPixelType() != MakePixelType<LabelValueType, LabelValueType, 1>())
     mitkThrow() << "Cannot add group. Passed group image has incorrect pixel type. Only LabelValueType is supported. Invalid pixel type: "<< layerImage->GetPixelType().GetTypeAsString();
 
   // push a new working image for the new layer
   m_LayerContainer.push_back(layerImage);
 
   m_Groups.push_back("");
   m_GroupToLabelMap.push_back({});
 
   for (auto label : labels)
   {
     if (m_LabelMap.end() != m_LabelMap.find(label->GetValue()))
     {
       mitkThrow() << "Cannot add layer. Labels that should be added with layer use at least one label value that is already in use. Conflicted label value: " << label->GetValue();
     }
 
     auto labelClone = label->Clone();
 
     DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(labelClone);
     this->AddLabelToMap(labelClone->GetValue(), labelClone, newGroupID);
     this->RegisterLabel(labelClone);
   }
 
   this->Modified();
   this->InvokeEvent(GroupAddedEvent(newGroupID));
 
   return newGroupID;
 }
 
 void mitk::LabelSetImage::ReplaceGroupLabels(const GroupIndexType groupID, const ConstLabelVectorType& labelSet)
 {
   if (m_LayerContainer.size() <= groupID)
   {
     mitkThrow() << "Trying to replace labels of non-existing group. Invalid group id: "<<groupID;
   }
 
   //remove old group labels
   LabelValueVectorType oldLabels;
   {
     std::lock_guard<std::shared_mutex> guard(m_LabelNGroupMapsMutex);
     oldLabels = this->m_GroupToLabelMap[groupID];
     for (auto labelID : oldLabels)
     {
       this->RemoveLabelFromMap(labelID);
       this->InvokeEvent(LabelRemovedEvent(labelID));
 
     }
   }
   this->InvokeEvent(LabelsChangedEvent(oldLabels));
   this->InvokeEvent(GroupModifiedEvent(groupID));
 
   //add new labels to group
   for (auto label : labelSet)
   {
     this->AddLabel(label->Clone(), groupID, true, false);
   }
 }
 
 void mitk::LabelSetImage::ReplaceGroupLabels(const GroupIndexType groupID, const LabelVectorType& labelSet)
 {
   return ReplaceGroupLabels(groupID, ConvertLabelVectorConst(labelSet));
 }
 
 mitk::Image* mitk::LabelSetImage::GetGroupImage(GroupIndexType groupID)
 {
   if (!this->ExistGroup(groupID)) mitkThrow() << "Error, cannot return group image. Group ID is invalid. Invalid ID: " << groupID;
 
   return groupID == this->GetActiveLayer() ? this : m_LayerContainer[groupID];
 }
 
 
 const mitk::Image* mitk::LabelSetImage::GetGroupImage(GroupIndexType groupID) const
 {
   if (!this->ExistGroup(groupID)) mitkThrow() << "Error, cannot return group image. Group ID is invalid. Invalid ID: " << groupID;
 
   return groupID == this->GetActiveLayer() ? this : m_LayerContainer.at(groupID).GetPointer();
 }
 
 const mitk::Image* mitk::LabelSetImage::GetGroupImageWorkaround(GroupIndexType groupID) const
 {
   if (!this->ExistGroup(groupID))
     mitkThrow() << "Error, cannot return group image. Group ID is invalid. Invalid ID: " << groupID;
 
   if (groupID == this->GetActiveLayer() && this->GetMTime()> m_LayerContainer[groupID]->GetMTime())
   { //we have to transfer the content first into the group image
     if (4 == this->GetDimension())
     {
       AccessFixedDimensionByItk_n(this, ImageToLayerContainerProcessing, 4, (groupID));
     }
     else
     {
       AccessByItk_1(this, ImageToLayerContainerProcessing, groupID);
     }
   }
 
   return m_LayerContainer[groupID].GetPointer();
 }
 
 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;
         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;
         AccessByItk_1(this, LayerContainerToImageProcessing, GetActiveLayer());
 
         AfterChangeLayerEvent.Send();
       }
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   this->Modified();
 }
 
 void mitk::LabelSetImage::SetActiveLabel(LabelValueType label)
 {
   m_ActiveLabelValue = label;
 
   if (label != UNLABELED_VALUE)
   {
     auto groupID = this->GetGroupIndexOfLabel(label);
     if (groupID!=this->GetActiveLayer()) this->SetActiveLayer(groupID);
   }
   Modified();
 }
 
 void mitk::LabelSetImage::ClearBuffer()
 {
   try
   {
     ClearImageBuffer(this);
     this->Modified();
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
 }
 
 void mitk::LabelSetImage::MergeLabel(PixelType pixelValue, PixelType sourcePixelValue)
 {
   try
   {
     AccessByItk_2(this, MergeLabelProcessing, pixelValue, sourcePixelValue);
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   this->SetActiveLabel(pixelValue);
   this->InvokeEvent(LabelModifiedEvent(sourcePixelValue));
   this->InvokeEvent(LabelModifiedEvent(pixelValue));
   this->InvokeEvent(LabelsChangedEvent({ sourcePixelValue, pixelValue }));
   Modified();
 }
 
 void mitk::LabelSetImage::MergeLabels(PixelType pixelValue, const std::vector<PixelType>& vectorOfSourcePixelValues)
 {
   try
   {
     for (unsigned int idx = 0; idx < vectorOfSourcePixelValues.size(); idx++)
     {
       AccessByItk_2(this, MergeLabelProcessing, pixelValue, vectorOfSourcePixelValues[idx]);
       this->InvokeEvent(LabelModifiedEvent(vectorOfSourcePixelValues[idx]));
     }
   }
   catch (itk::ExceptionObject &e)
   {
     mitkThrow() << e.GetDescription();
   }
   this->SetActiveLabel(pixelValue);
   this->InvokeEvent(LabelModifiedEvent(pixelValue));
   auto modifiedValues = vectorOfSourcePixelValues;
   modifiedValues.push_back(pixelValue);
   this->InvokeEvent(LabelsChangedEvent(modifiedValues));
 
   Modified();
 }
 
 void mitk::LabelSetImage::RemoveLabel(LabelValueType pixelValue)
 {
   GroupIndexType groupID = 0;
   {
     std::lock_guard<std::shared_mutex> guard(m_LabelNGroupMapsMutex);
     if (m_LabelMap.find(pixelValue) == m_LabelMap.end()) return;
 
     groupID = this->GetGroupIndexOfLabel(pixelValue);
 
     //first erase the pixel content (also triggers a LabelModified event)
     this->EraseLabel(pixelValue);
     this->RemoveLabelFromMap(pixelValue);
 
 
     if (m_ActiveLabelValue == pixelValue)
     {
       this->SetActiveLabel(0);
     }
   }
 
   this->InvokeEvent(LabelRemovedEvent(pixelValue));
   this->InvokeEvent(LabelsChangedEvent({ pixelValue }));
   this->InvokeEvent(GroupModifiedEvent(groupID));
 }
 
 void mitk::LabelSetImage::RemoveLabelFromMap(LabelValueType pixelValue)
 {
   if (m_LabelMap.find(pixelValue) == m_LabelMap.end()) mitkThrow()<<"Invalid state of instance. RemoveLabelFromMap was called for unknown label id. invalid label id: "<<pixelValue;
 
   auto groupID = this->GetGroupIndexOfLabel(pixelValue);
 
   this->ReleaseLabel(m_LabelMap[pixelValue]);
   //now remove the label entry itself
   m_LabelMap.erase(pixelValue);
   m_LabelToGroupMap.erase(pixelValue);
   auto labelsInGroup = m_GroupToLabelMap[groupID];
   labelsInGroup.erase(std::remove(labelsInGroup.begin(), labelsInGroup.end(), pixelValue), labelsInGroup.end());
   m_GroupToLabelMap[groupID] = labelsInGroup;
 }
 
 void mitk::LabelSetImage::RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues)
 {
   for (const auto labelValue : vectorOfLabelPixelValues)
   {
     this->RemoveLabel(labelValue);
   }
   this->InvokeEvent(LabelsChangedEvent(vectorOfLabelPixelValues));
 }
 
 void mitk::LabelSetImage::EraseLabel(LabelValueType pixelValue)
 {
   try
   {
     auto groupID = this->GetGroupIndexOfLabel(pixelValue);
 
     mitk::Image* groupImage = this->GetGroupImage(groupID);
 
     if (4 == this->GetDimension())
     {
       AccessFixedDimensionByItk_1(groupImage, EraseLabelProcessing, 4, pixelValue);
     }
     else
     {
       AccessByItk_1(groupImage, EraseLabelProcessing, pixelValue);
     }
   }
   catch (const itk::ExceptionObject& e)
   {
     mitkThrow() << e.GetDescription();
   }
 
   this->InvokeEvent(LabelModifiedEvent(pixelValue));
   this->InvokeEvent(LabelsChangedEvent({ pixelValue }));
   Modified();
 }
 
 void mitk::LabelSetImage::EraseLabels(const LabelValueVectorType& labelValues)
 {
   for (auto labelValue : labelValues)
   {
     this->EraseLabel(labelValue);
   }
 }
 
 mitk::LabelSetImage::LabelValueType mitk::LabelSetImage::GetUnusedLabelValue() const
 {
   auto usedValues = this->GetUsedLabelValues();
   return usedValues.back() + 1;
 }
 
 mitk::Label* mitk::LabelSetImage::AddLabel(mitk::Label* label, GroupIndexType groupID, bool addAsClone, bool correctLabelValue)
 {
   if (nullptr == label) mitkThrow() << "Invalid use of AddLabel. label is not valid.";
 
   mitk::Label::Pointer newLabel = label;
 
   {
     std::lock_guard<std::shared_mutex> guard(m_LabelNGroupMapsMutex);
 
     unsigned int max_size = mitk::Label::MAX_LABEL_VALUE + 1;
     if (m_LayerContainer.size() >= max_size)
       return nullptr;
 
     if (addAsClone) newLabel = label->Clone();
 
     auto pixelValue = newLabel->GetValue();
     auto usedValues = this->GetUsedLabelValues();
     auto finding = std::find(usedValues.begin(), usedValues.end(), pixelValue);
 
     if (!usedValues.empty() && usedValues.end() != finding)
     {
       if (correctLabelValue)
       {
         pixelValue = this->GetUnusedLabelValue();
         newLabel->SetValue(pixelValue);
       }
       else
       {
         mitkThrow() << "Cannot add label due to conflicting label value that already exists in the MultiLabelSegmentation. Conflicting label value: " << pixelValue;
       }
     }
 
     // add DICOM information of the label
     DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(newLabel);
 
     this->AddLabelToMap(pixelValue, newLabel, groupID);
     this->RegisterLabel(newLabel);
   }
 
   this->InvokeEvent(LabelAddedEvent(newLabel->GetValue()));
   m_ActiveLabelValue = newLabel->GetValue();
   this->Modified();
 
   return newLabel;
 }
 
 mitk::Label* mitk::LabelSetImage::AddLabelWithContent(Label* label, const Image* labelContent, GroupIndexType groupID, LabelValueType contentLabelValue, bool addAsClone, bool correctLabelValue)
 {
   if (nullptr == labelContent) mitkThrow() << "Invalid use of AddLabel. labelContent is not valid.";
   if (!Equal(*(this->GetTimeGeometry()), *(labelContent->GetTimeGeometry()), mitk::NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION, mitk::NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION))
     mitkThrow() << "Invalid use of AddLabel. labelContent has not the same geometry like the segmentation.";
 
   auto newLabel = this->AddLabel(label, groupID, addAsClone, correctLabelValue);
 
   mitk::TransferLabelContent(labelContent, this->GetGroupImage(groupID), this->GetConstLabelsByValue(this->GetLabelValuesByGroup(groupID)),
     mitk::LabelSetImage::UNLABELED_VALUE, mitk::LabelSetImage::UNLABELED_VALUE, false, { {contentLabelValue, newLabel->GetValue()}},
     mitk::MultiLabelSegmentation::MergeStyle::Replace, mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
   this->Modified();
 
   return newLabel;
 }
 
 mitk::Label* mitk::LabelSetImage::AddLabel(const std::string& name, const mitk::Color& color, GroupIndexType groupID)
 {
   mitk::Label::Pointer newLabel = mitk::Label::New();
   newLabel->SetName(name);
   newLabel->SetColor(color);
   return AddLabel(newLabel,groupID,false);
 }
 
 void mitk::LabelSetImage::RenameLabel(LabelValueType pixelValue, const std::string& name, const mitk::Color& color)
 {
   std::shared_lock<std::shared_mutex> guard(m_LabelNGroupMapsMutex);
 
   mitk::Label* label = GetLabel(pixelValue);
   if (nullptr == label) mitkThrow() << "Cannot rename label.Unknown label value provided. Unknown label value:" << pixelValue;
 
   label->SetName(name);
   label->SetColor(color);
 
   this->UpdateLookupTable(pixelValue);
   // change DICOM information of the label
   DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(label);
 }
 
 mitk::Label *mitk::LabelSetImage::GetActiveLabel()
 {
   if (m_ActiveLabelValue == UNLABELED_VALUE) return nullptr;
 
   auto finding = m_LabelMap.find(m_ActiveLabelValue);
   return finding == m_LabelMap.end() ? nullptr : finding->second;
 }
 
 const mitk::Label* mitk::LabelSetImage::GetActiveLabel() const
 {
   if (m_ActiveLabelValue == UNLABELED_VALUE) return nullptr;
 
   auto finding = m_LabelMap.find(m_ActiveLabelValue);
   return finding == m_LabelMap.end() ? nullptr : finding->second;
 }
 
 void mitk::LabelSetImage::UpdateCenterOfMass(PixelType pixelValue)
 {
   if (4 == this->GetDimension())
   {
     AccessFixedDimensionByItk_1(this->GetGroupImage(this->GetGroupIndexOfLabel(pixelValue)), CalculateCenterOfMassProcessing, 4, pixelValue);
   }
   else
   {
     AccessByItk_1(this->GetGroupImage(this->GetGroupIndexOfLabel(pixelValue)), CalculateCenterOfMassProcessing, pixelValue);
   }
 }
 
 void mitk::LabelSetImage::SetLookupTable(mitk::LookupTable* lut)
 {
   m_LookupTable = lut;
   this->Modified();
 }
 
 void mitk::LabelSetImage::UpdateLookupTable(PixelType pixelValue)
 {
   const mitk::Color& color = this->GetLabel(pixelValue)->GetColor();
 
   double rgba[4];
   m_LookupTable->GetTableValue(static_cast<int>(pixelValue), rgba);
   rgba[0] = color.GetRed();
   rgba[1] = color.GetGreen();
   rgba[2] = color.GetBlue();
   if (GetLabel(pixelValue)->GetVisible())
     rgba[3] = GetLabel(pixelValue)->GetOpacity();
   else
     rgba[3] = 0.0;
   m_LookupTable->SetTableValue(static_cast<int>(pixelValue), rgba);
 }
 
 unsigned int mitk::LabelSetImage::GetNumberOfLabels(unsigned int layer) const
 {
   if (layer >= m_Groups.size()) mitkThrow() << "Cannot get number of labels in group. Group is unknown. Invalid index:" << layer;
   return m_GroupToLabelMap[layer].size();
 }
 
 unsigned int mitk::LabelSetImage::GetTotalNumberOfLabels() const
 {
   return m_LabelMap.size();
 }
 
 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.";
   }
 }
 
 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 (Exception& e)
   {
     mitkReThrow(e) << "Could not initialize by provided labeled image.";
   }
   catch (...)
   {
     mitkThrow() << "Could not initialize by provided labeled image due to unknown error.";
   }
   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())
   {
     const auto originalSourceValue = sourceIter.Get();
     const auto sourceValue = static_cast<PixelType>(originalSourceValue);
 
     if (originalSourceValue > mitk::Label::MAX_LABEL_VALUE)
     {
       mitkThrow() << "Cannot initialize MultiLabelSegmentation by image. Image contains a pixel value that exceeds the label value range. Invalid pixel value:" << originalSourceValue;
     }
 
     targetIter.Set(sourceValue);
 
     if (LabelSetImage::UNLABELED_VALUE!=sourceValue && !this->ExistLabel(sourceValue))
     {
       if (this->GetTotalNumberOfLabels() >= mitk::Label::MAX_LABEL_VALUE)
       {
         mitkThrow() << "Cannot initialize MultiLabelSegmentation by image. Image contains to many labels.";
       }
 
       std::stringstream name;
       name << "object-" << sourceValue;
 
       double rgba[4];
       this->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->AddLabel(label,0,false);
     }
 
     ++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();
 
   const auto activeLabel = this->GetActiveLabel()->GetValue();
 
   while (!sourceIter.IsAtEnd())
   {
     PixelType sourceValue = sourceIter.Get();
     PixelType targetValue = targetIter.Get();
 
     if ((sourceValue != UNLABELED_VALUE) &&
         (forceOverwrite || !this->IsLabelLocked(targetValue))) // skip unlabeled pixels and locked labels
     {
       targetIter.Set(activeLabel);
     }
     ++sourceIter;
     ++targetIter;
   }
 
   this->Modified();
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::CalculateCenterOfMassProcessing(ImageType *itkImage, LabelValueType pixelValue)
 {
   if (ImageType::GetImageDimension() != 3)
   {
     return;
   }
 
   auto labelGeometryFilter = itk::LabelGeometryImageFilter<ImageType>::New();
   labelGeometryFilter->SetInput(itkImage);
   labelGeometryFilter->Update();
   auto centroid = labelGeometryFilter->GetCentroid(pixelValue);
 
   mitk::Point3D pos;
   pos[0] = centroid[0];
   pos[1] = centroid[1];
   pos[2] = centroid[2];
 
   this->GetLabel(pixelValue)->SetCenterOfMassIndex(pos);
   this->GetSlicedGeometry()->IndexToWorld(pos, pos);
   this->GetLabel(pixelValue)->SetCenterOfMassCoordinates(pos);
 }
 
 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(const 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;
   }
 
   m_LayerContainer[layer]->Modified();
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue)
 {
   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;
   }
 }
 
 void mitk::LabelSetImage::AddLabelToMap(LabelValueType labelValue, mitk::Label* label, GroupIndexType groupID)
 {
   if (m_LabelMap.find(labelValue)!=m_LabelMap.end())
     mitkThrow() << "Segmentation is in an invalid state: Label value collision. A label was added with a LabelValue already in use. LabelValue: " << labelValue;
 
   if (!this->ExistGroup(groupID))
     mitkThrow() << "Cannot add label. Defined group is unknown. Invalid group index: " << groupID;
 
   m_LabelMap[labelValue] = label;
   m_LabelToGroupMap[labelValue] = groupID;
   auto groupFinding = std::find(m_GroupToLabelMap[groupID].begin(), m_GroupToLabelMap[groupID].end(), labelValue);
   if (groupFinding == m_GroupToLabelMap[groupID].end())
   {
     m_GroupToLabelMap[groupID].push_back(labelValue);
   }
 }
 
 void mitk::LabelSetImage::RegisterLabel(mitk::Label* label)
 {
   if (nullptr == label) mitkThrow() << "Invalid call of RegisterLabel with a nullptr.";
 
   UpdateLookupTable(label->GetValue());
 
   auto command = itk::MemberCommand<LabelSetImage>::New();
   command->SetCallbackFunction(this, &LabelSetImage::OnLabelModified);
   m_LabelModEventGuardMap.emplace(label->GetValue(), ITKEventObserverGuard(label, itk::ModifiedEvent(), command));
 }
 
 void mitk::LabelSetImage::ReleaseLabel(Label* label)
 {
   if (nullptr == label) mitkThrow() << "Invalid call of ReleaseLabel with a nullptr.";
   m_LabelModEventGuardMap.erase(label->GetValue());
 }
 
 void mitk::LabelSetImage::ApplyToLabels(const LabelValueVectorType& values, std::function<void(Label*)>&& lambda)
 {
   auto labels = this->GetLabelsByValue(values);
   std::for_each(labels.begin(), labels.end(), lambda);
   this->InvokeEvent(LabelsChangedEvent(values));
 }
 
 void mitk::LabelSetImage::VisitLabels(const LabelValueVectorType& values, std::function<void(const Label*)>&& lambda) const
 {
   auto labels = this->GetConstLabelsByValue(values);
   std::for_each(labels.begin(), labels.end(), lambda);
 }
 
 
 void mitk::LabelSetImage::OnLabelModified(const Object* sender, const itk::EventObject&)
 {
   auto label = dynamic_cast<const Label*>(sender);
   if (nullptr == label)
     mitkThrow() << "LabelSet is in wrong state. LabelModified event is not send by a label instance.";
 
   Superclass::Modified();
   this->InvokeEvent(LabelModifiedEvent(label->GetValue()));
 }
 
 bool mitk::LabelSetImage::ExistLabel(LabelValueType value) const
 {
   auto finding = m_LabelMap.find(value);
   return m_LabelMap.end() != finding;
 }
 
 bool mitk::LabelSetImage::ExistLabel(LabelValueType value, GroupIndexType groupIndex) const
 {
   auto finding = m_LabelToGroupMap.find(value);
   if (m_LabelToGroupMap.end() != finding)
   {
     return finding->second == groupIndex;
   }
   return false;
 }
 
 bool mitk::LabelSetImage::ExistGroup(GroupIndexType index) const
 {
   return index < m_LayerContainer.size();
 }
 
 mitk::LabelSetImage::GroupIndexType mitk::LabelSetImage::GetGroupIndexOfLabel(LabelValueType value) const
 {
   auto finding = m_LabelToGroupMap.find(value);
   if (m_LabelToGroupMap.end() == finding)
   {
     mitkThrow()<< "Cannot deduce group index. Passed label value does not exist. Value: "<< value;
   }
   return finding->second;
 }
 
 
 const mitk::Label* mitk::LabelSetImage::GetLabel(LabelValueType value) const
 {
   auto finding = m_LabelMap.find(value);
   if (m_LabelMap.end() != finding)
   {
     return finding->second;
   }
   return nullptr;
 };
 
 mitk::Label* mitk::LabelSetImage::GetLabel(LabelValueType value)
 {
   auto finding = m_LabelMap.find(value);
   if (m_LabelMap.end() != finding)
   {
     return finding->second;
   }
   return nullptr;
 };
 
 bool mitk::LabelSetImage::IsLabelLocked(LabelValueType value) const
 {
   if (value == UNLABELED_VALUE)
   {
     return m_UnlabeledLabelLock;
   }
 
   const auto label = this->GetLabel(value);
   return label->GetLocked();
 }
 
 const mitk::LabelSetImage::ConstLabelVectorType mitk::LabelSetImage::GetLabels() const
 {
   ConstLabelVectorType result;
   for (auto [value, label] : m_LabelMap)
   {
     result.emplace_back(label);
   }
   return result;
 }
 
 const mitk::LabelSetImage::LabelVectorType mitk::LabelSetImage::GetLabels()
 {
   LabelVectorType result;
   for (auto [value, label] : m_LabelMap)
   {
     result.emplace_back(label);
   }
   return result;
 }
 
 const mitk::LabelSetImage::LabelVectorType mitk::LabelSetImage::GetLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing)
 {
   LabelVectorType result;
   for (const auto& labelValue : labelValues)
   {
     auto* label = this->GetLabel(labelValue);
 
     if (label != nullptr)
     {
       result.emplace_back(label);
     }
     else if (!ignoreMissing) mitkThrow() << "Error cannot get labels by Value. At least one passed value is unknown. Unknown value: " << labelValue;
   }
   return result;
 }
 
 const mitk::LabelSetImage::ConstLabelVectorType mitk::LabelSetImage::GetConstLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing) const
 {
   ConstLabelVectorType result;
   for (const auto& labelValue : labelValues)
   {
     const auto* label = this->GetLabel(labelValue);
 
     if (label != nullptr)
     {
       result.emplace_back(label);
     }
     else if (!ignoreMissing) mitkThrow() << "Error cannot get labels by Value. At least one passed value is unknown. Unknown value: " << labelValue;
   }
   return result;
 }
 
 const mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetLabelValuesByGroup(GroupIndexType index) const
 {
   if (!this->ExistGroup(index))
     mitkThrow() << "Cannot get labels of an invalid group. Invalid group index: " << index;
 
   return m_GroupToLabelMap[index];
 }
 
 const mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetLabelValuesByName(GroupIndexType index, const std::string_view name) const
 {
   LabelValueVectorType result;
 
   auto searchName = [&result, name](const Label* l) { if(l->GetName() == name) result.push_back(l->GetValue()); };
 
   this->VisitLabels(this->GetLabelValuesByGroup(index), searchName);
 
   return result;
 }
 
 std::vector<std::string> mitk::LabelSetImage::GetLabelClassNames() const
 {
   std::set<std::string> names;
   auto searchName = [&names](const Label* l) { names.emplace(l->GetName()); };
   this->VisitLabels(this->GetAllLabelValues(), searchName);
 
   return std::vector<std::string>(names.begin(), names.end());
 }
 
 std::vector<std::string> mitk::LabelSetImage::GetLabelClassNamesByGroup(GroupIndexType index) const
 {
   std::set<std::string> names;
   auto searchName = [&names](const Label* l) { names.emplace(l->GetName()); };
   this->VisitLabels(this->GetLabelValuesByGroup(index), searchName);
 
   return std::vector<std::string>(names.begin(), names.end());
 }
 
 void mitk::LabelSetImage::SetAllLabelsVisible(bool visible)
 {
-  auto setVisibility = [this, visible](Label* l)
+  auto setVisibility = [visible,this](Label* l)
     {
       l->SetVisible(visible);
       this->UpdateLookupTable(l->GetValue());
     };
 
   this->ApplyToLabels(this->GetAllLabelValues(), setVisibility);
+  this->m_LookupTable->Modified();
 }
 
 void mitk::LabelSetImage::SetAllLabelsVisibleByGroup(GroupIndexType group, bool visible)
 {
-  auto setVisibility = [this, visible](Label* l)
+  auto setVisibility = [visible, this](Label* l)
     {
       l->SetVisible(visible);
       this->UpdateLookupTable(l->GetValue());
     };
 
   this->ApplyToLabels(this->GetLabelValuesByGroup(group), setVisibility);
+  this->m_LookupTable->Modified();
 }
 
 void mitk::LabelSetImage::SetAllLabelsVisibleByName(GroupIndexType group, const std::string_view name, bool visible)
 {
-  auto setVisibility = [this, visible](Label* l)
+  auto setVisibility = [visible, this](Label* l)
     {
       l->SetVisible(visible);
       this->UpdateLookupTable(l->GetValue());
     };
 
   this->ApplyToLabels(this->GetLabelValuesByName(group, name), setVisibility);
+  this->m_LookupTable->Modified();
 }
 
 void mitk::LabelSetImage::SetAllLabelsLocked(bool locked)
 {
   auto setLock = [locked](Label* l) { l->SetLocked(locked); };
 
   this->ApplyToLabels(this->GetAllLabelValues(), setLock);
 }
 
 void mitk::LabelSetImage::SetAllLabelsLockedByGroup(GroupIndexType group, bool locked)
 {
   auto setLock = [locked](Label* l) { l->SetLocked(locked); };
 
   this->ApplyToLabels(this->GetLabelValuesByGroup(group), setLock);
 }
 
 void mitk::LabelSetImage::SetAllLabelsLockedByName(GroupIndexType group, const std::string_view name, bool locked)
 {
   auto setLock = [locked](Label* l) { l->SetLocked(locked); };
 
   this->ApplyToLabels(this->GetLabelValuesByName(group, name), setLock);
 }
 
 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 ---";
 
   // m_LookupTable;
   const mitk::LookupTable* lhsLUT = leftHandSide.GetLookupTable();
   const mitk::LookupTable* rhsLUT = rightHandSide.GetLookupTable();
 
   returnValue = *lhsLUT == *rhsLUT;
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Lookup tables not equal.";
     return returnValue;
     ;
   }
 
   // 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;
     }
   }
 
   if (leftHandSide.GetTotalNumberOfLabels() != rightHandSide.GetTotalNumberOfLabels())
   {
     MITK_INFO(verbose) << "Number of labels are 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.GetGroupImage(layerIndex), *rightHandSide.GetGroupImage(layerIndex), eps, verbose);
       if (!returnValue)
       {
         MITK_INFO(verbose) << "Layer image data not equal.";
         return false;
       }
     }
 
     // label data
     auto leftLabelsInGroup = leftHandSide.GetLabelValuesByGroup(layerIndex);
     auto rightLabelsInGroup = rightHandSide.GetLabelValuesByGroup(layerIndex);
 
     if (leftLabelsInGroup.size()!=rightLabelsInGroup.size())
     {
       MITK_INFO(verbose) << "Number of layer labels is not equal. Invalid layer:" <<layerIndex;
       return false;
     }
 
     for (ConstLabelVector::size_type index = 0; index < leftLabelsInGroup.size(); ++index)
     {
       if (!mitk::Equal(*(leftHandSide.GetLabel(leftLabelsInGroup[index])), *(rightHandSide.GetLabel(rightLabelsInGroup[index])),eps,verbose))
       {
         MITK_INFO(verbose) << "At least one label in layer is not equal. Invalid layer:" << layerIndex;
         return false;
       }
     }
   }
 
   return returnValue;
 }
 
 bool mitk::Equal(const mitk::LabelSetImage::ConstLabelVectorType& leftHandSide,
   const mitk::LabelSetImage::ConstLabelVectorType& rightHandSide, ScalarType eps, bool verbose)
 {
   bool returnValue = true;
 
   // container size;
   returnValue = leftHandSide.size() == rightHandSide.size();
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Number of labels not equal.";
     return returnValue;
     ;
   }
 
   // m_LabelContainer;
   auto lhsit = leftHandSide.begin();
   auto rhsit = rightHandSide.begin();
   for (; lhsit != leftHandSide.end(); ++lhsit, ++rhsit)
   {
     returnValue = mitk::Equal(**rhsit, **lhsit,eps,verbose);
     if (!returnValue)
     {
       MITK_INFO(verbose) << "Label in label container not equal.";
       return returnValue;
       ;
     }
   }
 
   return returnValue;
 }
 
 /**Helper function to convert a vector of labels into a label map
  * @pre every label in the vector has a unique value.*/
 using ConstLabelMapType = std::map<mitk::LabelSetImage::LabelValueType, mitk::Label::ConstPointer>;
 ConstLabelMapType ConvertLabelVectorToMap(const mitk::ConstLabelVector& labelV)
 {
   ConstLabelMapType result;
   for (auto label : labelV)
   {
     const auto value = label->GetValue();
     auto finding = result.find(value);
     if (finding != result.end()) mitkThrow() << "Operation failed. Cannot convert label vector into label map, because at least one label value is not unique. Violating label value: " << value;
     result.insert(std::make_pair(value, label));
   }
 
   return result;
 }
 
 
 /** Functor class that implements the label transfer and is used in conjunction with the itk::BinaryFunctorImageFilter.
 * For details regarding the usage of the filter and the functor patterns, please see info of itk::BinaryFunctorImageFilter.
 */
 template <class TDestinationPixel, class TSourcePixel, class TOutputpixel>
 class LabelTransferFunctor
 {
 
 public:
   LabelTransferFunctor() {};
 
   LabelTransferFunctor(const ConstLabelMapType& destinationLabels, mitk::Label::PixelType sourceBackground,
     mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked,
     mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, mitk::MultiLabelSegmentation::MergeStyle mergeStyle,
     mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle) :
     m_DestinationLabels(destinationLabels), m_SourceBackground(sourceBackground),
     m_DestinationBackground(destinationBackground), m_DestinationBackgroundLocked(destinationBackgroundLocked),
     m_SourceLabel(sourceLabel), m_NewDestinationLabel(newDestinationLabel), m_MergeStyle(mergeStyle), m_OverwriteStyle(overwriteStyle)
   {
   };
 
   ~LabelTransferFunctor() {};
 
   bool operator!=(const LabelTransferFunctor& other)const
   {
     return !(*this == other);
   }
   bool operator==(const LabelTransferFunctor& other) const
   {
     return this->m_SourceBackground == other.m_SourceBackground &&
       this->m_DestinationBackground == other.m_DestinationBackground &&
       this->m_DestinationBackgroundLocked == other.m_DestinationBackgroundLocked &&
       this->m_SourceLabel == other.m_SourceLabel &&
       this->m_NewDestinationLabel == other.m_NewDestinationLabel &&
       this->m_MergeStyle == other.m_MergeStyle &&
       this->m_OverwriteStyle == other.m_OverwriteStyle &&
       this->m_DestinationLabels == other.m_DestinationLabels;
   }
 
   LabelTransferFunctor& operator=(const LabelTransferFunctor& other)
   {
     this->m_DestinationLabels = other.m_DestinationLabels;
     this->m_SourceBackground = other.m_SourceBackground;
     this->m_DestinationBackground = other.m_DestinationBackground;
     this->m_DestinationBackgroundLocked = other.m_DestinationBackgroundLocked;
     this->m_SourceLabel = other.m_SourceLabel;
     this->m_NewDestinationLabel = other.m_NewDestinationLabel;
     this->m_MergeStyle = other.m_MergeStyle;
     this->m_OverwriteStyle = other.m_OverwriteStyle;
 
     return *this;
   }
 
   inline TOutputpixel operator()(const TDestinationPixel& existingDestinationValue, const TSourcePixel& existingSourceValue)
   {
     if (existingSourceValue == this->m_SourceLabel)
     {
       if (mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks == this->m_OverwriteStyle)
       {
         return this->m_NewDestinationLabel;
       }
       else
       {
         if (existingDestinationValue == m_DestinationBackground)
         {
           if (!m_DestinationBackgroundLocked)
           {
             return this->m_NewDestinationLabel;
           }
         }
         else
         {
           auto labelFinding = this->m_DestinationLabels.find(existingDestinationValue);
           if (labelFinding==this->m_DestinationLabels.end() || !labelFinding->second->GetLocked())
           {
             return this->m_NewDestinationLabel;
           }
         }
       }
     }
     else if (mitk::MultiLabelSegmentation::MergeStyle::Replace == this->m_MergeStyle
       && existingSourceValue == this->m_SourceBackground
       && existingDestinationValue == this->m_NewDestinationLabel
       && (mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks == this->m_OverwriteStyle
           || !this->m_DestinationBackgroundLocked))
     {
       return this->m_DestinationBackground;
     }
 
     return existingDestinationValue;
   }
 
 private:
   ConstLabelMapType m_DestinationLabels;
   mitk::Label::PixelType m_SourceBackground = 0;
   mitk::Label::PixelType m_DestinationBackground = 0;
   bool m_DestinationBackgroundLocked = false;
   mitk::Label::PixelType m_SourceLabel = 1;
   mitk::Label::PixelType m_NewDestinationLabel = 1;
   mitk::MultiLabelSegmentation::MergeStyle m_MergeStyle = mitk::MultiLabelSegmentation::MergeStyle::Replace;
   mitk::MultiLabelSegmentation::OverwriteStyle m_OverwriteStyle = mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks;
 };
 
 /**Helper function used by TransferLabelContentAtTimeStep to allow the templating over different image dimensions in conjunction of AccessFixedPixelTypeByItk_n.*/
 template<unsigned int VImageDimension>
 void TransferLabelContentAtTimeStepHelper(const itk::Image<mitk::Label::PixelType, VImageDimension>* itkSourceImage, mitk::Image* destinationImage,
   const mitk::ConstLabelVector& destinationLabels, mitk::Label::PixelType sourceBackground, mitk::Label::PixelType destinationBackground,
   bool destinationBackgroundLocked, mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, mitk::MultiLabelSegmentation::MergeStyle mergeStyle, mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle)
 {
   typedef itk::Image<mitk::Label::PixelType, VImageDimension> ContentImageType;
   typename ContentImageType::Pointer itkDestinationImage;
   mitk::CastToItkImage(destinationImage, itkDestinationImage);
 
   auto sourceRegion = itkSourceImage->GetLargestPossibleRegion();
   auto relevantRegion = itkDestinationImage->GetLargestPossibleRegion();
   bool overlapping = relevantRegion.Crop(sourceRegion);
 
   if (!overlapping)
   {
     mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage and destinationImage seem to have no overlapping image region.";
   }
 
   typedef LabelTransferFunctor <mitk::Label::PixelType, mitk::Label::PixelType, mitk::Label::PixelType> LabelTransferFunctorType;
   typedef itk::BinaryFunctorImageFilter<ContentImageType, ContentImageType, ContentImageType, LabelTransferFunctorType> FilterType;
 
   LabelTransferFunctorType transferFunctor(ConvertLabelVectorToMap(destinationLabels), sourceBackground, destinationBackground,
     destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeStyle, overwriteStyle);
 
   auto transferFilter = FilterType::New();
 
   transferFilter->SetFunctor(transferFunctor);
   transferFilter->InPlaceOn();
   transferFilter->SetInput1(itkDestinationImage);
   transferFilter->SetInput2(itkSourceImage);
   transferFilter->GetOutput()->SetRequestedRegion(relevantRegion);
 
   transferFilter->Update();
 }
 
 void mitk::TransferLabelContentAtTimeStep(
   const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabels, const TimeStepType timeStep, mitk::Label::PixelType sourceBackground,
   mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, LabelValueMappingVector labelMapping,
   MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
 {
   if (nullptr == sourceImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage must not be null.";
   }
   if (nullptr == destinationImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; destinationImage must not be null.";
   }
 
   if (sourceImage == destinationImage && labelMapping.size() > 1)
   {
     MITK_DEBUG << "Warning. Using TransferLabelContentAtTimeStep or TransferLabelContent with equal source and destination and more then on label to transfer, can lead to wrong results. Please see documentation and verify that the usage is OK.";
   }
 
   Image::ConstPointer sourceImageAtTimeStep = SelectImageByTimeStep(sourceImage, timeStep);
   Image::Pointer destinationImageAtTimeStep = SelectImageByTimeStep(destinationImage, timeStep);
 
   if (nullptr == sourceImageAtTimeStep)
   {
     mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage does not have the requested time step: " << timeStep;
   }
 
   if (nullptr == destinationImageAtTimeStep)
   {
     mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; destinationImage does not have the requested time step: " << timeStep;
   }
 
   if (!Equal(*(sourceImageAtTimeStep->GetGeometry()), *(destinationImageAtTimeStep->GetGeometry()), mitk::NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION, mitk::NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION))
   {
     if (IsSubGeometry(*(sourceImageAtTimeStep->GetGeometry()), *(destinationImageAtTimeStep->GetGeometry()), mitk::NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION, mitk::NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION))
     {
       //we have to pad the source image
       //because ImageToImageFilters always check for origin matching even if
       //the requested output region is fitting :(
       auto padFilter = mitk::PadImageFilter::New();
       padFilter->SetInput(0, sourceImageAtTimeStep);
       padFilter->SetInput(1, destinationImageAtTimeStep);
       padFilter->SetPadConstant(Label::UNLABELED_VALUE);
       padFilter->SetBinaryFilter(false);
 
       padFilter->Update();
 
       sourceImageAtTimeStep = padFilter->GetOutput();
     }
     else
     {
       mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; source image has neither the same geometry than destination image nor has the source image a sub geometry.";
     }
   }
 
   auto destLabelMap = ConvertLabelVectorToMap(destinationLabels);
   for (const auto& [sourceLabel, newDestinationLabel] : labelMapping)
   {
     if (LabelSetImage::UNLABELED_VALUE!=newDestinationLabel && destLabelMap.end() == destLabelMap.find(newDestinationLabel))
     {
       mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep. Defined destination label does not exist in destinationImage. newDestinationLabel: " << newDestinationLabel;
     }
 
     AccessFixedPixelTypeByItk_n(sourceImageAtTimeStep, TransferLabelContentAtTimeStepHelper, (Label::PixelType), (destinationImageAtTimeStep, destinationLabels, sourceBackground, destinationBackground, destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeStyle, overwriteStlye));
   }
   destinationImage->Modified();
 }
 
 void mitk::TransferLabelContent(
   const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabels, mitk::Label::PixelType sourceBackground,
   mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, LabelValueMappingVector labelMapping,
   MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
 {
   if (nullptr == sourceImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
   }
   if (nullptr == destinationImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
   }
 
   const auto sourceTimeStepCount = sourceImage->GetTimeGeometry()->CountTimeSteps();
   if (sourceTimeStepCount != destinationImage->GetTimeGeometry()->CountTimeSteps())
   {
     mitkThrow() << "Invalid call of TransferLabelContent; mismatch between images in number of time steps.";
   }
 
   for (mitk::TimeStepType i = 0; i < sourceTimeStepCount; ++i)
   {
     TransferLabelContentAtTimeStep(sourceImage, destinationImage, destinationLabels, i, sourceBackground,
       destinationBackground, destinationBackgroundLocked, labelMapping, mergeStyle, overwriteStlye);
   }
 }
 
 void mitk::TransferLabelContentAtTimeStep(
   const LabelSetImage* sourceImage, LabelSetImage* destinationImage, const TimeStepType timeStep,
   LabelValueMappingVector labelMapping,
   MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
 {
   if (nullptr == sourceImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage must not be null.";
   }
 
   auto destinationLabels = destinationImage->GetConstLabelsByValue(destinationImage->GetLabelValuesByGroup(destinationImage->GetActiveLayer()));
 
   for (const auto& mappingElement : labelMapping)
   {
     if (LabelSetImage::UNLABELED_VALUE != mappingElement.first && !sourceImage->ExistLabel(mappingElement.first, sourceImage->GetActiveLayer()))
     {
       mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep. Defined source label does not exist in sourceImage. SourceLabel: " << mappingElement.first;
     }
   }
 
   TransferLabelContentAtTimeStep(sourceImage, destinationImage, destinationLabels, timeStep, LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, destinationImage->GetUnlabeledLabelLock(),
     labelMapping, mergeStyle, overwriteStlye);
 }
 
 void mitk::TransferLabelContent(
   const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
   LabelValueMappingVector labelMapping,
   MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
 {
   if (nullptr == sourceImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
   }
   if (nullptr == destinationImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
   }
 
   const auto sourceTimeStepCount = sourceImage->GetTimeGeometry()->CountTimeSteps();
   if (sourceTimeStepCount != destinationImage->GetTimeGeometry()->CountTimeSteps())
   {
     mitkThrow() << "Invalid call of TransferLabelContent; images have no equal number of time steps.";
   }
 
   for (mitk::TimeStepType i = 0; i < sourceTimeStepCount; ++i)
   {
     TransferLabelContentAtTimeStep(sourceImage, destinationImage, i, labelMapping, mergeStyle, overwriteStlye);
   }
 }
 
diff --git a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp
index 936e561891..7a4210ee50 100644
--- a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp
+++ b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.cpp
@@ -1,643 +1,755 @@
 /*============================================================================
 
 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 "mitkLabelSetImageVtkMapper2D.h"
 
 // MITK
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkDataNode.h>
 #include <mitkImageSliceSelector.h>
-#include <mitkImageStatisticsHolder.h>
-#include <mitkLevelWindowProperty.h>
-#include <mitkLookupTableProperty.h>
-#include <mitkPixelType.h>
-#include <mitkPlaneClipping.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkProperties.h>
-#include <mitkResliceMethodProperty.h>
-#include <mitkTransferFunctionProperty.h>
-#include <mitkVtkResliceInterpolationProperty.h>
+#include <mitkVectorProperty.h>
 
 // MITK Rendering
-#include "vtkMitkLevelWindowFilter.h"
-#include "vtkMitkThickSlicesFilter.h"
 #include "vtkNeverTranslucentTexture.h"
 
 // VTK
 #include <vtkCamera.h>
-#include <vtkCellArray.h>
 #include <vtkImageData.h>
 #include <vtkImageReslice.h>
 #include <vtkLookupTable.h>
-#include <vtkMatrix4x4.h>
 #include <vtkPlaneSource.h>
-#include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkProperty.h>
-#include <vtkTransform.h>
-//#include <vtkOpenGLTexture.h>
+#include <vtkImageMapToColors.h>
 
-// ITK
-#include <itkRGBAPixel.h>
-#include <mitkRenderingModeProperty.h>
+namespace
+{
+  itk::ModifiedTimeType PropertyTimeStampIsNewer(const mitk::IPropertyProvider* provider, mitk::BaseRenderer* renderer, const std::string& propName, itk::ModifiedTimeType refMT)
+  {
+    const std::string context = renderer != nullptr ? renderer->GetName() : "";
+    auto prop = provider->GetConstProperty(propName, context);
+    if (prop != nullptr)
+    {
+      return prop->GetTimeStamp() > refMT;
+    }
+    return false;
+  }
+}
 
 mitk::LabelSetImageVtkMapper2D::LabelSetImageVtkMapper2D()
 {
 }
 
 mitk::LabelSetImageVtkMapper2D::~LabelSetImageVtkMapper2D()
 {
 }
 
 vtkProp *mitk::LabelSetImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   // return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Actors;
 }
 
 mitk::LabelSetImageVtkMapper2D::LocalStorage *mitk::LabelSetImageVtkMapper2D::GetLocalStorage(
   mitk::BaseRenderer *renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
-void mitk::LabelSetImageVtkMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
+void mitk::LabelSetImageVtkMapper2D::GenerateLookupTable(mitk::BaseRenderer* renderer)
 {
-  LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
-  mitk::DataNode *node = this->GetDataNode();
-  auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
+  LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode* node = this->GetDataNode();
+  auto* image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
   assert(image && image->IsInitialized());
 
-  // check if there is a valid worldGeometry
-  const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
-  if ((worldGeometry == nullptr) || (!worldGeometry->IsValid()) || (!worldGeometry->HasReferenceGeometry()))
-    return;
+  localStorage->m_LabelLookupTable = image->GetLookupTable()->Clone();
+  const auto labelValues = image->GetAllLabelValues();
 
-  image->Update();
+  std::string propertyName = "org.mitk.multilabel.labels.highlighted";
 
-  int numberOfLayers = image->GetNumberOfLayers();
-  int activeLayer = image->GetActiveLayer();
+  mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
+  if (nullptr != prop)
+  {
+    const auto highlightedLabelValues = prop->GetValue();
 
-  float opacity = 1.0f;
-  node->GetOpacity(opacity, renderer, "opacity");
+    if (!highlightedLabelValues.empty())
+    {
+      auto lookUpTable  = localStorage->m_LabelLookupTable->GetVtkLookupTable();
+      auto highlightEnd = highlightedLabelValues.cend();
+
+      double rgba[4];
+      for (const auto& value : labelValues)
+      {
+        lookUpTable->GetTableValue(value, rgba);
+        if (highlightEnd == std::find(highlightedLabelValues.begin(), highlightedLabelValues.end(), value))
+        { //make all none highlighted values more transparent
+          rgba[3] *= 0.3;
+        }
+        else
+        {
+          if (rgba[3] != 0)
+          { //if highlighted values are visible set them to opaque to pop out
+            rgba[3] = 1.;
+          }
+          else
+          { //if highlighted values are invisible the opacity is increased a bit
+            //to give a visual hint that the are highlighted but also invisible.
+            //e.g. needed to see a difference if you change the visibility of
+            //a highlighted label in the MultiLabelInspector
+            rgba[3] = 0.4;
+          }
+        }
+        lookUpTable->SetTableValue(value, rgba);
+      }
+      localStorage->m_LabelLookupTable->Modified();
+    }
+  }
+}
 
-  if (numberOfLayers != localStorage->m_NumberOfLayers)
+namespace
+{
+  std::vector<mitk::LabelSetImage::GroupIndexType> GetOutdatedGroups(const mitk::LabelSetImageVtkMapper2D::LocalStorage* ls, const mitk::LabelSetImage* seg)
   {
-    localStorage->m_NumberOfLayers = numberOfLayers;
-    localStorage->m_ReslicedImageVector.clear();
-    localStorage->m_ReslicerVector.clear();
-    localStorage->m_LayerTextureVector.clear();
-    localStorage->m_LevelWindowFilterVector.clear();
-    localStorage->m_LayerMapperVector.clear();
-    localStorage->m_LayerActorVector.clear();
-
-    localStorage->m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
+    const auto nrOfGroups = seg->GetNumberOfLayers();
+    std::vector<mitk::LabelSetImage::GroupIndexType> result;
 
-    for (int lidx = 0; lidx < numberOfLayers; ++lidx)
+    for (mitk::LabelSetImage::GroupIndexType groupID = 0; groupID < nrOfGroups; ++groupID)
     {
-      localStorage->m_ReslicedImageVector.push_back(vtkSmartPointer<vtkImageData>::New());
-      localStorage->m_ReslicerVector.push_back(mitk::ExtractSliceFilter::New());
-      localStorage->m_LayerTextureVector.push_back(vtkSmartPointer<vtkNeverTranslucentTexture>::New());
-      localStorage->m_LevelWindowFilterVector.push_back(vtkSmartPointer<vtkMitkLevelWindowFilter>::New());
-      localStorage->m_LayerMapperVector.push_back(vtkSmartPointer<vtkPolyDataMapper>::New());
-      localStorage->m_LayerActorVector.push_back(vtkSmartPointer<vtkActor>::New());
+      const auto groupImage = seg->GetGroupImage(groupID);
+      if (groupImage->GetMTime() > ls->m_LastDataUpdateTime
+        || groupImage->GetPipelineMTime() > ls->m_LastDataUpdateTime
+        || ls->m_GroupImageIDs.size() <= groupID
+        || groupImage != ls->m_GroupImageIDs[groupID])
+      {
+        result.push_back(groupID);
+      }
+    }
+    return result;
+  }
+}
 
-      // do not repeat the texture (the image)
-      localStorage->m_LayerTextureVector[lidx]->RepeatOff();
+void mitk::LabelSetImageVtkMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
+{
+  LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode *node = this->GetDataNode();
+  auto *segmentation = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
+  assert(segmentation && segmentation->IsInitialized());
 
-      // set corresponding mappers for the actors
-      localStorage->m_LayerActorVector[lidx]->SetMapper(localStorage->m_LayerMapperVector[lidx]);
+  bool isLookupModified = localStorage->m_LabelLookupTable.IsNull() ||
+    (localStorage->m_LabelLookupTable->GetMTime() < segmentation->GetLookupTable()->GetMTime()) ||
+    PropertyTimeStampIsNewer(node, renderer, "org.mitk.multilabel.labels.highlighted", localStorage->m_LabelLookupTable->GetMTime()) ||
+    PropertyTimeStampIsNewer(node, renderer, "opacity", localStorage->m_LabelLookupTable->GetMTime());
 
-      localStorage->m_Actors->AddPart(localStorage->m_LayerActorVector[lidx]);
-    }
+  if (isLookupModified)
+  {
+    this->GenerateLookupTable(renderer);
+  }
 
-    localStorage->m_Actors->AddPart(localStorage->m_OutlineShadowActor);
-    localStorage->m_Actors->AddPart(localStorage->m_OutlineActor);
+  auto outdatedGroups = GetOutdatedGroups(localStorage, segmentation);
+
+  bool isGeometryModified = (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
+    (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime());
+
+  bool rendererGeometryIsValid = true;
+
+  // check if there is a valid worldGeometry
+  if (isGeometryModified)
+  {
+    const PlaneGeometry* worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
+    rendererGeometryIsValid = worldGeometry != nullptr
+      && worldGeometry->IsValid()
+      && worldGeometry->HasReferenceGeometry();
+
+    isGeometryModified = rendererGeometryIsValid
+      && localStorage->m_WorldPlane.IsNotNull() && !Equal(*worldGeometry, *(localStorage->m_WorldPlane.GetPointer()));
+
+    localStorage->m_WorldPlane = rendererGeometryIsValid ? worldGeometry->Clone() : nullptr;
   }
 
-  // early out if there is no intersection of the current rendering geometry
-  // and the geometry of the image that is to be rendered.
-  if (!RenderingGeometryIntersectsImage(worldGeometry, image->GetSlicedGeometry()))
+  bool hasValidContent = rendererGeometryIsValid && RenderingGeometryIntersectsImage(localStorage->m_WorldPlane, segmentation->GetSlicedGeometry());
+
+  if (!hasValidContent && localStorage->m_HasValidContent)
   {
     // set image to nullptr, to clear the texture in 3D, because
     // the latest image is used there if the plane is out of the geometry
     // see bug-13275
-    for (int lidx = 0; lidx < numberOfLayers; ++lidx)
+    for (unsigned int lidx = 0; lidx < localStorage->m_NumberOfLayers; ++lidx)
     {
       localStorage->m_ReslicedImageVector[lidx] = nullptr;
       localStorage->m_LayerMapperVector[lidx]->SetInputData(localStorage->m_EmptyPolyData);
       localStorage->m_OutlineActor->SetVisibility(false);
       localStorage->m_OutlineShadowActor->SetVisibility(false);
     }
+    localStorage->m_LastDataUpdateTime.Modified();
+  }
+
+  if (isGeometryModified || (hasValidContent && !localStorage->m_HasValidContent))
+  {
+    //if geometry is outdated or we have valid content again
+    // -> all groups need regeneration
+    outdatedGroups.resize(segmentation->GetNumberOfLayers());
+    std::iota(outdatedGroups.begin(), outdatedGroups.end(), 0);
+  }
+
+  localStorage->m_HasValidContent = hasValidContent;
+
+  if (!hasValidContent)
+  {
+    // early out if there is no intersection of the current rendering geometry
+    // and the geometry of the image that is to be rendered.
     return;
   }
 
-  for (int lidx = 0; lidx < numberOfLayers; ++lidx)
+  if (!outdatedGroups.empty())
   {
-    const auto layerImage = image->GetGroupImage(lidx);
+    this->GenerateImageSlice(renderer, outdatedGroups);
+  }
 
-    localStorage->m_ReslicerVector[lidx]->SetInput(layerImage);
-    localStorage->m_ReslicerVector[lidx]->SetWorldGeometry(worldGeometry);
-    localStorage->m_ReslicerVector[lidx]->SetTimeStep(this->GetTimestep());
+  float opacity = 1.0f;
+  node->GetOpacity(opacity, renderer, "opacity");
+
+  if (isLookupModified)
+  {
+    //if lookup table is modified all groups need a new color mapping
+    outdatedGroups.resize(segmentation->GetNumberOfLayers());
+    std::iota(outdatedGroups.begin(), outdatedGroups.end(), 0);
+  }
+
+  for (const auto groupID: outdatedGroups)
+  {
+    localStorage->m_LayerImageMapToColors[groupID]->SetLookupTable(localStorage->m_LabelLookupTable->GetVtkLookupTable());
+    localStorage->m_LayerImageMapToColors[groupID]->SetInputData(localStorage->m_ReslicedImageVector[groupID]);
+    localStorage->m_LayerImageMapToColors[groupID]->Update();
+
+    // check for texture interpolation property
+    bool textureInterpolation = false;
+    node->GetBoolProperty("texture interpolation", textureInterpolation, renderer);
+
+    // set the interpolation modus according to the property
+    localStorage->m_LayerTextureVector[groupID]->SetInterpolate(textureInterpolation);
+
+    localStorage->m_LayerTextureVector[groupID]->SetInputConnection(
+      localStorage->m_LayerImageMapToColors[groupID]->GetOutputPort());
+    this->TransformActor(renderer);
+
+    // set the plane as input for the mapper
+    localStorage->m_LayerMapperVector[groupID]->SetInputConnection(localStorage->m_Plane->GetOutputPort());
+
+    // set the texture for the actor
+    localStorage->m_LayerActorVector[groupID]->SetTexture(localStorage->m_LayerTextureVector[groupID]);
+    localStorage->m_LayerActorVector[groupID]->GetProperty()->SetOpacity(opacity);
+  }
+
+  auto activeLayer = segmentation->GetActiveLayer();
+  bool activeGroupIsOutdated = std::find(outdatedGroups.begin(), outdatedGroups.end(), activeLayer) != outdatedGroups.end();
+
+  if (activeGroupIsOutdated
+      || PropertyTimeStampIsNewer(node, renderer, "opacity", localStorage->m_LastActiveLabelUpdateTime.GetMTime())
+      || PropertyTimeStampIsNewer(node, renderer, "labelset.contour.active", localStorage->m_LastActiveLabelUpdateTime.GetMTime())
+      || PropertyTimeStampIsNewer(node, renderer, "labelset.contour.width", localStorage->m_LastActiveLabelUpdateTime.GetMTime())
+    )
+  {
+    this->GenerateActiveLabelOutline(renderer);
+  }
+}
+
+void mitk::LabelSetImageVtkMapper2D::GenerateImageSlice(mitk::BaseRenderer* renderer, const std::vector<mitk::LabelSetImage::GroupIndexType>& outdatedGroupIDs)
+{
+  LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode* node = this->GetDataNode();
+  auto* segmentation = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
+  assert(segmentation && segmentation->IsInitialized());
+
+  segmentation->Update();
+
+  const auto numberOfLayers = segmentation->GetNumberOfLayers();
+
+  if (numberOfLayers != localStorage->m_NumberOfLayers)
+  {
+    if (numberOfLayers > localStorage->m_NumberOfLayers)
+    {
+      for (unsigned int lidx = localStorage->m_NumberOfLayers; lidx < numberOfLayers; ++lidx)
+      {
+        localStorage->m_GroupImageIDs.push_back(nullptr);
+        localStorage->m_ReslicedImageVector.push_back(vtkSmartPointer<vtkImageData>::New());
+        localStorage->m_ReslicerVector.push_back(mitk::ExtractSliceFilter::New());
+        localStorage->m_LayerTextureVector.push_back(vtkSmartPointer<vtkNeverTranslucentTexture>::New());
+        localStorage->m_LayerMapperVector.push_back(vtkSmartPointer<vtkPolyDataMapper>::New());
+        localStorage->m_LayerActorVector.push_back(vtkSmartPointer<vtkActor>::New());
+        localStorage->m_LayerImageMapToColors.push_back(vtkSmartPointer<vtkImageMapToColors>::New());
+
+        // do not repeat the texture (the image)
+        localStorage->m_LayerTextureVector[lidx]->RepeatOff();
+        // set corresponding mappers for the actors
+        localStorage->m_LayerActorVector[lidx]->SetMapper(localStorage->m_LayerMapperVector[lidx]);
+      }
+    }
+    else
+    {
+      localStorage->m_GroupImageIDs.resize(numberOfLayers);
+      localStorage->m_ReslicedImageVector.resize(numberOfLayers);
+      localStorage->m_ReslicerVector.resize(numberOfLayers);
+      localStorage->m_LayerTextureVector.resize(numberOfLayers);
+      localStorage->m_LayerMapperVector.resize(numberOfLayers);
+      localStorage->m_LayerActorVector.resize(numberOfLayers);
+      localStorage->m_LayerImageMapToColors.resize(numberOfLayers);
+    }
+    localStorage->m_NumberOfLayers = numberOfLayers;
+
+    localStorage->m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
+
+    for (unsigned int lidx = 0; lidx < numberOfLayers; ++lidx)
+    {
+      localStorage->m_Actors->AddPart(localStorage->m_LayerActorVector[lidx]);
+    }
+    localStorage->m_Actors->AddPart(localStorage->m_OutlineShadowActor);
+    localStorage->m_Actors->AddPart(localStorage->m_OutlineActor);
+  }
+
+  for (const auto groupID : outdatedGroupIDs)
+  {
+    const auto groupImage = segmentation->GetGroupImage(groupID);
+    localStorage->m_GroupImageIDs[groupID] = groupImage;
+
+    localStorage->m_ReslicerVector[groupID]->SetInput(groupImage);
+    localStorage->m_ReslicerVector[groupID]->SetWorldGeometry(localStorage->m_WorldPlane);
+    localStorage->m_ReslicerVector[groupID]->SetTimeStep(this->GetTimestep());
 
     // set the transformation of the image to adapt reslice axis
-    localStorage->m_ReslicerVector[lidx]->SetResliceTransformByGeometry(
-      layerImage->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep()));
+    localStorage->m_ReslicerVector[groupID]->SetResliceTransformByGeometry(
+      groupImage->GetTimeGeometry()->GetGeometryForTimeStep(this->GetTimestep()));
 
     // is the geometry of the slice based on the image image or the worldgeometry?
     bool inPlaneResampleExtentByGeometry = false;
     node->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
-    localStorage->m_ReslicerVector[lidx]->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
-    localStorage->m_ReslicerVector[lidx]->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
-    localStorage->m_ReslicerVector[lidx]->SetVtkOutputRequest(true);
+    localStorage->m_ReslicerVector[groupID]->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
+    localStorage->m_ReslicerVector[groupID]->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
+    localStorage->m_ReslicerVector[groupID]->SetVtkOutputRequest(true);
 
     // this is needed when thick mode was enabled before. These variables have to be reset to default values
-    localStorage->m_ReslicerVector[lidx]->SetOutputDimensionality(2);
-    localStorage->m_ReslicerVector[lidx]->SetOutputSpacingZDirection(1.0);
-    localStorage->m_ReslicerVector[lidx]->SetOutputExtentZDirection(0, 0);
+    localStorage->m_ReslicerVector[groupID]->SetOutputDimensionality(2);
+    localStorage->m_ReslicerVector[groupID]->SetOutputSpacingZDirection(1.0);
+    localStorage->m_ReslicerVector[groupID]->SetOutputExtentZDirection(0, 0);
 
     // Bounds information for reslicing (only required if reference geometry is present)
     // this used for generating a vtkPLaneSource with the right size
     double sliceBounds[6];
     sliceBounds[0] = 0.0;
     sliceBounds[1] = 0.0;
     sliceBounds[2] = 0.0;
     sliceBounds[3] = 0.0;
     sliceBounds[4] = 0.0;
     sliceBounds[5] = 0.0;
 
-    localStorage->m_ReslicerVector[lidx]->GetClippedPlaneBounds(sliceBounds);
+    localStorage->m_ReslicerVector[groupID]->GetClippedPlaneBounds(sliceBounds);
 
     // setup the textured plane
     this->GeneratePlane(renderer, sliceBounds);
 
     // get the spacing of the slice
-    localStorage->m_mmPerPixel = localStorage->m_ReslicerVector[lidx]->GetOutputSpacing();
-    localStorage->m_ReslicerVector[lidx]->Modified();
+    localStorage->m_mmPerPixel = localStorage->m_ReslicerVector[groupID]->GetOutputSpacing();
+    localStorage->m_ReslicerVector[groupID]->Modified();
     // start the pipeline with updating the largest possible, needed if the geometry of the image has changed
-    localStorage->m_ReslicerVector[lidx]->UpdateLargestPossibleRegion();
-    localStorage->m_ReslicedImageVector[lidx] = localStorage->m_ReslicerVector[lidx]->GetVtkOutput();
-
-    const auto *planeGeometry = dynamic_cast<const PlaneGeometry *>(worldGeometry);
-
-    double textureClippingBounds[6];
-    for (auto &textureClippingBound : textureClippingBounds)
-    {
-      textureClippingBound = 0.0;
-    }
-
-    // Calculate the actual bounds of the transformed plane clipped by the
-    // dataset bounding box; this is required for drawing the texture at the
-    // correct position during 3D mapping.
-    mitk::PlaneClipping::CalculateClippedPlaneBounds(layerImage->GetGeometry(), planeGeometry, textureClippingBounds);
-
-    textureClippingBounds[0] = static_cast<int>(textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5);
-    textureClippingBounds[1] = static_cast<int>(textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5);
-    textureClippingBounds[2] = static_cast<int>(textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5);
-    textureClippingBounds[3] = static_cast<int>(textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5);
-
-    // clipping bounds for cutting the imageLayer
-    localStorage->m_LevelWindowFilterVector[lidx]->SetClippingBounds(textureClippingBounds);
-
-    localStorage->m_LevelWindowFilterVector[lidx]->SetLookupTable(
-      image->GetLookupTable()->GetVtkLookupTable());
-
-    // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
-    localStorage->m_LayerTextureVector[lidx]->SetColorModeToDirectScalars();
-
-    // connect the imageLayer with the levelwindow filter
-    localStorage->m_LevelWindowFilterVector[lidx]->SetInputData(localStorage->m_ReslicedImageVector[lidx]);
-    // connect the texture with the output of the levelwindow filter
-
-    // check for texture interpolation property
-    bool textureInterpolation = false;
-    node->GetBoolProperty("texture interpolation", textureInterpolation, renderer);
-
-    // set the interpolation modus according to the property
-    localStorage->m_LayerTextureVector[lidx]->SetInterpolate(textureInterpolation);
-
-    localStorage->m_LayerTextureVector[lidx]->SetInputConnection(
-      localStorage->m_LevelWindowFilterVector[lidx]->GetOutputPort());
+    localStorage->m_ReslicerVector[groupID]->UpdateLargestPossibleRegion();
+    localStorage->m_ReslicedImageVector[groupID] = localStorage->m_ReslicerVector[groupID]->GetVtkOutput();
+  }
+  localStorage->m_LastDataUpdateTime.Modified();
+}
 
-    this->TransformActor(renderer);
+void mitk::LabelSetImageVtkMapper2D::GenerateActiveLabelOutline(mitk::BaseRenderer* renderer)
+{
+  LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode* node = this->GetDataNode();
+  auto* image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
 
-    // set the plane as input for the mapper
-    localStorage->m_LayerMapperVector[lidx]->SetInputConnection(localStorage->m_Plane->GetOutputPort());
+  int activeLayer = image->GetActiveLayer();
 
-    // set the texture for the actor
-    localStorage->m_LayerActorVector[lidx]->SetTexture(localStorage->m_LayerTextureVector[lidx]);
-    localStorage->m_LayerActorVector[lidx]->GetProperty()->SetOpacity(opacity);
-  }
+  float opacity = 1.0f;
+  node->GetOpacity(opacity, renderer, "opacity");
 
   mitk::Label* activeLabel = image->GetActiveLabel();
-  if (nullptr != activeLabel)
+  bool contourActive = false;
+  node->GetBoolProperty("labelset.contour.active", contourActive, renderer);
+  if (nullptr != activeLabel && contourActive && activeLabel->GetVisible())
   {
-    bool contourActive = false;
-    node->GetBoolProperty("labelset.contour.active", contourActive, renderer);
-    if (contourActive && activeLabel->GetVisible()) //contour rendering
-    {
-      //generate contours/outlines
-      localStorage->m_OutlinePolyData =
-        this->CreateOutlinePolyData(renderer, localStorage->m_ReslicedImageVector[activeLayer], activeLabel->GetValue());
-      localStorage->m_OutlineActor->SetVisibility(true);
-      localStorage->m_OutlineShadowActor->SetVisibility(true);
-      const mitk::Color& color = activeLabel->GetColor();
-      localStorage->m_OutlineActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
-      localStorage->m_OutlineShadowActor->GetProperty()->SetColor(0, 0, 0);
-
-      float contourWidth(2.0);
-      node->GetFloatProperty("labelset.contour.width", contourWidth, renderer);
-      localStorage->m_OutlineActor->GetProperty()->SetLineWidth(contourWidth);
-      localStorage->m_OutlineShadowActor->GetProperty()->SetLineWidth(contourWidth * 1.5);
-
-      localStorage->m_OutlineActor->GetProperty()->SetOpacity(opacity);
-      localStorage->m_OutlineShadowActor->GetProperty()->SetOpacity(opacity);
-
-      localStorage->m_OutlineMapper->SetInputData(localStorage->m_OutlinePolyData);
-      return;
-    }
+    //generate contours/outlines
+    localStorage->m_OutlinePolyData =
+      this->CreateOutlinePolyData(renderer, localStorage->m_ReslicedImageVector[activeLayer], activeLabel->GetValue());
+    localStorage->m_OutlineActor->SetVisibility(true);
+    localStorage->m_OutlineShadowActor->SetVisibility(true);
+    const mitk::Color& color = activeLabel->GetColor();
+    localStorage->m_OutlineActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
+    localStorage->m_OutlineShadowActor->GetProperty()->SetColor(0, 0, 0);
+
+    float contourWidth(2.0);
+    node->GetFloatProperty("labelset.contour.width", contourWidth, renderer);
+    localStorage->m_OutlineActor->GetProperty()->SetLineWidth(contourWidth);
+    localStorage->m_OutlineShadowActor->GetProperty()->SetLineWidth(contourWidth * 1.5);
+
+    localStorage->m_OutlineActor->GetProperty()->SetOpacity(opacity);
+    localStorage->m_OutlineShadowActor->GetProperty()->SetOpacity(opacity);
+
+    localStorage->m_OutlineMapper->SetInputData(localStorage->m_OutlinePolyData);
+  }
+  else
+  {
+    localStorage->m_OutlineActor->SetVisibility(false);
+    localStorage->m_OutlineShadowActor->SetVisibility(false);
   }
-  localStorage->m_OutlineActor->SetVisibility(false);
-  localStorage->m_OutlineShadowActor->SetVisibility(false);
+  localStorage->m_LastActiveLabelUpdateTime.Modified();
 }
 
+
 bool mitk::LabelSetImageVtkMapper2D::RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry,
-                                                                      SlicedGeometry3D *imageGeometry)
+  const BaseGeometry *imageGeometry) const
 {
   // if either one of the two geometries is nullptr we return true
   // for safety reasons
   if (renderingGeometry == nullptr || imageGeometry == nullptr)
     return true;
 
   // get the distance for the first cornerpoint
   ScalarType initialDistance = renderingGeometry->SignedDistance(imageGeometry->GetCornerPoint(0));
   for (int i = 1; i < 8; i++)
   {
     mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint(i);
 
     // get the distance to the other cornerpoints
     ScalarType distance = renderingGeometry->SignedDistance(cornerPoint);
 
     // if it has not the same signing as the distance of the first point
     if (initialDistance * distance < 0)
     {
       // we have an intersection and return true
       return true;
     }
   }
 
   // all distances have the same sign, no intersection and we return false
   return false;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::LabelSetImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer *renderer,
                                                                                    vtkImageData *image,
                                                                                    int pixelValue)
 {
   LocalStorage *localStorage = this->GetLocalStorage(renderer);
 
   // get the min and max index values of each direction
   int *extent = image->GetExtent();
   int xMin = extent[0];
   int xMax = extent[1];
   int yMin = extent[2];
   int yMax = extent[3];
 
   int *dims = image->GetDimensions(); // dimensions of the image
   int line = dims[0];                 // how many pixels per line?
   int x = xMin;                       // pixel index x
   int y = yMin;                       // pixel index y
 
   // get the depth for each contour
   float depth = this->CalculateLayerDepth(renderer);
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();      // the points to draw
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); // the lines to connect the points
 
   // We take the pointer to the first pixel of the image
   auto *currentPixel = static_cast<mitk::Label::PixelType *>(image->GetScalarPointer());
 
   while (y <= yMax)
   {
     // if the current pixel value is set to something
     if ((currentPixel) && (*currentPixel == pixelValue))
     {
       // check in which direction a line is necessary
       // a line is added if the neighbor of the current pixel has the value 0
       // and if the pixel is located at the edge of the image
 
       // if   vvvvv  not the first line vvvvv
       if (y > yMin && *(currentPixel - line) != pixelValue)
       { // x direction - bottom edge of the pixel
         // add the 2 points
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         // add the line between both points
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the last line vvvvv
       if (y < yMax && *(currentPixel + line) != pixelValue)
       { // x direction - top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the first pixel vvvvv
       if ((x > xMin || y > yMin) && *(currentPixel - 1) != pixelValue)
       { // y direction - left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  not the last pixel vvvvv
       if ((y < yMax || (x < xMax)) && *(currentPixel + 1) != pixelValue)
       { // y direction - right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       /*  now consider pixels at the edge of the image  */
 
       // if   vvvvv  left edge of image vvvvv
       if (x == xMin)
       { // draw left edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  right edge of image vvvvv
       if (x == xMax)
       { // draw right edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  bottom edge of image vvvvv
       if (y == yMin)
       { // draw bottom edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 =
           points->InsertNextPoint((x + 1) * localStorage->m_mmPerPixel[0], y * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
 
       // if   vvvvv  top edge of image vvvvv
       if (y == yMax)
       { // draw top edge of the pixel
         vtkIdType p1 =
           points->InsertNextPoint(x * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         vtkIdType p2 = points->InsertNextPoint(
           (x + 1) * localStorage->m_mmPerPixel[0], (y + 1) * localStorage->m_mmPerPixel[1], depth);
         lines->InsertNextCell(2);
         lines->InsertCellPoint(p1);
         lines->InsertCellPoint(p2);
       }
     } // end if currentpixel is set
 
     x++;
 
     if (x > xMax)
     { // reached end of line
       x = xMin;
       y++;
     }
 
     // Increase the pointer-position to the next pixel.
     // This is safe, as the while-loop and the x-reset logic above makes
     // sure we do not exceed the bounds of the image
     currentPixel++;
   } // end of while
 
   // Create a polydata to store everything in
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   // Add the points to the dataset
   polyData->SetPoints(points);
   // Add the lines to the dataset
   polyData->SetLines(lines);
   return polyData;
 }
 
-void mitk::LabelSetImageVtkMapper2D::ApplyColor(mitk::BaseRenderer *renderer, const mitk::Color &color)
-{
-  LocalStorage *localStorage = this->GetLocalStorage(renderer);
-  localStorage->m_OutlineActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
-  localStorage->m_OutlineShadowActor->GetProperty()->SetColor(0, 0, 0);
-}
-
-void mitk::LabelSetImageVtkMapper2D::ApplyOpacity(mitk::BaseRenderer *renderer, int layer)
-{
-  LocalStorage *localStorage = this->GetLocalStorage(renderer);
-  float opacity = 1.0f;
-  this->GetDataNode()->GetOpacity(opacity, renderer, "opacity");
-  localStorage->m_LayerActorVector[layer]->GetProperty()->SetOpacity(opacity);
-  localStorage->m_OutlineActor->GetProperty()->SetOpacity(opacity);
-  localStorage->m_OutlineShadowActor->GetProperty()->SetOpacity(opacity);
-}
-
-void mitk::LabelSetImageVtkMapper2D::ApplyLookuptable(mitk::BaseRenderer *renderer, int layer)
-{
-  LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
-  auto *input = dynamic_cast<mitk::LabelSetImage *>(this->GetDataNode()->GetData());
-  localStorage->m_LevelWindowFilterVector[layer]->SetLookupTable(
-    input->GetLookupTable()->GetVtkLookupTable());
-}
-
 void mitk::LabelSetImageVtkMapper2D::Update(mitk::BaseRenderer *renderer)
 {
   bool visible = true;
   const DataNode *node = this->GetDataNode();
   node->GetVisibility(visible, renderer, "visible");
 
   if (!visible)
     return;
 
   auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
 
   if (image == nullptr || image->IsInitialized() == false)
     return;
 
   // Calculate time step of the image data for the specified renderer (integer value)
   this->CalculateTimeStep(renderer);
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = image->GetTimeGeometry();
   if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
       (!dataTimeGeometry->IsValidTimeStep(this->GetTimestep())))
   {
     return;
   }
 
   image->UpdateOutputInformation();
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   // check if something important has changed and we need to re-render
 
-  if ((localStorage->m_LastDataUpdateTime < image->GetMTime()) ||
+  if (localStorage->m_LabelLookupTable.IsNull() ||
+      (localStorage->m_LabelLookupTable->GetMTime() < image->GetLookupTable()->GetMTime()) ||
+      (localStorage->m_LastDataUpdateTime < image->GetMTime()) ||
       (localStorage->m_LastDataUpdateTime < image->GetPipelineMTime()) ||
       (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
-      (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()))
+      (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
+      (localStorage->m_LastPropertyUpdateTime < node->GetPropertyList()->GetMTime()) ||
+      (localStorage->m_LastPropertyUpdateTime < node->GetPropertyList(renderer)->GetMTime()) ||
+      (localStorage->m_LastPropertyUpdateTime < image->GetPropertyList()->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
-    localStorage->m_LastDataUpdateTime.Modified();
+    localStorage->m_LastPropertyUpdateTime.Modified();
   }
   else if ((localStorage->m_LastPropertyUpdateTime < node->GetPropertyList()->GetMTime()) ||
            (localStorage->m_LastPropertyUpdateTime < node->GetPropertyList(renderer)->GetMTime()) ||
            (localStorage->m_LastPropertyUpdateTime < image->GetPropertyList()->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
     localStorage->m_LastPropertyUpdateTime.Modified();
   }
 }
 
 // set the two points defining the textured plane according to the dimension and spacing
 void mitk::LabelSetImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6])
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   float depth = this->CalculateLayerDepth(renderer);
   // Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
   // plane size in crosshair rotation and swivel mode.
   localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
   // These two points define the axes of the plane in combination with the origin.
   // Point 1 is the x-axis and point 2 the y-axis.
   // Each plane is transformed according to the view (axial, coronal and sagittal) afterwards.
   localStorage->m_Plane->SetPoint1(planeBounds[1], planeBounds[2], depth); // P1: (xMax, yMin, depth)
   localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); // P2: (xMin, yMax, depth)
 }
 
 float mitk::LabelSetImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer *renderer)
 {
   // get the clipping range to check how deep into z direction we can render images
   double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
 
   // Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
   float depth = -maxRange * 0.01; // divide by 100
   int layer = 0;
   GetDataNode()->GetIntProperty("layer", layer, renderer);
   // add the layer property for each image to render images with a higher layer on top of the others
   depth += layer * 10; //*10: keep some room for each image (e.g. for ODFs in between)
   if (depth > 0.0f)
   {
     depth = 0.0f;
     MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
   }
   return depth;
 }
 
 void mitk::LabelSetImageVtkMapper2D::TransformActor(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   // get the transformation matrix of the reslicer in order to render the slice as axial, coronal or sagittal
   vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_ReslicerVector[0]->GetResliceAxes(); // same for all layers
   trans->SetMatrix(matrix);
 
-  for (int lidx = 0; lidx < localStorage->m_NumberOfLayers; ++lidx)
+  for (unsigned int lidx = 0; lidx < localStorage->m_NumberOfLayers; ++lidx)
   {
     // transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or sagittal)
     localStorage->m_LayerActorVector[lidx]->SetUserTransform(trans);
     // transform the origin to center based coordinates, because MITK is center based.
     localStorage->m_LayerActorVector[lidx]->SetPosition(
       -0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
   }
   // same for outline actor
   localStorage->m_OutlineActor->SetUserTransform(trans);
   localStorage->m_OutlineActor->SetPosition(
     -0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
   // same for outline shadow actor
   localStorage->m_OutlineShadowActor->SetUserTransform(trans);
   localStorage->m_OutlineShadowActor->SetPosition(
     -0.5 * localStorage->m_mmPerPixel[0], -0.5 * localStorage->m_mmPerPixel[1], 0.0);
 }
 
 void mitk::LabelSetImageVtkMapper2D::SetDefaultProperties(mitk::DataNode *node,
                                                           mitk::BaseRenderer *renderer,
                                                           bool overwrite)
 {
   // add/replace the following properties
   node->SetProperty("opacity", FloatProperty::New(1.0f), renderer);
   node->SetProperty("binary", BoolProperty::New(false), renderer);
 
-  mitk::RenderingModeProperty::Pointer renderingModeProperty =
-    mitk::RenderingModeProperty::New(RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
-  node->SetProperty("Image Rendering.Mode", renderingModeProperty, renderer);
-
-  mitk::LevelWindow levelwindow(32767.5, 65535);
-  mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New(levelwindow);
-
-  levWinProp->SetLevelWindow(levelwindow);
-  node->SetProperty("levelwindow", levWinProp, renderer);
-
   node->SetProperty("labelset.contour.active", BoolProperty::New(true), renderer);
   node->SetProperty("labelset.contour.width", FloatProperty::New(2.0), renderer);
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 mitk::LabelSetImageVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 mitk::LabelSetImageVtkMapper2D::LocalStorage::LocalStorage()
 {
   // Do as much actions as possible in here to avoid double executions.
   m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
   m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
   m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
   m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_OutlineActor = vtkSmartPointer<vtkActor>::New();
   m_OutlineMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_OutlineShadowActor = vtkSmartPointer<vtkActor>::New();
 
+  m_HasValidContent = false;
   m_NumberOfLayers = 0;
   m_mmPerPixel = nullptr;
 
   m_OutlineActor->SetMapper(m_OutlineMapper);
   m_OutlineShadowActor->SetMapper(m_OutlineMapper);
 
   m_OutlineActor->SetVisibility(false);
   m_OutlineShadowActor->SetVisibility(false);
 }
diff --git a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h
index a5363284fa..c213b7fff5 100644
--- a/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h
+++ b/Modules/Multilabel/mitkLabelSetImageVtkMapper2D.h
@@ -1,241 +1,231 @@
 /*============================================================================
 
 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 mitkLabelSetImageVtkMapper2D_h
 #define mitkLabelSetImageVtkMapper2D_h
 
 // MITK
 #include "MitkMultilabelExports.h"
 #include "mitkCommon.h"
 
 // MITK Rendering
 #include "mitkBaseRenderer.h"
 #include "mitkExtractSliceFilter.h"
 #include "mitkLabelSetImage.h"
 #include "mitkVtkMapper.h"
 
 // VTK
 #include <vtkSmartPointer.h>
 
 class vtkActor;
 class vtkPolyDataMapper;
 class vtkPlaneSource;
 class vtkImageData;
 class vtkLookupTable;
 class vtkImageReslice;
 class vtkPoints;
 class vtkMitkThickSlicesFilter;
 class vtkPolyData;
-class vtkMitkLevelWindowFilter;
 class vtkNeverTranslucentTexture;
+class vtkImageMapToColors;
 
 namespace mitk
 {
 
   /** \brief Mapper to resample and display 2D slices of a 3D labelset image.
    *
    * Properties that can be set for labelset images and influence this mapper are:
    *
    *   - \b "labelset.contour.active": (BoolProperty) whether to show only the active label as a contour or not
    *   - \b "labelset.contour.width": (FloatProperty) line width of the contour
 
    * The default properties are:
 
    *   - \b "labelset.contour.active", mitk::BoolProperty::New( true ), renderer, overwrite )
    *   - \b "labelset.contour.width", mitk::FloatProperty::New( 2.0 ), renderer, overwrite )
 
    * \ingroup Mapper
    */
   class MITKMULTILABEL_EXPORT LabelSetImageVtkMapper2D : public VtkMapper
   {
   public:
     /** Standard class typedefs. */
     mitkClassMacro(LabelSetImageVtkMapper2D, VtkMapper);
 
     /** Method for creation through the object factory. */
     itkNewMacro(Self);
 
     /** \brief Get the Image to map */
     const mitk::Image *GetInput(void);
 
     /** \brief Checks whether this mapper needs to update itself and generate
      * data. */
     void Update(mitk::BaseRenderer *renderer) override;
 
     //### methods of MITK-VTK rendering pipeline
     vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
     //### end of methods of MITK-VTK rendering pipeline
 
     /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
     /**
        * To render axial, coronal, and sagittal, the mapper is called three times.
        * For performance reasons, the corresponding data for each view is saved in the
        * internal helper class LocalStorage. This allows rendering n views with just
        * 1 mitkMapper using n vtkMapper.
        * */
     class MITKMULTILABEL_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
     {
     public:
       vtkSmartPointer<vtkPropAssembly> m_Actors;
 
+      /** Vector containing the pointer of the currently used group images.
+       * IMPORTANT: This member must not be used to access any data.
+       * Its purpose is to allow checking if the order of the groups has changed
+       * in order to adapt the pipe line accordingly*/
+      std::vector<const Image*> m_GroupImageIDs;
+
       std::vector<vtkSmartPointer<vtkActor>> m_LayerActorVector;
       std::vector<vtkSmartPointer<vtkPolyDataMapper>> m_LayerMapperVector;
       std::vector<vtkSmartPointer<vtkImageData>> m_ReslicedImageVector;
+      std::vector<vtkSmartPointer<vtkImageMapToColors>> m_LayerImageMapToColors;
       std::vector<vtkSmartPointer<vtkNeverTranslucentTexture>> m_LayerTextureVector;
 
       vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
       vtkSmartPointer<vtkPlaneSource> m_Plane;
 
       std::vector<mitk::ExtractSliceFilter::Pointer> m_ReslicerVector;
 
       vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
       /** \brief An actor for the outline */
       vtkSmartPointer<vtkActor> m_OutlineActor;
       /** \brief An actor for the outline shadow*/
       vtkSmartPointer<vtkActor> m_OutlineShadowActor;
       /** \brief A mapper for the outline */
       vtkSmartPointer<vtkPolyDataMapper> m_OutlineMapper;
 
       /** \brief Timestamp of last update of stored data. */
       itk::TimeStamp m_LastDataUpdateTime;
-
       /** \brief Timestamp of last update of a property. */
       itk::TimeStamp m_LastPropertyUpdateTime;
+      /** \brief Timestamp of last update of a property. */
+      itk::TimeStamp m_LastActiveLabelUpdateTime;
 
       /** \brief mmPerPixel relation between pixel and mm. (World spacing).*/
       mitk::ScalarType *m_mmPerPixel;
 
-      int m_NumberOfLayers;
+      /** look up table for label colors. */
+      mitk::LookupTable::Pointer m_LabelLookupTable;
+
+      mitk::PlaneGeometry::Pointer m_WorldPlane;
+      bool m_HasValidContent;
 
-      /** \brief This filter is used to apply the level window to Grayvalue and RBG(A) images. */
-      // vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
-      std::vector<vtkSmartPointer<vtkMitkLevelWindowFilter>> m_LevelWindowFilterVector;
+      unsigned int m_NumberOfLayers;
 
       /** \brief Default constructor of the local storage. */
       LocalStorage();
-      /** \brief Default deconstructor of the local storage. */
+      /** \brief Default destructor of the local storage. */
       ~LocalStorage() override;
     };
 
     /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
     mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
     /** \brief Get the LocalStorage corresponding to the current renderer. */
     LocalStorage *GetLocalStorage(mitk::BaseRenderer *renderer);
 
     /** \brief Set the default properties for general image rendering. */
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
     /** \brief This method switches between different rendering modes (e.g. use a lookup table or a transfer function).
      * Detailed documentation about the modes can be found here: \link mitk::RenderingModeProperty \endlink
      */
     void ApplyRenderingMode(mitk::BaseRenderer *renderer);
 
   protected:
     /** \brief Transforms the actor to the actual position in 3D.
       *   \param renderer The current renderer corresponding to the render window.
       */
     void TransformActor(mitk::BaseRenderer *renderer);
 
     /** \brief Generates a plane according to the size of the resliced image in milimeters.
       *
       * In VTK a vtkPlaneSource is defined through three points. The origin and two
       * points defining the axes of the plane (see VTK documentation). The origin is
       * set to (xMin; yMin; Z), where xMin and yMin are the minimal bounds of the
       * resliced image in space. Z is relevant for blending and the layer property.
       * The center of the plane (C) is also the center of the view plane (cf. the image above).
       *
       * \note For the standard MITK view with three 2D render windows showing three
       * different slices, three such planes are generated. All these planes are generated
       * in the XY-plane (even if they depict a YZ-slice of the volume).
       *
       */
     void GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6]);
 
     /** \brief Generates a vtkPolyData object containing the outline of a given binary slice.
         \param renderer Pointer to the renderer containing the needed information
         \param image
         \param pixelValue
         \note This code is based on code from the iil library.
         */
     vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer *renderer,
                                                        vtkImageData *image,
                                                        int pixelValue = 1);
 
     /** Default constructor */
     LabelSetImageVtkMapper2D();
     /** Default deconstructor */
     ~LabelSetImageVtkMapper2D() override;
 
     /** \brief Does the actual resampling, without rendering the image yet.
       * All the data is generated inside this method. The vtkProp (or Actor)
       * is filled with content (i.e. the resliced image).
       *
       * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
       * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
       * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
       * to the actual 3D position (cf. the following image).
       *
       * \image html cameraPositioning3D.png
       *
       */
     void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
+    void GenerateImageSlice(mitk::BaseRenderer* renderer, const std::vector<mitk::LabelSetImage::GroupIndexType>& outdatedGroupIDs);
+
+    void GenerateActiveLabelOutline(mitk::BaseRenderer* renderer);
+
+    /** \brief Generates the look up table that should be used.
+      */
+    void GenerateLookupTable(mitk::BaseRenderer* renderer);
+
     /** \brief This method uses the vtkCamera clipping range and the layer property
       * to calcualte the depth of the object (e.g. image or contour). The depth is used
       * to keep the correct order for the final VTK rendering.*/
     float CalculateLayerDepth(mitk::BaseRenderer *renderer);
 
-    /** \brief This method applies (or modifies) the lookuptable for all types of images.
-     * \warning To use the lookup table, the property 'Lookup Table' must be set and a 'Image Rendering.Mode'
-     * which uses the lookup table must be set.
-  */
-    void ApplyLookuptable(mitk::BaseRenderer *renderer, int layer);
-
-    /** \brief This method applies a color transfer function.
-     * Internally, a vtkColorTransferFunction is used. This is usefull for coloring continous
-     * images (e.g. float)
-     * \warning To use the color transfer function, the property 'Image Rendering.Transfer Function' must be set and a
-     * 'Image Rendering.Mode' which uses the color transfer function must be set.
-  */
-    void ApplyColorTransferFunction(mitk::BaseRenderer *renderer);
-
-    /**
-     * @brief ApplyLevelWindow Apply the level window for the given renderer.
-     * \warning To use the level window, the property 'LevelWindow' must be set and a 'Image Rendering.Mode' which uses
-     * the level window must be set.
-     * @param renderer Level window for which renderer?
-     */
-    void ApplyLevelWindow(mitk::BaseRenderer *renderer);
-
-    /** \brief Set the color of the image/polydata */
-    void ApplyColor(mitk::BaseRenderer *renderer, const mitk::Color &color);
-
-    /** \brief Set the opacity of the actor. */
-    void ApplyOpacity(mitk::BaseRenderer *renderer, int layer);
-
     /**
       * \brief Calculates whether the given rendering geometry intersects the
       * given SlicedGeometry3D.
       *
       * This method checks if the given Geometry2D intersects the given
       * SlicedGeometry3D. It calculates the distance of the Geometry2D to all
       * 8 cornerpoints of the SlicedGeometry3D. If all distances have the same
       * sign (all positive or all negative) there is no intersection.
       * If the distances have different sign, there is an intersection.
       **/
-    bool RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry, SlicedGeometry3D *imageGeometry);
+    bool RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry, const BaseGeometry* imageGeometry) const;
   };
 
 } // namespace mitk
 
 #endif
diff --git a/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp
new file mode 100644
index 0000000000..27a5d47030
--- /dev/null
+++ b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.cpp
@@ -0,0 +1,350 @@
+/*============================================================================
+
+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 "mitkMultiLabelSegmentationVtkMapper3D.h"
+
+// MITK
+#include <mitkDataNode.h>
+#include <mitkProperties.h>
+#include <mitkVectorProperty.h>
+
+// MITK Rendering
+
+// VTK
+#include <vtkImageData.h>
+#include <vtkLookupTable.h>
+#include <vtkVolume.h>
+#include <vtkSmartVolumeMapper.h>
+#include <vtkVolumeProperty.h>
+#include <vtkSmartPointer.h>
+#include <vtkColorTransferFunction.h>
+#include <vtkPiecewiseFunction.h>
+
+#include <vtkProperty.h>
+
+namespace
+{
+  itk::ModifiedTimeType PropertyTimeStampIsNewer(const mitk::IPropertyProvider* provider, mitk::BaseRenderer* renderer, const std::string& propName, itk::ModifiedTimeType refMT)
+  {
+    const std::string context = renderer != nullptr ? renderer->GetName() : "";
+    auto prop = provider->GetConstProperty(propName, context);
+    if (prop != nullptr)
+    {
+      return prop->GetTimeStamp() > refMT;
+    }
+    return false;
+  }
+}
+
+mitk::MultiLabelSegmentationVtkMapper3D::MultiLabelSegmentationVtkMapper3D()
+{
+}
+
+mitk::MultiLabelSegmentationVtkMapper3D::~MultiLabelSegmentationVtkMapper3D()
+{
+}
+
+vtkProp *mitk::MultiLabelSegmentationVtkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
+{
+  // return the actor corresponding to the renderer
+  return m_LSH.GetLocalStorage(renderer)->m_Actors;
+}
+
+mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage *mitk::MultiLabelSegmentationVtkMapper3D::GetLocalStorage(
+  mitk::BaseRenderer *renderer)
+{
+  return m_LSH.GetLocalStorage(renderer);
+}
+
+void mitk::MultiLabelSegmentationVtkMapper3D::GenerateLookupTable(mitk::BaseRenderer* renderer)
+{
+  LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode* node = this->GetDataNode();
+  auto* image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
+  assert(image && image->IsInitialized());
+
+  localStorage->m_LabelLookupTable = image->GetLookupTable()->Clone();
+  auto lookUpTable = localStorage->m_LabelLookupTable->GetVtkLookupTable();
+
+  const auto labelValues = image->GetAllLabelValues();
+
+  std::string propertyName = "org.mitk.multilabel.labels.highlighted";
+
+  mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
+  if (nullptr != prop)
+  {
+    const auto highlightedLabelValues = prop->GetValue();
+
+    if (!highlightedLabelValues.empty())
+    {
+      auto highlightEnd = highlightedLabelValues.cend();
+
+      double rgba[4];
+      for (const auto& value : labelValues)
+      {
+        lookUpTable->GetTableValue(value, rgba);
+        if (highlightEnd == std::find(highlightedLabelValues.begin(), highlightedLabelValues.end(), value))
+        { //make all none highlighted values more transparent
+          rgba[3] *= 0.05;
+        }
+        else
+        {
+          if (rgba[3] != 0)
+          { //if highlighted values are visible set them to opaque to pop out
+            rgba[3] = 1.;
+          }
+          else
+          { //if highlighted values are invisible the opacity is increased a bit
+            //to give a visual hint that the are highlighted but also invisible.
+            //e.g. needed to see a difference if you change the visibility of
+            //a highlighted label in the MultiLabelInspector
+            rgba[3] = 0.2;
+          }
+        }
+        lookUpTable->SetTableValue(value, rgba);
+      }
+      localStorage->m_LabelLookupTable->Modified(); // need to call modified, since LookupTableProperty seems to be unchanged so no widget-update is
+      // executed
+    }
+  }
+
+  const auto nrOfGroups = image->GetNumberOfLayers();
+  for (unsigned int groupID = 0; groupID < nrOfGroups; ++groupID)
+  {
+    localStorage->m_TransferFunctions[groupID] = vtkSmartPointer<vtkColorTransferFunction>::New();
+    localStorage->m_OpacityTransferFunctions[groupID] = vtkSmartPointer<vtkPiecewiseFunction>::New();
+
+    localStorage->m_TransferFunctions[groupID]->AddRGBPoint(0, 0., 0., 1.);
+    localStorage->m_OpacityTransferFunctions[groupID]->AddPoint(0, 0.);
+
+    for (const auto& value : image->GetLabelValuesByGroup(groupID))
+    {
+      double* color = lookUpTable->GetTableValue(value);
+      localStorage->m_TransferFunctions[groupID]->AddRGBPoint(value, color[0], color[1], color[2]);
+
+      localStorage->m_OpacityTransferFunctions[groupID]->AddPoint(value, color[3]);
+    }
+  }
+}
+
+namespace
+{
+  std::vector<mitk::LabelSetImage::GroupIndexType> GetOutdatedGroups(const mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage* ls, const mitk::LabelSetImage* seg)
+  {
+    const auto nrOfGroups = seg->GetNumberOfLayers();
+    std::vector<mitk::LabelSetImage::GroupIndexType> result;
+
+    for (mitk::LabelSetImage::GroupIndexType groupID = 0; groupID < nrOfGroups; ++groupID)
+    {
+      const auto groupImage = seg->GetGroupImage(groupID);
+      if (groupImage->GetMTime() > ls->m_LastDataUpdateTime
+        || groupImage->GetPipelineMTime() > ls->m_LastDataUpdateTime
+        || ls->m_GroupImageIDs.size() <= groupID
+        || groupImage != ls->m_GroupImageIDs[groupID])
+      {
+        result.push_back(groupID);
+      }
+    }
+    return result;
+  }
+}
+
+void mitk::MultiLabelSegmentationVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
+{
+  LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode *node = this->GetDataNode();
+  auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
+  assert(image && image->IsInitialized());
+
+  bool isLookupModified = localStorage->m_LabelLookupTable.IsNull() ||
+    (localStorage->m_LabelLookupTable->GetMTime() < image->GetLookupTable()->GetMTime()) ||
+    PropertyTimeStampIsNewer(node, renderer, "org.mitk.multilabel.labels.highlighted", localStorage->m_LabelLookupTable->GetMTime()) ||
+    PropertyTimeStampIsNewer(node, renderer, "opacity", localStorage->m_LabelLookupTable->GetMTime());
+
+  auto outdatedGroups = GetOutdatedGroups(localStorage, image);
+
+  bool isGeometryModified = (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
+    (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime());
+
+  if (isGeometryModified)
+  {
+    //if geometry is outdated all groups need regeneration
+    outdatedGroups.resize(image->GetNumberOfLayers());
+    std::iota(outdatedGroups.begin(), outdatedGroups.end(), 0);
+  }
+
+  if (!outdatedGroups.empty())
+  {
+    auto hasValidContent = this->GenerateVolumeMapping(renderer, outdatedGroups);
+    if (!hasValidContent) return;
+  }
+
+  if (isLookupModified)
+  {
+    this->GenerateLookupTable(renderer);
+  }
+
+  if (isLookupModified)
+  {
+    //if lookup table is modified all groups need a new color mapping
+    outdatedGroups.resize(image->GetNumberOfLayers());
+    std::iota(outdatedGroups.begin(), outdatedGroups.end(), 0);
+  }
+
+  for (const auto groupID : outdatedGroups)
+  {
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->SetColor(localStorage->m_TransferFunctions[groupID]);
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->SetScalarOpacity(localStorage->m_OpacityTransferFunctions[groupID]);
+    localStorage->m_LayerVolumes[groupID]->Update();
+  }
+}
+
+bool mitk::MultiLabelSegmentationVtkMapper3D::GenerateVolumeMapping(mitk::BaseRenderer* renderer, const std::vector<mitk::LabelSetImage::GroupIndexType>& outdatedGroupIDs)
+{
+  LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
+  mitk::DataNode* node = this->GetDataNode();
+  auto* image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
+  assert(image && image->IsInitialized());
+
+  image->Update();
+
+  const auto numberOfGroups = image->GetNumberOfLayers();
+
+  if (numberOfGroups != localStorage->m_NumberOfGroups)
+  {
+    if (numberOfGroups > localStorage->m_NumberOfGroups)
+    {
+      for (unsigned int groupID = localStorage->m_NumberOfGroups; groupID < numberOfGroups; ++groupID)
+      {
+        localStorage->m_GroupImageIDs.push_back(nullptr);
+        localStorage->m_LayerImages.push_back(vtkSmartPointer<vtkImageData>::New());
+        localStorage->m_LayerVolumeMappers.push_back(vtkSmartPointer<vtkSmartVolumeMapper>::New());
+        localStorage->m_LayerVolumes.push_back(vtkSmartPointer<vtkVolume>::New());
+
+        localStorage->m_TransferFunctions.push_back(vtkSmartPointer<vtkColorTransferFunction>::New());
+        localStorage->m_OpacityTransferFunctions.push_back(vtkSmartPointer<vtkPiecewiseFunction>::New());
+      }
+    }
+    else
+    {
+      localStorage->m_GroupImageIDs.resize(numberOfGroups);
+      localStorage->m_LayerImages.resize(numberOfGroups);
+      localStorage->m_LayerVolumeMappers.resize(numberOfGroups);
+      localStorage->m_LayerVolumes.resize(numberOfGroups);
+
+      localStorage->m_TransferFunctions.resize(numberOfGroups);
+      localStorage->m_OpacityTransferFunctions.resize(numberOfGroups);
+    }
+
+    localStorage->m_NumberOfGroups = numberOfGroups;
+
+    localStorage->m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
+
+    for (unsigned int groupID = 0; groupID < numberOfGroups; ++groupID)
+    {
+      localStorage->m_Actors->AddPart(localStorage->m_LayerVolumes[groupID]);
+    }
+  }
+
+  for (const auto groupID : outdatedGroupIDs)
+  {
+    const auto groupImage = image->GetGroupImage(groupID);
+    localStorage->m_GroupImageIDs[groupID] = groupImage;
+
+    localStorage->m_LayerImages[groupID] = groupImage->GetVtkImageData(this->GetTimestep());
+
+    //need to recreate the volumeMapper because otherwise label data was still rendered even
+    //if a label was removed. There must be a cleaner way to do it. Exchanging the whole mapper
+    //is a ugly workaround for now.
+    localStorage->m_LayerVolumeMappers[groupID] = vtkSmartPointer<vtkSmartVolumeMapper>::New();
+
+    localStorage->m_LayerVolumeMappers[groupID]->SetInputData(localStorage->m_LayerImages[groupID]);
+
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->ShadeOn();
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->SetDiffuse(1.0);
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->SetAmbient(0.4);
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->SetSpecular(0.2);
+    localStorage->m_LayerVolumes[groupID]->GetProperty()->SetInterpolationTypeToNearest();
+
+    localStorage->m_LayerVolumes[groupID]->SetMapper(localStorage->m_LayerVolumeMappers[groupID]);
+  }
+  localStorage->m_LastDataUpdateTime.Modified();
+  return true;
+}
+
+void mitk::MultiLabelSegmentationVtkMapper3D::Update(mitk::BaseRenderer *renderer)
+{
+  bool visible = true;
+  bool has3Dvisualize = true;
+  const DataNode *node = this->GetDataNode();
+  node->GetVisibility(visible, renderer, "visible");
+  node->GetBoolProperty("multilabel.3D.visualize", has3Dvisualize, renderer);
+  if (!visible || !has3Dvisualize)
+    return;
+
+  auto *image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
+
+  if (image == nullptr || image->IsInitialized() == false)
+    return;
+
+  // Calculate time step of the image data for the specified renderer (integer value)
+  this->CalculateTimeStep(renderer);
+
+  // Check if time step is valid
+  const TimeGeometry *dataTimeGeometry = image->GetTimeGeometry();
+  if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
+      (!dataTimeGeometry->IsValidTimeStep(this->GetTimestep())))
+  {
+    return;
+  }
+
+  image->UpdateOutputInformation();
+  LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
+
+  // check if something important has changed and we need to re-render
+
+  if (localStorage->m_LabelLookupTable.IsNull() ||
+      (localStorage->m_LabelLookupTable->GetMTime() < image->GetLookupTable()->GetMTime()) ||
+      (localStorage->m_LastDataUpdateTime < image->GetMTime()) ||
+      (localStorage->m_LastDataUpdateTime < image->GetPipelineMTime()) ||
+      (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) ||
+      (localStorage->m_LastDataUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
+      (localStorage->m_LastPropertyUpdateTime < node->GetPropertyList()->GetMTime()) ||
+      (localStorage->m_LastPropertyUpdateTime < node->GetPropertyList(renderer)->GetMTime()) ||
+      (localStorage->m_LastPropertyUpdateTime < image->GetPropertyList()->GetMTime()))
+  {
+    this->GenerateDataForRenderer(renderer);
+    localStorage->m_LastPropertyUpdateTime.Modified();
+  }
+}
+
+void mitk::MultiLabelSegmentationVtkMapper3D::SetDefaultProperties(mitk::DataNode *node,
+                                                          mitk::BaseRenderer *renderer,
+                                                          bool overwrite)
+{
+  Superclass::SetDefaultProperties(node, renderer, overwrite);
+
+  // add/replace the following properties
+  node->SetProperty("multilabel.3D.visualize", BoolProperty::New(false), renderer);
+}
+
+mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage::~LocalStorage()
+{
+}
+
+mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage::LocalStorage()
+{
+  // Do as much actions as possible in here to avoid double executions.
+  m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
+
+  m_NumberOfGroups = 0;
+}
diff --git a/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h
new file mode 100644
index 0000000000..043096f2a6
--- /dev/null
+++ b/Modules/Multilabel/mitkMultiLabelSegmentationVtkMapper3D.h
@@ -0,0 +1,149 @@
+/*============================================================================
+
+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 mitkMultiLabelSegmentationVtkMapper3D_h
+#define mitkMultiLabelSegmentationVtkMapper3D_h
+
+// MITK
+#include "MitkMultilabelExports.h"
+#include "mitkCommon.h"
+
+// MITK Rendering
+#include "mitkBaseRenderer.h"
+#include "mitkExtractSliceFilter.h"
+#include "mitkLabelSetImage.h"
+#include "mitkVtkMapper.h"
+
+// VTK
+#include <vtkSmartPointer.h>
+
+class vtkPolyDataMapper;
+class vtkImageData;
+class vtkLookupTable;
+class vtkVolumeProperty;
+class vtkVolume;
+class vtkSmartVolumeMapper;
+
+namespace mitk
+{
+
+  /** \brief Mapper to resample and display 2D slices of a 3D labelset image.
+   *
+   * Properties that can be set for labelset images and influence this mapper are:
+   *
+   *   - \b "labelset.contour.active": (BoolProperty) whether to show only the active label as a contour or not
+   *   - \b "labelset.contour.width": (FloatProperty) line width of the contour
+
+   * The default properties are:
+
+   *   - \b "labelset.contour.active", mitk::BoolProperty::New( true ), renderer, overwrite )
+   *   - \b "labelset.contour.width", mitk::FloatProperty::New( 2.0 ), renderer, overwrite )
+
+   * \ingroup Mapper
+   */
+  class MITKMULTILABEL_EXPORT MultiLabelSegmentationVtkMapper3D : public VtkMapper
+  {
+  public:
+    /** Standard class typedefs. */
+    mitkClassMacro(MultiLabelSegmentationVtkMapper3D, VtkMapper);
+
+    /** Method for creation through the object factory. */
+    itkNewMacro(Self);
+
+    /** \brief Checks whether this mapper needs to update itself and generate
+     * data. */
+    void Update(mitk::BaseRenderer *renderer) override;
+
+    //### methods of MITK-VTK rendering pipeline
+    vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
+    //### end of methods of MITK-VTK rendering pipeline
+
+    /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */
+    /**
+       * To render axial, coronal, and sagittal, the mapper is called three times.
+       * For performance reasons, the corresponding data for each view is saved in the
+       * internal helper class LocalStorage. This allows rendering n views with just
+       * 1 mitkMapper using n vtkMapper.
+       * */
+    class MITKMULTILABEL_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
+    {
+    public:
+      vtkSmartPointer<vtkPropAssembly> m_Actors;
+
+      std::vector<vtkSmartPointer<vtkSmartVolumeMapper>> m_LayerVolumeMappers;
+      std::vector<vtkSmartPointer<vtkImageData>> m_LayerImages;
+      std::vector<vtkSmartPointer<vtkVolume>> m_LayerVolumes;
+
+      std::vector <vtkSmartPointer<vtkColorTransferFunction> > m_TransferFunctions;
+      std::vector <vtkSmartPointer<vtkPiecewiseFunction> > m_OpacityTransferFunctions;
+
+      /** Vector containing the pointer of the currently used group images.
+       * IMPORTANT: This member must not be used to access any data.
+       * Its purpose is to allow checking if the order of the groups has changed
+       * in order to adapt the pipe line accordingly*/
+      std::vector<const Image*> m_GroupImageIDs;
+
+      /** \brief Timestamp of last update of stored data. */
+      itk::TimeStamp m_LastDataUpdateTime;
+      /** \brief Timestamp of last update of a property. */
+      itk::TimeStamp m_LastPropertyUpdateTime;
+
+      /** look up table for label colors. */
+      mitk::LookupTable::Pointer m_LabelLookupTable;
+
+      unsigned int m_NumberOfGroups;
+
+      /** \brief Default constructor of the local storage. */
+      LocalStorage();
+      /** \brief Default destructor of the local storage. */
+      ~LocalStorage() override;
+    };
+
+    /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */
+    mitk::LocalStorageHandler<LocalStorage> m_LSH;
+
+    /** \brief Get the LocalStorage corresponding to the current renderer. */
+    LocalStorage *GetLocalStorage(mitk::BaseRenderer *renderer);
+
+    /** \brief Set the default properties for general image rendering. */
+    static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
+
+  protected:
+    /** Default constructor */
+    MultiLabelSegmentationVtkMapper3D();
+    /** Default deconstructor */
+    ~MultiLabelSegmentationVtkMapper3D() override;
+
+    /** \brief Does the actual resampling, without rendering the image yet.
+      * All the data is generated inside this method. The vtkProp (or Actor)
+      * is filled with content (i.e. the resliced image).
+      *
+      * After generation, a 4x4 transformation matrix(t) of the current slice is obtained
+      * from the vtkResliceImage object via GetReslicesAxis(). This matrix is
+      * applied to each textured plane (actor->SetUserTransform(t)) to transform everything
+      * to the actual 3D position (cf. the following image).
+      *
+      * \image html cameraPositioning3D.png
+      *
+      */
+    void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
+
+    bool GenerateVolumeMapping(mitk::BaseRenderer* renderer, const std::vector<mitk::LabelSetImage::GroupIndexType>& outdatedGroupIDs);
+
+    /** \brief Generates the look up table that should be used.
+      */
+    void GenerateLookupTable(mitk::BaseRenderer* renderer);
+  };
+
+} // namespace mitk
+
+#endif
diff --git a/Modules/Multilabel/mitkMultilabelObjectFactory.cpp b/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
index 03be75a0e8..6e0e75742a 100644
--- a/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
+++ b/Modules/Multilabel/mitkMultilabelObjectFactory.cpp
@@ -1,124 +1,134 @@
 /*============================================================================
 
 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 "mitkMultilabelObjectFactory.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include <mitkCoreServices.h>
 #include <mitkIPropertyFilters.h>
 #include <mitkLabelSetImageVtkMapper2D.h>
+#include <mitkMultiLabelSegmentationVtkMapper3D.h>
 #include <mitkPropertyFilter.h>
 
 mitk::MultilabelObjectFactory::MultilabelObjectFactory() : CoreObjectFactoryBase()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "MultilabelObjectFactory c'tor" << std::endl;
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::MultilabelObjectFactory::~MultilabelObjectFactory()
 {
 }
 
 mitk::Mapper::Pointer mitk::MultilabelObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::BaseData *data = node->GetData();
 
   if (id == mitk::BaseRenderer::Standard2D)
   {
     if ((dynamic_cast<mitk::LabelSetImage *>(data) != nullptr))
     {
       newMapper = mitk::LabelSetImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
   }
+  else if (id == mitk::BaseRenderer::Standard3D)
+  {
+    if ((dynamic_cast<mitk::LabelSetImage*>(data) != nullptr))
+    {
+      newMapper = mitk::MultiLabelSegmentationVtkMapper3D::New();
+      newMapper->SetDataNode(node);
+    }
+  }
   return newMapper;
 }
 
 void mitk::MultilabelObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   if (node->GetData() == nullptr)
     return;
 
   if (dynamic_cast<LabelSetImage *>(node->GetData()) != nullptr)
   {
     mitk::LabelSetImageVtkMapper2D::SetDefaultProperties(node);
+    mitk::MultiLabelSegmentationVtkMapper3D::SetDefaultProperties(node);
 
     auto propertyFilters = CoreServices::GetPropertyFilters();
 
     if (propertyFilters != nullptr)
     {
       PropertyFilter labelSetImageFilter;
       labelSetImageFilter.AddEntry("binaryimage.hoveringannotationcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("binaryimage.hoveringcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("binaryimage.selectedannotationcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("binaryimage.selectedcolor", PropertyFilter::Blacklist);
       labelSetImageFilter.AddEntry("outline binary shadow color", PropertyFilter::Blacklist);
 
       propertyFilters->AddFilter(labelSetImageFilter, "LabelSetImage");
     }
   }
 }
 
 std::string mitk::MultilabelObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::MultilabelObjectFactory::GetFileExtensionsMap()
 {
   return {};
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::MultilabelObjectFactory::GetSaveFileExtensionsMap()
 {
   return {};
 }
 
 void mitk::MultilabelObjectFactory::CreateFileExtensionsMap()
 {
 }
 
 std::string mitk::MultilabelObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions({}, fileExtension);
   return fileExtension.c_str();
 }
 
 struct RegisterMultilabelObjectFactory
 {
   RegisterMultilabelObjectFactory() : m_Factory(mitk::MultilabelObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterMultilabelObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::MultilabelObjectFactory::Pointer m_Factory;
 };
 
 static RegisterMultilabelObjectFactory registerMultilabelObjectFactory;
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp
index f7fa9929f6..a5ab871e72 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp
@@ -1,1336 +1,1415 @@
 /*============================================================================
 
 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 <QmitkMultiLabelInspector.h>
 
 // mitk
 #include <mitkRenderingManager.h>
 #include <mitkLabelSetImageHelper.h>
 #include <mitkDICOMSegmentationPropertyHelper.h>
+#include <mitkVectorProperty.h>
 
 // Qmitk
 #include <QmitkMultiLabelTreeModel.h>
 #include <QmitkLabelColorItemDelegate.h>
 #include <QmitkLabelToggleItemDelegate.h>
 #include <QmitkStyleManager.h>
 
 // Qt
 #include <QMenu>
 #include <QLabel>
 #include <QWidgetAction>
 #include <QMessageBox>
 
 #include <ui_QmitkMultiLabelInspectorControls.h>
 
+namespace
+{
+  void ActivateLabelHighlights(mitk::DataNode* node, const mitk::LabelSetImage::LabelValueVectorType highlightedValues)
+  {
+    const std::string propertyName = "org.mitk.multilabel.labels.highlighted";
+
+    mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
+    if (nullptr == prop)
+    {
+      prop = mitk::IntVectorProperty::New();
+      node->SetProperty(propertyName, prop);
+    }
+
+    mitk::IntVectorProperty::VectorType intValues(highlightedValues.begin(), highlightedValues.end());
+    prop->SetValue(intValues);
+    prop->Modified(); //see T30386; needed because VectorProperty::SetValue does currently trigger no modified
+    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  }
+
+  void DeactivateLabelHighlights(mitk::DataNode* node)
+  {
+    std::string propertyName = "org.mitk.multilabel.labels.highlighted";
+
+    mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
+    if (nullptr != prop)
+    {
+      prop->SetValue({});
+      prop->Modified(); //see T30386; needed because VectorProperty::SetValue does currently trigger no modified
+
+      mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+    }
+  }
+}
+
 QmitkMultiLabelInspector::QmitkMultiLabelInspector(QWidget* parent/* = nullptr*/)
   : QWidget(parent), m_Controls(new Ui::QmitkMultiLabelInspector), m_SegmentationNodeDataMTime(0)
 {
   m_Controls->setupUi(this);
 
   m_Model = new QmitkMultiLabelTreeModel(this);
 
   m_Controls->view->setModel(m_Model);
 
   m_ColorItemDelegate = new QmitkLabelColorItemDelegate(this);
 
   auto visibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg"));
   auto invisibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg"));
   m_VisibilityItemDelegate = new QmitkLabelToggleItemDelegate(visibleIcon, invisibleIcon, this);
 
   auto lockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
   auto unlockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
   m_LockItemDelegate = new QmitkLabelToggleItemDelegate(lockIcon, unlockIcon, this);
 
   auto* view = this->m_Controls->view;
   view->setItemDelegateForColumn(1, m_LockItemDelegate);
   view->setItemDelegateForColumn(2, m_ColorItemDelegate);
   view->setItemDelegateForColumn(3, m_VisibilityItemDelegate);
 
   auto* header = view->header();
   header->setSectionResizeMode(0,QHeaderView::Stretch);
   header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
   header->setSectionResizeMode(2, QHeaderView::ResizeToContents);
   header->setSectionResizeMode(3, QHeaderView::ResizeToContents);
   view->setContextMenuPolicy(Qt::CustomContextMenu);
 
   connect(m_Model, &QAbstractItemModel::modelReset, this, &QmitkMultiLabelInspector::OnModelReset);
   connect(m_Model, &QAbstractItemModel::dataChanged, this, &QmitkMultiLabelInspector::OnDataChanged);
   connect(view->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), SLOT(OnChangeModelSelection(const QItemSelection&, const QItemSelection&)));
   connect(view, &QAbstractItemView::customContextMenuRequested, this, &QmitkMultiLabelInspector::OnContextMenuRequested);
   connect(view, &QAbstractItemView::doubleClicked, this, &QmitkMultiLabelInspector::OnItemDoubleClicked);
+  connect(view, &QAbstractItemView::entered, this, &QmitkMultiLabelInspector::OnEntered);
+  connect(view, &QmitkMultiLabelTreeView::MouseLeave, this, &QmitkMultiLabelInspector::OnMouseLeave);
 }
 
 QmitkMultiLabelInspector::~QmitkMultiLabelInspector()
 {
   delete m_Controls;
 }
 
 void QmitkMultiLabelInspector::Initialize()
 {
   m_LastValidSelectedLabels = {};
   m_ModelManipulationOngoing = false;
   m_Model->SetSegmentation(m_Segmentation);
   m_Controls->view->expandAll();
 
   m_LastValidSelectedLabels = {};
 
   //in singel selection mode, if at least one label exist select the first label of the mode.
   if (m_Segmentation.IsNotNull() && !this->GetMultiSelectionMode() && m_Segmentation->GetTotalNumberOfLabels() > 0)
   {
     auto firstIndex = m_Model->FirstLabelInstanceIndex(QModelIndex());
     auto labelVariant = firstIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
 
     if (labelVariant.isValid())
     {
       this->SetSelectedLabel(labelVariant.value<LabelValueType>());
       m_Controls->view->selectionModel()->setCurrentIndex(firstIndex, QItemSelectionModel::NoUpdate);
     }
   }
 }
 
 void QmitkMultiLabelInspector::SetMultiSelectionMode(bool multiMode)
 {
   m_Controls->view->setSelectionMode(multiMode
      ? QAbstractItemView::SelectionMode::MultiSelection
      : QAbstractItemView::SelectionMode::SingleSelection);
 }
 
 bool QmitkMultiLabelInspector::GetMultiSelectionMode() const
 {
   return QAbstractItemView::SelectionMode::MultiSelection == m_Controls->view->selectionMode();
 }
 
 void QmitkMultiLabelInspector::SetAllowVisibilityModification(bool visibilityMod)
 {
   m_AllowVisibilityModification = visibilityMod;
   this->m_Model->SetAllowVisibilityModification(visibilityMod);
 }
 
 void QmitkMultiLabelInspector::SetAllowLabelModification(bool labelMod)
 {
   m_AllowLabelModification = labelMod;
 }
 
 bool QmitkMultiLabelInspector::GetAllowVisibilityModification() const
 {
   return m_AllowVisibilityModification;
 }
 
 void QmitkMultiLabelInspector::SetAllowLockModification(bool lockMod)
 {
   m_AllowLockModification = lockMod;
   this->m_Model->SetAllowLockModification(lockMod);
 }
 
 bool QmitkMultiLabelInspector::GetAllowLockModification() const
 {
   return m_AllowLockModification;
 }
 
 bool QmitkMultiLabelInspector::GetAllowLabelModification() const
 {
   return m_AllowLabelModification;
 }
 
 void QmitkMultiLabelInspector::SetDefaultLabelNaming(bool defaultLabelNaming)
 {
   m_DefaultLabelNaming = defaultLabelNaming;
 }
 
 void QmitkMultiLabelInspector::SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation)
 {
   if (segmentation != m_Segmentation)
   {
     m_Segmentation = segmentation;
     this->Initialize();
     emit SegmentationChanged();
   }
 }
 
 mitk::LabelSetImage* QmitkMultiLabelInspector::GetMultiLabelSegmentation() const
 {
   return m_Segmentation;
 }
 
 void QmitkMultiLabelInspector::SetMultiLabelNode(mitk::DataNode* node)
 {
   if (node != this->m_SegmentationNode.GetPointer())
   {
     m_SegmentationObserver.Reset();
     m_SegmentationNode = node;
     m_SegmentationNodeDataMTime = 0;
 
     if (m_SegmentationNode.IsNotNull())
     {
       auto& widget = *this;
       auto checkAndSetSeg = [&widget, node](const itk::EventObject&)
         {
           if (widget.m_SegmentationNodeDataMTime < node->GetDataReferenceChangedTime())
           {
             auto newSeg = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
             if (nullptr == newSeg) mitkThrow() << "Invalid usage. Node set does not contain a segmentation.";
 
             widget.m_SegmentationNodeDataMTime = node->GetDataReferenceChangedTime();
             widget.SetMultiLabelSegmentation(newSeg);
           }
         };
 
       m_SegmentationObserver.Reset(node, itk::ModifiedEvent(), checkAndSetSeg);
       checkAndSetSeg(itk::ModifiedEvent());
     }
     else
     {
       this->SetMultiLabelSegmentation(nullptr);
     }
   }
 }
 
 mitk::DataNode* QmitkMultiLabelInspector::GetMultiLabelNode() const
 {
   return m_SegmentationNode;
 }
 
 
 bool QmitkMultiLabelInspector::GetModelManipulationOngoing() const
 {
   return m_ModelManipulationOngoing;
 }
 
 void QmitkMultiLabelInspector::OnModelReset()
 {
   m_LastValidSelectedLabels = {};
   m_ModelManipulationOngoing = false;
 }
 
 void QmitkMultiLabelInspector::OnDataChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/,
   const QList<int>& /*roles*/)
 {
   if (!m_ModelManipulationOngoing && topLeft.isValid())
     m_Controls->view->expand(topLeft);
 }
 
 bool EqualLabelSelections(const QmitkMultiLabelInspector::LabelValueVectorType& selection1, const QmitkMultiLabelInspector::LabelValueVectorType& selection2)
 {
   if (selection1.size() == selection2.size())
   {
     // lambda to compare node pointer inside both lists
     return std::is_permutation(selection1.begin(), selection1.end(), selection2.begin());
   }
 
   return false;
 }
 
 void QmitkMultiLabelInspector::SetSelectedLabels(const LabelValueVectorType& selectedLabels)
 {
   if (EqualLabelSelections(this->GetSelectedLabels(), selectedLabels))
   {
     return;
   }
 
   this->UpdateSelectionModel(selectedLabels);
   m_LastValidSelectedLabels = selectedLabels;
 }
 
 void QmitkMultiLabelInspector::UpdateSelectionModel(const LabelValueVectorType& selectedLabels)
 {
   // create new selection by retrieving the corresponding indexes of the labels
   QItemSelection newCurrentSelection;
   for (const auto& labelID : selectedLabels)
   {
     QModelIndexList matched = m_Model->match(m_Model->index(0, 0), QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole, QVariant(labelID), 1, Qt::MatchRecursive);
     if (!matched.empty())
     {
       newCurrentSelection.select(matched.front(), matched.front());
     }
   }
 
   m_Controls->view->selectionModel()->select(newCurrentSelection, QItemSelectionModel::ClearAndSelect|QItemSelectionModel::Current);
 }
 
 void QmitkMultiLabelInspector::SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel)
 {
   this->SetSelectedLabels({ selectedLabel });
 }
 
 QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetSelectedLabelsFromSelectionModel() const
 {
   LabelValueVectorType result;
   QModelIndexList selectedIndexes = m_Controls->view->selectionModel()->selectedIndexes();
   for (const auto& index : std::as_const(selectedIndexes))
   {
     QVariant qvariantDataNode = m_Model->data(index, QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
     if (qvariantDataNode.canConvert<mitk::LabelSetImage::LabelValueType>())
     {
       result.push_back(qvariantDataNode.value<mitk::LabelSetImage::LabelValueType>());
     }
   }
   return result;
 }
 
 QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetSelectedLabels() const
 {
   return m_LastValidSelectedLabels;
 }
 
 mitk::Label* QmitkMultiLabelInspector::GetFirstSelectedLabelObject() const
 {
   if (m_LastValidSelectedLabels.empty() || m_Segmentation.IsNull())
     return nullptr;
 
   return m_Segmentation->GetLabel(m_LastValidSelectedLabels.front());
 }
 
 void QmitkMultiLabelInspector::OnChangeModelSelection(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
 {
   if (!m_ModelManipulationOngoing)
   {
     auto internalSelection = GetSelectedLabelsFromSelectionModel();
     if (internalSelection.empty())
     {
       //empty selections are not allowed by UI interactions, there should always be at least on label selected.
       //but selections are e.g. also cleared if the model is updated (e.g. due to addition of labels)
       UpdateSelectionModel(m_LastValidSelectedLabels);
     }
     else
     {
       m_LastValidSelectedLabels = internalSelection;
       emit CurrentSelectionChanged(GetSelectedLabels());
     }
   }
 }
 
 void QmitkMultiLabelInspector::WaitCursorOn() const
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void QmitkMultiLabelInspector::WaitCursorOff() const
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkMultiLabelInspector::RestoreOverrideCursor() const
 {
   QApplication::restoreOverrideCursor();
 }
 
 mitk::Label* QmitkMultiLabelInspector::GetCurrentLabel() const
 {
   auto currentIndex = this->m_Controls->view->currentIndex();
   auto labelVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelDataRole);
   mitk::Label::Pointer currentIndexLabel = nullptr;
 
   if (labelVariant.isValid())
   {
     auto uncastedLabel = labelVariant.value<void*>();
     currentIndexLabel = static_cast<mitk::Label*>(uncastedLabel);
   }
   return currentIndexLabel;
 }
 
 QmitkMultiLabelInspector::IndexLevelType QmitkMultiLabelInspector::GetCurrentLevelType() const
 {
   auto currentIndex = this->m_Controls->view->currentIndex();
   auto labelInstanceVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceDataRole);
   auto labelVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelDataRole);
 
   if (labelInstanceVariant.isValid() )
   {
     return IndexLevelType::LabelInstance;
   }
   else if (labelVariant.isValid())
   {
     return IndexLevelType::LabelClass;
   }
 
   return IndexLevelType::Group;
 }
 
 QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetCurrentlyAffactedLabelInstances() const
 {
   auto currentIndex = m_Controls->view->currentIndex();
   return m_Model->GetLabelsInSubTree(currentIndex);
 }
 
 QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetLabelInstancesOfSelectedFirstLabel() const
 {
   if (m_Segmentation.IsNull())
     return {};
 
   if (this->GetSelectedLabels().empty())
     return {};
 
   const auto index = m_Model->indexOfLabel(this->GetSelectedLabels().front());
   return m_Model->GetLabelInstancesOfSameLabelClass(index);
 }
 
 mitk::Label* QmitkMultiLabelInspector::AddNewLabelInstanceInternal(mitk::Label* templateLabel)
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of AddNewLabelInstance.";
 
   if (nullptr == templateLabel)
     mitkThrow() << "QmitkMultiLabelInspector is in an invalid state. AddNewLabelInstanceInternal was called with a non existing label as template";
 
   auto groupID = m_Segmentation->GetGroupIndexOfLabel(templateLabel->GetValue());
   m_ModelManipulationOngoing = true;
   auto newLabel = m_Segmentation->AddLabel(templateLabel, groupID, true);
   m_ModelManipulationOngoing = false;
   this->SetSelectedLabel(newLabel->GetValue());
 
   auto index = m_Model->indexOfLabel(newLabel->GetValue());
   if (index.isValid())
   {
     m_Controls->view->expand(index.parent());
   }
   else
   {
     mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the model after adding it to the segmentation. Label value: " << newLabel->GetValue();
   }
 
   emit ModelUpdated();
   return newLabel;
 }
 
 mitk::Label* QmitkMultiLabelInspector::AddNewLabelInstance()
 {
   auto currentLabel = this->GetFirstSelectedLabelObject();
   if (nullptr == currentLabel)
     return nullptr;
 
   auto result = this->AddNewLabelInstanceInternal(currentLabel);
 
   // this is needed as workaround for (T27307). It circumvents the fact that modifications
   // of data (here the segmentation) does not directly trigger the modification of the
   // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
   // listens to the datastorage for modification would not get notified.
   if (m_SegmentationNode.IsNotNull())
   {
     m_SegmentationNode->Modified();
   }
 
   return result;
 }
 
 mitk::Label* QmitkMultiLabelInspector::AddNewLabelInternal(const mitk::LabelSetImage::GroupIndexType& containingGroup)
 {
   auto newLabel = mitk::LabelSetImageHelper::CreateNewLabel(m_Segmentation);
 
   if (!m_DefaultLabelNaming)
     emit LabelRenameRequested(newLabel, false);
 
   m_ModelManipulationOngoing = true;
   m_Segmentation->AddLabel(newLabel, containingGroup, false);
   m_ModelManipulationOngoing = false;
 
   this->SetSelectedLabel(newLabel->GetValue());
 
   auto index = m_Model->indexOfLabel(newLabel->GetValue());
 
   if (!index.isValid())
     mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the "
                    "model after adding it to the segmentation. Label value: " << newLabel->GetValue();
 
   m_Controls->view->expand(index.parent());
 
   emit ModelUpdated();
 
   return newLabel;
 }
 
 mitk::Label* QmitkMultiLabelInspector::AddNewLabel()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of AddNewLabel.";
 
   if (m_Segmentation.IsNull())
   {
     return nullptr;
   }
 
   auto currentLabel = this->GetFirstSelectedLabelObject();
   mitk::LabelSetImage::GroupIndexType groupID = nullptr != currentLabel
     ? m_Segmentation->GetGroupIndexOfLabel(currentLabel->GetValue())
     : 0;
 
   auto result = AddNewLabelInternal(groupID);
 
   // this is needed as workaround for (T27307). It circumvents the fact that modifications
   // of data (here the segmentation) does not directly trigger the modification of the
   // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
   // listens to the datastorage for modification would not get notified.
   if (m_SegmentationNode.IsNotNull())
   {
     m_SegmentationNode->Modified();
   }
 
   return result;
 }
 
 void QmitkMultiLabelInspector::DeleteLabelInstance()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of DeleteLabelInstance.";
 
   if (m_Segmentation.IsNull())
     return;
 
   auto label = this->GetFirstSelectedLabelObject();
 
   if (nullptr == label)
     return;
 
   auto index = m_Model->indexOfLabel(label->GetValue());
   auto instanceName = index.data(Qt::DisplayRole);
 
   auto question = "Do you really want to delete label instance \"" + instanceName.toString() + "\"?";
   auto answer = QMessageBox::question(this, QString("Delete label instances"), question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answer == QMessageBox::Yes)
   {
     this->DeleteLabelInternal({ label->GetValue() });
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::DeleteLabel()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of DeleteLabel.";
 
   if (m_Segmentation.IsNull())
     return;
 
   const auto label = this->GetFirstSelectedLabelObject();
 
   if (nullptr == label)
     return;
 
   const auto relevantLabels = this->GetLabelInstancesOfSelectedFirstLabel();
 
   if (relevantLabels.empty())
     return;
 
   auto question = "Do you really want to delete label \"" + QString::fromStdString(label->GetName());
   question = relevantLabels.size()==1 ? question + "\"?" : question + "\" with all "+QString::number(relevantLabels.size()) +" instances?";
 
   auto answer = QMessageBox::question(this, QString("Delete label"), question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answer == QMessageBox::Yes)
   {
     this->DeleteLabelInternal(relevantLabels);
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::DeleteLabelInternal(const LabelValueVectorType& labelValues)
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of DeleteLabelInternal.";
 
   if (m_Segmentation.IsNull())
   {
     return;
   }
 
   QVariant nextLabelVariant;
 
   this->WaitCursorOn();
   m_ModelManipulationOngoing = true;
   for (auto labelValue : labelValues)
   {
     if (labelValue == labelValues.back())
     {
       auto currentIndex = m_Model->indexOfLabel(labelValue);
       auto nextIndex = m_Model->ClosestLabelInstanceIndex(currentIndex);
       nextLabelVariant = nextIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
     }
 
     m_Segmentation->RemoveLabel(labelValue);
   }
   m_ModelManipulationOngoing = false;
   this->WaitCursorOff();
 
   if (nextLabelVariant.isValid())
   {
     auto newLabelValue = nextLabelVariant.value<LabelValueType>();
     this->SetSelectedLabel(newLabelValue);
 
     auto index = m_Model->indexOfLabel(newLabelValue); //we have to get index again, because it could have changed due to remove operation.
     if (index.isValid())
     {
       m_Controls->view->expand(index.parent());
     }
     else
     {
       mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the model after adding it to the segmentation. Label value: " << newLabelValue;
     }
   }
   else
   {
     this->SetSelectedLabels({});
   }
 
   emit ModelUpdated();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 mitk::Label* QmitkMultiLabelInspector::AddNewGroup()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of AddNewLabel.";
 
   if (m_Segmentation.IsNull())
   {
     return nullptr;
   }
 
   mitk::LabelSetImage::GroupIndexType groupID = 0;
   mitk::Label* newLabel = nullptr;
   m_ModelManipulationOngoing = true;
   try
   {
     this->WaitCursorOn();
     groupID = m_Segmentation->AddLayer();
     m_Segmentation->SetActiveLayer(groupID);
     this->WaitCursorOff();
     newLabel =  this->AddNewLabelInternal(groupID);
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     m_ModelManipulationOngoing = false;
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Add group", "Could not add a new group. See error log for details.");
   }
   m_ModelManipulationOngoing = false;
 
   emit ModelUpdated();
 
   // this is needed as workaround for (T27307). It circumvents the fact that modifications
   // of data (here the segmentation) does not directly trigger the modification of the
   // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
   // listens to the datastorage for modification would not get notified.
   if (m_SegmentationNode.IsNotNull())
   {
     m_SegmentationNode->Modified();
   }
 
   return newLabel;
 }
 
 void QmitkMultiLabelInspector::RemoveGroupInternal(const mitk::LabelSetImage::GroupIndexType& groupID)
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
 
   if (m_Segmentation.IsNull())
     return;
 
   if (m_Segmentation->GetNumberOfLayers() < 2)
     return;
 
   auto currentIndex = m_Model->indexOfGroup(groupID);
   auto nextIndex = m_Model->ClosestLabelInstanceIndex(currentIndex);
   auto labelVariant = nextIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
 
   try
   {
     this->WaitCursorOn();
     m_ModelManipulationOngoing = true;
     m_Segmentation->RemoveGroup(groupID);
     m_ModelManipulationOngoing = false;
     this->WaitCursorOff();
   }
   catch (mitk::Exception& e)
   {
     m_ModelManipulationOngoing = false;
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Delete group", "Could not delete the currently active group. See error log for details.");
     return;
   }
 
   if (labelVariant.isValid())
   {
     auto newLabelValue = labelVariant.value<LabelValueType>();
     this->SetSelectedLabel(newLabelValue);
 
     auto index = m_Model->indexOfLabel(newLabelValue); //we have to get index again, because it could have changed due to remove operation.
     if (index.isValid())
     {
       m_Controls->view->expand(index.parent());
     }
     else
     {
       mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the model after adding it to the segmentation. Label value: " << newLabelValue;
     }
   }
   else
   {
     this->SetSelectedLabels({});
   }
 
   emit ModelUpdated();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMultiLabelInspector::RemoveGroup()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
 
   if (m_Segmentation.IsNull())
     return;
 
   if (m_Segmentation->GetNumberOfLayers() < 2)
   {
     QMessageBox::information(this, "Delete group", "Cannot delete last remaining group. A segmentation must contain at least a single group.");
     return;
   }
 
   const auto* selectedLabel = this->GetFirstSelectedLabelObject();
 
   if (selectedLabel == nullptr)
     return;
 
   const auto group = m_Segmentation->GetGroupIndexOfLabel(selectedLabel->GetValue());
 
   auto question = QStringLiteral("Do you really want to delete group %1 including all of its labels?").arg(group);
   auto answer = QMessageBox::question(this, QStringLiteral("Delete group %1").arg(group), question, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
   if (answer != QMessageBox::Yes)
     return;
 
   this->RemoveGroupInternal(group);
 }
 
 void QmitkMultiLabelInspector::OnDeleteGroup()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
 
   if (m_Segmentation.IsNull())
     return;
 
   auto currentIndex = this->m_Controls->view->currentIndex();
   auto groupIDVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::GroupIDRole);
 
   if (groupIDVariant.isValid())
   {
     auto groupID = groupIDVariant.value<mitk::LabelSetImage::GroupIndexType>();
 
     auto question = QStringLiteral("Do you really want to delete group %1 including all of its labels?").arg(groupID);
     auto answer = QMessageBox::question(this, QString("Delete group %1").arg(groupID), question, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
     if (answer != QMessageBox::Yes)
       return;
 
     this->RemoveGroupInternal(groupID);
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 };
 
 
 void QmitkMultiLabelInspector::OnContextMenuRequested(const QPoint& /*pos*/)
 {
   if (m_Segmentation.IsNull() || !this->isEnabled())
     return;
 
   const auto indexLevel = this->GetCurrentLevelType();
 
+  auto currentIndex = this->m_Controls->view->currentIndex();
+  //this ensures correct highlighting is the context menu is triggered while
+  //another context menu is already open.
+  if (currentIndex.isValid() && this->m_AboutToShowContextMenu) this->OnEntered(this->m_Controls->view->currentIndex());
+
+
+  QMenu* menu = new QMenu(this);
+
   if (IndexLevelType::Group == indexLevel)
   {
-    QMenu* menu = new QMenu(this);
-
     if (m_AllowLabelModification)
     {
       QAction* addInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add.svg")), "&Add label", this);
       QObject::connect(addInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnAddLabel);
       menu->addAction(addInstanceAction);
 
       if (m_Segmentation->GetNumberOfLayers() > 1)
       {
         QAction* removeAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_group_delete.svg")), "Delete group", this);
         QObject::connect(removeAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnDeleteGroup);
         menu->addAction(removeAction);
       }
     }
 
     if (m_AllowLockModification)
     {
       menu->addSeparator();
       QAction* lockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg")), "Lock group", this);
       QObject::connect(lockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnLockAffectedLabels);
       menu->addAction(lockAllAction);
 
       QAction* unlockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg")), "Unlock group", this);
       QObject::connect(unlockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnUnlockAffectedLabels);
       menu->addAction(unlockAllAction);
     }
 
     if (m_AllowVisibilityModification)
     {
       menu->addSeparator();
 
       QAction* viewAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Show group", this);
       QObject::connect(viewAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsVisible);
       menu->addAction(viewAllAction);
 
       QAction* hideAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg")), "Hide group", this);
       QObject::connect(hideAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsInvisible);
       menu->addAction(hideAllAction);
 
       menu->addSeparator();
 
       auto opacityAction = this->CreateOpacityAction();
       if (nullptr != opacityAction)
         menu->addAction(opacityAction);
     }
-    menu->popup(QCursor::pos());
   }
   else if (IndexLevelType::LabelClass == indexLevel)
   {
-    QMenu* menu = new QMenu(this);
-
     if (m_AllowLabelModification)
     {
       QAction* addInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add_instance.svg")), "Add label instance", this);
       QObject::connect(addInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnAddLabelInstance);
       menu->addAction(addInstanceAction);
 
       QAction* renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "&Rename label", this);
       QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
       menu->addAction(renameAction);
 
       QAction* removeAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete.svg")), "&Delete label", this);
       QObject::connect(removeAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnDeleteAffectedLabel);
       menu->addAction(removeAction);
     }
 
     if (m_AllowLockModification)
     {
       menu->addSeparator();
       QAction* lockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg")), "Lock label instances", this);
       QObject::connect(lockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnLockAffectedLabels);
       menu->addAction(lockAllAction);
 
       QAction* unlockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg")), "Unlock label instances", this);
       QObject::connect(unlockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnUnlockAffectedLabels);
       menu->addAction(unlockAllAction);
     }
 
     if (m_AllowVisibilityModification)
     {
       menu->addSeparator();
 
       QAction* viewAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Show label instances", this);
       QObject::connect(viewAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsVisible);
       menu->addAction(viewAllAction);
 
       QAction* hideAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg")), "Hide label instances", this);
       QObject::connect(hideAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsInvisible);
       menu->addAction(hideAllAction);
 
       menu->addSeparator();
 
       auto opacityAction = this->CreateOpacityAction();
       if (nullptr!=opacityAction)
         menu->addAction(opacityAction);
     }
-    menu->popup(QCursor::pos());
   }
   else
   {
     auto selectedLabelValues = this->GetSelectedLabels();
     if (selectedLabelValues.empty())
       return;
 
-    QMenu* menu = new QMenu(this);
-
     if (this->GetMultiSelectionMode() && selectedLabelValues.size() > 1)
     {
       if (m_AllowLabelModification)
       {
         QAction* mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge selection on current label", this);
         QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabels(bool)));
         menu->addAction(mergeAction);
 
         QAction* removeLabelsAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete_instance.svg")), "&Delete selected labels", this);
         QObject::connect(removeLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnDeleteLabels(bool)));
         menu->addAction(removeLabelsAction);
 
         QAction* clearLabelsAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "&Clear selected labels", this);
         QObject::connect(clearLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnClearLabels(bool)));
         menu->addAction(clearLabelsAction);
       }
 
       if (m_AllowVisibilityModification)
       {
         if (m_AllowLabelModification) menu->addSeparator();
 
         QAction* viewOnlyAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Hide everything but this", this);
         QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
         menu->addAction(viewOnlyAction);
 
         menu->addSeparator();
 
         auto opacityAction = this->CreateOpacityAction();
         if (nullptr != opacityAction)
           menu->addAction(opacityAction);
       }
     }
     else
     {
       if (m_AllowLabelModification)
       {
         QAction* addInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add_instance.svg")), "&Add label instance", this);
         QObject::connect(addInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnAddLabelInstance);
         menu->addAction(addInstanceAction);
 
         const auto selectedLabelIndex = m_Model->indexOfLabel(selectedLabelValues.front());
 
         if (m_Model->GetLabelInstancesOfSameLabelClass(selectedLabelIndex).size() > 1) // Only labels that actually appear as instance (having additional instances)
         {
           QAction* renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "&Rename label instance", this);
           QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
           menu->addAction(renameAction);
 
           QAction* removeInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete_instance.svg")), "&Delete label instance", this);
           QObject::connect(removeInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::DeleteLabelInstance);
           menu->addAction(removeInstanceAction);
         }
         else
         {
           QAction* renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "&Rename label", this);
           QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
           menu->addAction(renameAction);
         }
 
         QAction* removeLabelAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete.svg")), "Delete &label", this);
         QObject::connect(removeLabelAction, &QAction::triggered, this, &QmitkMultiLabelInspector::DeleteLabel);
         menu->addAction(removeLabelAction);
 
         QAction* clearAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "&Clear content", this);
         QObject::connect(clearAction, SIGNAL(triggered(bool)), this, SLOT(OnClearLabel(bool)));
         menu->addAction(clearAction);
       }
 
       if (m_AllowVisibilityModification)
       {
         if (m_AllowLabelModification) menu->addSeparator();
 
         QAction* viewOnlyAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Hide everything but this", this);
         QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
         menu->addAction(viewOnlyAction);
 
         menu->addSeparator();
 
         auto opacityAction = this->CreateOpacityAction();
         if (nullptr != opacityAction)
           menu->addAction(opacityAction);
       }
     }
-    menu->popup(QCursor::pos());
   }
+
+  QObject::connect(menu, &QMenu::aboutToHide, this, &QmitkMultiLabelInspector::OnMouseLeave);
+  m_AboutToShowContextMenu = true;
+  menu->popup(QCursor::pos());
 }
 
 QWidgetAction* QmitkMultiLabelInspector::CreateOpacityAction()
 {
   auto selectedLabelValues = this->GetSelectedLabels();
 
   auto relevantLabelValues = !this->GetMultiSelectionMode() || selectedLabelValues.size() <= 1
     ? this->GetCurrentlyAffactedLabelInstances()
     : selectedLabelValues;
 
   std::vector<mitk::Label*> relevantLabels;
 
   if (!relevantLabelValues.empty())
   {
     for (auto value : relevantLabelValues)
     {
       auto label = this->m_Segmentation->GetLabel(value);
       if (nullptr == label)
         mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
       relevantLabels.emplace_back(label);
     }
 
     auto* opacitySlider = new QSlider;
     opacitySlider->setMinimum(0);
     opacitySlider->setMaximum(100);
     opacitySlider->setOrientation(Qt::Horizontal);
 
     auto opacity = relevantLabels.front()->GetOpacity();
     opacitySlider->setValue(static_cast<int>(opacity * 100));
     auto segmentation = m_Segmentation;
+    auto node = m_SegmentationNode;
 
-    QObject::connect(opacitySlider, &QSlider::valueChanged, this, [segmentation, relevantLabels](const int value)
-    {
-      auto opacity = static_cast<float>(value) / 100.0f;
-      for (auto label : relevantLabels)
+    auto onChangeLambda = [segmentation, relevantLabels](const int value)
       {
-        label->SetOpacity(opacity);
-        segmentation->UpdateLookupTable(label->GetValue());
-      }
-      mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-    }
-    );
+        auto opacity = static_cast<float>(value) / 100.0f;
+        for (auto label : relevantLabels)
+        {
+          label->SetOpacity(opacity);
+          segmentation->UpdateLookupTable(label->GetValue());
+        }
+        segmentation->GetLookupTable()->Modified();
+        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+      };
+    QObject::connect(opacitySlider, &QSlider::valueChanged, this, onChangeLambda);
+
+    auto onPressedLambda = [node]()
+      {
+        DeactivateLabelHighlights(node);
+      };
+    QObject::connect(opacitySlider, &QSlider::sliderPressed, this, onPressedLambda);
+
+    auto onReleasedLambda = [node, relevantLabelValues]()
+      {
+        ActivateLabelHighlights(node, relevantLabelValues);
+      };
+    QObject::connect(opacitySlider, &QSlider::sliderReleased, this, onReleasedLambda);
 
     QLabel* opacityLabel = new QLabel("Opacity: ");
     QVBoxLayout* opacityWidgetLayout = new QVBoxLayout;
     opacityWidgetLayout->setContentsMargins(4, 4, 4, 4);
     opacityWidgetLayout->addWidget(opacityLabel);
     opacityWidgetLayout->addWidget(opacitySlider);
     QWidget* opacityWidget = new QWidget;
     opacityWidget->setLayout(opacityWidgetLayout);
     QWidgetAction* opacityAction = new QWidgetAction(this);
     opacityAction->setDefaultWidget(opacityWidget);
 
     return opacityAction;
   }
 
   return nullptr;
 }
 
 void QmitkMultiLabelInspector::OnClearLabels(bool /*value*/)
 {
   QString question = "Do you really want to clear the selected labels?";
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Clear selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     m_Segmentation->EraseLabels(this->GetSelectedLabels());
     this->WaitCursorOff();
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::OnDeleteAffectedLabel()
 {
   if (!m_AllowLabelModification)
     mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
 
   if (m_Segmentation.IsNull())
   {
     return;
   }
 
   auto affectedLabels = GetCurrentlyAffactedLabelInstances();
   auto currentLabel = m_Segmentation->GetLabel(affectedLabels.front());
   QString question = "Do you really want to delete all instances of label \"" + QString::fromStdString(currentLabel->GetName()) + "\"?";
 
   QMessageBox::StandardButton answerButton =
     QMessageBox::question(this, "Delete label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->DeleteLabelInternal(affectedLabels);
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::OnDeleteLabels(bool /*value*/)
 {
   QString question = "Do you really want to remove the selected labels?";
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Remove selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     m_Segmentation->RemoveLabels(this->GetSelectedLabels());
     this->WaitCursorOff();
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::OnMergeLabels(bool /*value*/)
 {
   auto currentLabel = GetCurrentLabel();
   QString question = "Do you really want to merge selected labels into \"" + QString::fromStdString(currentLabel->GetName())+"\"?";
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Merge selected label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     m_Segmentation->MergeLabels(currentLabel->GetValue(), this->GetSelectedLabels());
     this->WaitCursorOff();
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::OnAddLabel()
 {
   auto currentIndex = this->m_Controls->view->currentIndex();
   auto groupIDVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::GroupIDRole);
 
   if (groupIDVariant.isValid())
   {
     auto groupID = groupIDVariant.value<mitk::LabelSetImage::GroupIndexType>();
     this->AddNewLabelInternal(groupID);
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::OnAddLabelInstance()
 {
   auto currentLabel = this->GetCurrentLabel();
   if (nullptr == currentLabel)
     return;
 
   this->AddNewLabelInstanceInternal(currentLabel);
 
   // this is needed as workaround for (T27307). It circumvents the fact that modifications
   // of data (here the segmentation) does not directly trigger the modification of the
   // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
   // listens to the datastorage for modification would not get notified.
   if (m_SegmentationNode.IsNotNull())
   {
     m_SegmentationNode->Modified();
   }
 }
 
 void QmitkMultiLabelInspector::OnClearLabel(bool /*value*/)
 {
   auto currentLabel = GetFirstSelectedLabelObject();
   QString question = "Do you really want to clear the contents of label \"" + QString::fromStdString(currentLabel->GetName())+"\"?";
 
   QMessageBox::StandardButton answerButton =
     QMessageBox::question(this, "Clear label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     m_Segmentation->EraseLabel(currentLabel->GetValue());
     this->WaitCursorOff();
 
     // this is needed as workaround for (T27307). It circumvents the fact that modifications
     // of data (here the segmentation) does not directly trigger the modification of the
     // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
     // listens to the datastorage for modification would not get notified.
     if (m_SegmentationNode.IsNotNull())
     {
       m_SegmentationNode->Modified();
     }
   }
 }
 
 void QmitkMultiLabelInspector::OnRenameLabel(bool /*value*/)
 {
   auto relevantLabelValues = this->GetCurrentlyAffactedLabelInstances();
   auto currentLabel = this->GetCurrentLabel();
 
   emit LabelRenameRequested(currentLabel, true);
 
   for (auto value : relevantLabelValues)
   {
     if (value != currentLabel->GetValue())
     {
       auto label = this->m_Segmentation->GetLabel(value);
       if (nullptr == label)
         mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
 
       label->SetName(currentLabel->GetName());
       label->SetColor(currentLabel->GetColor());
       m_Segmentation->UpdateLookupTable(label->GetValue());
       mitk::DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(label);
 
       // this is needed as workaround for (T27307). It circumvents the fact that modifications
       // of data (here the segmentation) does not directly trigger the modification of the
       // owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
       // listens to the datastorage for modification would not get notified.
       if (m_SegmentationNode.IsNotNull())
       {
         m_SegmentationNode->Modified();
       }
     }
   }
   emit ModelUpdated();
 }
 
 
 void QmitkMultiLabelInspector::SetLockOfAffectedLabels(bool locked) const
 {
   auto relevantLabelValues = this->GetCurrentlyAffactedLabelInstances();
 
   if (!relevantLabelValues.empty())
   {
     for (auto value : relevantLabelValues)
     {
       auto label = this->m_Segmentation->GetLabel(value);
       if (nullptr == label)
         mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
       label->SetLocked(locked);
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkMultiLabelInspector::OnUnlockAffectedLabels()
 {
   this->SetLockOfAffectedLabels(false);
 }
 
 void QmitkMultiLabelInspector::OnLockAffectedLabels()
 {
   this->SetLockOfAffectedLabels(true);
 }
 
 void QmitkMultiLabelInspector::SetVisibilityOfAffectedLabels(bool visible) const
 {
   auto relevantLabelValues = this->GetCurrentlyAffactedLabelInstances();
 
   if (!relevantLabelValues.empty())
   {
     for (auto value : relevantLabelValues)
     {
       auto label = this->m_Segmentation->GetLabel(value);
       if (nullptr == label)
         mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
       label->SetVisible(visible);
       m_Segmentation->UpdateLookupTable(label->GetValue());
     }
+    m_Segmentation->GetLookupTable()->Modified();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkMultiLabelInspector::OnSetAffectedLabelsVisible()
 {
   this->SetVisibilityOfAffectedLabels(true);
 }
 
 void QmitkMultiLabelInspector::OnSetAffectedLabelsInvisible()
 {
   this->SetVisibilityOfAffectedLabels(false);
 }
 
 void QmitkMultiLabelInspector::OnSetOnlyActiveLabelVisible(bool /*value*/)
 {
   auto selectedLabelValues = this->GetSelectedLabels();
 
   if (selectedLabelValues.empty()) return;
 
   m_Segmentation->SetAllLabelsVisible(false);
 
   for (auto selectedValue : selectedLabelValues)
   {
     auto currentLabel = m_Segmentation->GetLabel(selectedValue);
     currentLabel->SetVisible(true);
     m_Segmentation->UpdateLookupTable(selectedValue);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->PrepareGoToLabel(selectedLabelValues.front());
 }
 
 void QmitkMultiLabelInspector::OnItemDoubleClicked(const QModelIndex& index)
 {
   if (!index.isValid()) return;
   if (index.column() > 0) return;
 
   auto labelVariant = index.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
 
   if (!labelVariant.isValid()) return;
 
   const auto labelID = labelVariant.value<mitk::Label::PixelType>();
 
   if (QApplication::queryKeyboardModifiers().testFlag(Qt::AltModifier))
   {
     this->OnRenameLabel(false);
     return;
   }
 
   this->PrepareGoToLabel(labelID);
 }
 
 void QmitkMultiLabelInspector::PrepareGoToLabel(mitk::Label::PixelType labelID) const
 {
   this->WaitCursorOn();
   m_Segmentation->UpdateCenterOfMass(labelID);
   const auto currentLabel = m_Segmentation->GetLabel(labelID);
   const mitk::Point3D& pos = currentLabel->GetCenterOfMassCoordinates();
   this->WaitCursorOff();
 
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit GoToLabel(currentLabel->GetValue(), pos);
   }
 }
 
+void QmitkMultiLabelInspector::OnEntered(const QModelIndex& index)
+{
+  if (m_SegmentationNode.IsNotNull())
+  {
+    auto labelVariant = index.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
+
+    auto highlightedValues = m_Model->GetLabelsInSubTree(index);
+
+    ActivateLabelHighlights(m_SegmentationNode, highlightedValues);
+  }
+  m_AboutToShowContextMenu = false;
+}
+
+void QmitkMultiLabelInspector::OnMouseLeave()
+{
+  if (m_SegmentationNode.IsNotNull() && !m_AboutToShowContextMenu)
+  {
+    DeactivateLabelHighlights(m_SegmentationNode);
+  }
+  else
+  {
+    m_AboutToShowContextMenu = false;
+  }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h
index cadca6ed32..9d660a34d4 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h
@@ -1,329 +1,333 @@
 /*============================================================================
 
 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 QmitkMultiLabelInspector_h
 #define QmitkMultiLabelInspector_h
 
 #include <MitkSegmentationUIExports.h>
 #include <mitkWeakPointer.h>
 #include <mitkLabelSetImage.h>
 #include <mitkDataNode.h>
 
 #include <QWidget>
 #include <QItemSelectionModel>
 
 class QmitkMultiLabelTreeModel;
 class QStyledItemDelegate;
 class QWidgetAction;
 
 namespace Ui
 {
   class QmitkMultiLabelInspector;
 }
 
 /*
 * @brief This is an inspector that offers a tree view on the labels and groups of a MultiLabelSegmentation instance.
 * It also allows some manipulation operations an the labels/groups accordin to the UI/selection state.
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkMultiLabelInspector : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkMultiLabelInspector(QWidget* parent = nullptr);
   ~QmitkMultiLabelInspector();
 
   bool GetMultiSelectionMode() const;
 
   bool GetAllowVisibilityModification() const;
   bool GetAllowLockModification() const;
   bool GetAllowLabelModification() const;
   /** Indicates if the inspector is currently modifiying the model/segmentation.
    Thus as long as the manipulation is ongoing, one should assume the model to be in an invalid state.*/
   bool GetModelManipulationOngoing() const;
 
   using LabelValueType = mitk::LabelSetImage::LabelValueType;
   using LabelValueVectorType = mitk::LabelSetImage::LabelValueVectorType;
 
   /**
   * @brief Retrieve the currently selected labels (equals the last CurrentSelectionChanged values).
   */
   LabelValueVectorType GetSelectedLabels() const;
 
   /** @brief Returns the label that currently has the focus in the tree view.
    *
    * The focus is indicated by QTreeView::currentIndex, thus the mouse is over it and it has a dashed border line.
    *
    * The current label must not equal the selected label(s). If the mouse is not hovering above a label
    * (label class or instance item), the method will return nullptr.
    */
   mitk::Label* GetCurrentLabel() const;
 
   enum class IndexLevelType
   {
     Group,
     LabelClass,
     LabelInstance
   };
 
   /** @brief Returns the level of the index that currently has the focus in the tree view.
    *
    * The focus is indicated by QTreeView::currentIndex, thus the mouse is over it and it has a dashed border line.
    */
   IndexLevelType GetCurrentLevelType() const;
 
   /** @brief Returns all label values that are currently affected.
    *
    * Affected means that these labels (including the one returned by GetCurrentLabel) are in the subtree of the tree
    * view element that currently has the focus (indicated by QTreeView::currentIndex, thus the mouse is over it and
    * it has a dashed border line.
    */
   LabelValueVectorType GetCurrentlyAffactedLabelInstances() const;
 
   /** @brief Returns the values of all label instances that are of the same label (class) like the first selected label instance.
    *
    * If no label is selected an empty vector will be returned.
    */
   LabelValueVectorType GetLabelInstancesOfSelectedFirstLabel() const;
 
 Q_SIGNALS:
   /**
   * @brief A signal that will be emitted if the selected labels change.
   *
   * @param labels A list of label values that are now selected.
   */
   void CurrentSelectionChanged(LabelValueVectorType labels) const;
 
   /**
   * @brief A signal that will be emitted if the user has requested to "go to" a certain label.
   *
   * Going to a label would be e.g. to focus the renderwindows on the centroid of the label.
   * @param label The label that should be focused.
   * @param point in World coordinate that should be focused.
   */
   void GoToLabel(LabelValueType label, const mitk::Point3D& point) const;
 
   /** @brief Signal that is emitted, if a label should be (re)named and default
   * label naming is deactivated.
   *
   * The instance for which a new name is requested is passed with the signal.
   * @param label Pointer to the instance that needs a (new) name.
   * @param rename Indicates if it is a renaming or naming of a new label.
   */
   void LabelRenameRequested(mitk::Label* label, bool rename) const;
 
   /** @brief Signal that is emitted, if the model was updated (e.g. by a delete or add operation).*/
   void ModelUpdated() const;
 
   /** @brief Signal is emitted, if the segmentation is changed that is observed by the inspector.*/
   void SegmentationChanged() const;
 
 public Q_SLOTS:
 
   /**
   * @brief Transform a list of label values into the new selection of the inspector.
   * @param selectedLabels A list of selected label values.
   * @remark Using this method to select labels will not trigger the CurrentSelectionChanged signal. Observers
   * should regard that to avoid signal loops.
   */
   void SetSelectedLabels(const LabelValueVectorType& selectedLabels);
   /**
   * @brief The passed label will be used as new selection in the widget
   * @param selectedLabel Value of the selected label.
   * @remark Using this method to select labels will not trigger the CurrentSelectionChanged signal. Observers
   * should regard that to avoid signal loops.
   */
   void SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel);
 
   /** @brief Sets the segmentation that will be used and monitored by the widget.
   * @param segmentation      A pointer to the segmentation to set.
   * @remark You cannot set the segmentation directly if a segmentation node is
   * also set. Reset the node (nullptr) if you want to change to direct segmentation
   * setting.
   * @pre Segmentation node is nullptr.
   */
   void SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation);
   mitk::LabelSetImage* GetMultiLabelSegmentation() const;
 
   /**
   * @brief Sets the segmentation node that will be used /monitored by the widget.
   *
   * @param node A pointer to the segmentation node.
   * @remark If not set some features (e.g. highlighting in render windows) of the inspectors
   * are not active.
   * @remark Currently it is also needed to circumvent the fact that
   * modification of data does not directly trigger modification of the
   * node (see T27307).
   */
   void SetMultiLabelNode(mitk::DataNode* node);
   mitk::DataNode* GetMultiLabelNode() const;
 
   void SetMultiSelectionMode(bool multiMode);
 
   void SetAllowVisibilityModification(bool visiblityMod);
   void SetAllowLockModification(bool lockMod);
   void SetAllowLabelModification(bool labelMod);
 
   void SetDefaultLabelNaming(bool defaultLabelNaming);
 
   /** @brief Adds an instance of the same label/class like the first label instance
   * indicated by GetSelectedLabels() to the segmentation.
   *
   * This new label instance is returned by the function. If the inspector has no selected label,
   * no new instance will be generated and nullptr will be returned.
   *
   * @remark The new label instance is a clone of the selected label instance.
   * Therefore all properties but the LabelValue will be the same.
   *
   * @pre AllowLabeModification must be set to true.
   */
   mitk::Label* AddNewLabelInstance();
 
   /** @brief Adds a new label to the segmentation.
   * Depending on the settings the name of
   * the label will be either default generated or the rename delegate will be used. The label
   * will be added to the same group as the first currently selected label.
   *
   * @pre AllowLabeModification must be set to true.*/
   mitk::Label* AddNewLabel();
 
   /** @brief Removes the first currently selected label instance of the segmentation.
   * If no label is selected
   * nothing will happen.
   *
   * @pre AllowLabeModification must be set to true.*/
   void DeleteLabelInstance();
 
   /** @brief Delete the first currently selected label and all its instances of the segmentation.
   * If no label is selected
   * nothing will happen.
   *
   * @pre AllowLabeModification must be set to true.*/
   void DeleteLabel();
 
   /** @brief Adds a new group with a new label to segmentation.
   *
   * @pre AllowLabeModification must be set to true.*/
   mitk::Label* AddNewGroup();
 
   /** @brief Removes the group of the first currently selected label of the segmentation.
   *If no label is selected nothing will happen.
   *
   * @pre AllowLabeModification must be set to true.*/
   void RemoveGroup();
 
   void SetVisibilityOfAffectedLabels(bool visible) const;
   void SetLockOfAffectedLabels(bool visible) const;
 
 protected:
   void Initialize();
   void OnModelReset();
   void OnDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight,
     const QList<int>& roles = QList<int>());
 
   QmitkMultiLabelTreeModel* m_Model;
   mitk::LabelSetImage::Pointer m_Segmentation;
 
   LabelValueVectorType m_LastValidSelectedLabels;
   QStyledItemDelegate* m_LockItemDelegate;
   QStyledItemDelegate* m_ColorItemDelegate;
   QStyledItemDelegate* m_VisibilityItemDelegate;
 
   Ui::QmitkMultiLabelInspector* m_Controls;
 
   LabelValueVectorType GetSelectedLabelsFromSelectionModel() const;
   void UpdateSelectionModel(const LabelValueVectorType& selectedLabels);
 
   /** @brief Helper that returns the label object (if multiple labels are selected the first).
   */
   mitk::Label* GetFirstSelectedLabelObject() const;
 
   mitk::Label* AddNewLabelInternal(const mitk::LabelSetImage::GroupIndexType& containingGroup);
 
   /**@brief Adds an instance of the same label/class like the passed label value
   */
   mitk::Label* AddNewLabelInstanceInternal(mitk::Label* templateLabel);
 
   void RemoveGroupInternal(const mitk::LabelSetImage::GroupIndexType& groupID);
   void DeleteLabelInternal(const LabelValueVectorType& labelValues);
 
 private Q_SLOTS:
   /** @brief Transform a labels selection into a data node list and emit the 'CurrentSelectionChanged'-signal.
   *
   * The function adds the selected nodes from the original selection that could not be modified, if
   * m_SelectOnlyVisibleNodes is false.
   * This slot is internally connected to the 'selectionChanged'-signal of the selection model of the private member item view.
   *
   * @param selected	The newly selected items.
   * @param deselected	The newly deselected items.
   */
   void OnChangeModelSelection(const QItemSelection& selected, const QItemSelection& deselected);
 
   void OnContextMenuRequested(const QPoint&);
 
   void OnAddLabel();
   void OnAddLabelInstance();
   void OnDeleteGroup();
   void OnDeleteAffectedLabel();
   void OnDeleteLabels(bool);
   void OnClearLabels(bool);
   void OnMergeLabels(bool);
 
   void OnRenameLabel(bool);
   void OnClearLabel(bool);
 
   void OnUnlockAffectedLabels();
   void OnLockAffectedLabels();
 
   void OnSetAffectedLabelsVisible();
   void OnSetAffectedLabelsInvisible();
   void OnSetOnlyActiveLabelVisible(bool);
 
   void OnItemDoubleClicked(const QModelIndex& index);
 
   void WaitCursorOn() const;
   void WaitCursorOff() const;
   void RestoreOverrideCursor() const;
 
   void PrepareGoToLabel(LabelValueType labelID) const;
 
+  void OnEntered(const QModelIndex& index);
+  void OnMouseLeave();
+
   QWidgetAction* CreateOpacityAction();
 
 private:
   bool m_ShowVisibility = true;
   bool m_ShowLock = true;
   bool m_ShowOther = false;
 
   /** @brief Indicates if the context menu allows changes in visiblity.
   *
   * Visiblity includes also color
   */
   bool m_AllowVisibilityModification = true;
 
   /** @brief Indicates if the context menu allows changes in lock state.
   */
   bool m_AllowLockModification = true;
 
   /** @brief Indicates if the context menu allows label modifications (adding, removing, renaming ...)
   */
   bool m_AllowLabelModification = false;
 
   bool m_DefaultLabelNaming = true;
 
   bool m_ModelManipulationOngoing = false;
 
+  bool m_AboutToShowContextMenu = false;
   mitk::DataNode::Pointer m_SegmentationNode;
   unsigned long m_SegmentationNodeDataMTime;
   mitk::ITKEventObserverGuard m_SegmentationObserver;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
index 1380a9b500..9608c7f2dd 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
@@ -1,1051 +1,1052 @@
 /*============================================================================
 
 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 "QmitkMultiLabelTreeModel.h"
 
 #include <mitkMultiLabelEvents.h>
 #include <mitkRenderingManager.h>
 
 #include <QmitkStyleManager.h>
 
 
 class QmitkMultiLabelSegTreeItem
 {
 public:
   enum class ItemType
   {
     Group,
     Label,
     Instance
   };
 
   QmitkMultiLabelSegTreeItem()
   {
   };
 
   explicit QmitkMultiLabelSegTreeItem(ItemType type, QmitkMultiLabelSegTreeItem* parentItem,
     mitk::Label* label = nullptr, std::string className = ""): m_parentItem(parentItem), m_ItemType(type), m_Label(label), m_ClassName(className)
   {
   };
 
   ~QmitkMultiLabelSegTreeItem()
   {
     for (auto item : m_childItems)
     {
       delete item;
     }
   };
 
   void AppendChild(QmitkMultiLabelSegTreeItem* child)
   {
       m_childItems.push_back(child);
   };
 
   void RemoveChild(std::size_t row)
   {
     if (row < m_childItems.size())
     {
       delete m_childItems[row];
       m_childItems.erase(m_childItems.begin() + row);
     }
   };
 
   int Row() const
   {
     if (m_parentItem)
     {
       auto finding = std::find(m_parentItem->m_childItems.begin(), m_parentItem->m_childItems.end(), this);
       if (finding != m_parentItem->m_childItems.end())
       {
         return std::distance(m_parentItem->m_childItems.begin(), finding);
       }
     }
 
     return 0;
   };
 
   QmitkMultiLabelSegTreeItem* ParentItem()
   {
     return m_parentItem;
   };
 
   const QmitkMultiLabelSegTreeItem* ParentItem() const
   {
     return m_parentItem;
   };
 
   const QmitkMultiLabelSegTreeItem* NextSibblingItem() const
   {
     if (m_parentItem)
     {
       const std::vector<QmitkMultiLabelSegTreeItem*>::size_type row = this->Row();
       if (row + 1 < m_parentItem->m_childItems.size())
         return m_parentItem->m_childItems[row+1];
     }
 
     return nullptr;
   };
 
   const QmitkMultiLabelSegTreeItem* PrevSibblingItem() const
   {
     if (m_parentItem)
     {
       const std::vector<QmitkMultiLabelSegTreeItem*>::size_type row = this->Row();
       if (row > 0)
         return m_parentItem->m_childItems[row-1];
     }
 
     return nullptr;
   };
 
   const QmitkMultiLabelSegTreeItem* RootItem() const
   {
     auto item = this;
     while (item->m_parentItem != nullptr)
     {
       item = item->m_parentItem;
     }
     return item;
   };
 
   std::size_t GetGroupID() const
   {
     auto root = this->RootItem();
     auto item = this;
     if (root == this) return 0;
 
     while (root != item->m_parentItem)
     {
       item = item->m_parentItem;
     }
 
     auto iter = std::find(root->m_childItems.begin(), root->m_childItems.end(), item);
 
     if (root->m_childItems.end() == iter) mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Root does not have an currentItem as child that has root as parent.";
 
     return std::distance(root->m_childItems.begin(), iter);
   }
 
   bool HandleAsInstance() const
   {
     return (ItemType::Instance == m_ItemType) || ((ItemType::Label == m_ItemType) && (m_childItems.size() == 1));
   }
 
   mitk::Label* GetLabel() const
   {
     if (ItemType::Instance == m_ItemType)
     {
       return m_Label;
     }
     if (ItemType::Label == m_ItemType)
     {
       if (m_childItems.empty()) mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Internal label currentItem has no instance currentItem.";
       return m_childItems[0]->GetLabel();
     }
 
     return nullptr;
   };
 
   mitk::LabelSetImage::LabelValueType GetLabelValue() const
   {
     auto label = this->GetLabel();
 
     if (nullptr == label)
     {
       mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Called GetLabelValue on an group currentItem.";
     }
 
     return label->GetValue();
   };
 
   /** returns a vector containing all label values of referenced by this item or its child items.*/
   std::vector< mitk::LabelSetImage::LabelValueType> GetLabelsInSubTree() const
   {
     if (this->m_ItemType == ItemType::Instance)
     {
       return { this->GetLabelValue() };
     }
 
     std::vector< mitk::LabelSetImage::LabelValueType> result;
     for (const auto child : this->m_childItems)
     {
       auto childresult = child->GetLabelsInSubTree();
       result.reserve(result.size() + childresult.size());
       result.insert(result.end(), childresult.begin(), childresult.end());
     }
 
     return result;
   }
 
   std::vector<QmitkMultiLabelSegTreeItem*> m_childItems;
   QmitkMultiLabelSegTreeItem* m_parentItem = nullptr;
   ItemType m_ItemType = ItemType::Group;
   mitk::Label::Pointer m_Label;
   std::string m_ClassName;
 };
 
 QModelIndex GetIndexByItem(const QmitkMultiLabelSegTreeItem* start, const QmitkMultiLabelTreeModel* model)
 {
   QModelIndex parentIndex = QModelIndex();
   if (nullptr != start->m_parentItem)
   {
     parentIndex = GetIndexByItem(start->m_parentItem, model);
   }
   else
   {
     return parentIndex;
   }
 
   return model->index(start->Row(), 0, parentIndex);
 }
 
 QmitkMultiLabelSegTreeItem* GetGroupItem(QmitkMultiLabelTreeModel::GroupIndexType groupIndex, QmitkMultiLabelSegTreeItem* root)
 {
   if (nullptr != root && groupIndex < root->m_childItems.size())
   {
     return root->m_childItems[groupIndex];
   }
 
   return nullptr;
 }
 
 QmitkMultiLabelSegTreeItem* GetInstanceItem(QmitkMultiLabelTreeModel::LabelValueType labelValue, QmitkMultiLabelSegTreeItem* root)
 {
   QmitkMultiLabelSegTreeItem* result = nullptr;
 
   for (auto item : root->m_childItems)
   {
     result = GetInstanceItem(labelValue, item);
     if (nullptr != result) return result;
   }
 
   if (root->m_ItemType == QmitkMultiLabelSegTreeItem::ItemType::Instance && root->GetLabelValue() == labelValue)
   {
     return root;
   }
 
   return nullptr;
 }
 
 const QmitkMultiLabelSegTreeItem* GetFirstInstanceLikeItem(const QmitkMultiLabelSegTreeItem* startItem)
 {
   const QmitkMultiLabelSegTreeItem* result = nullptr;
 
   if (nullptr != startItem)
   {
     if (startItem->HandleAsInstance())
     {
       result = startItem;
     }
     else if (!startItem->m_childItems.empty())
     {
       result = GetFirstInstanceLikeItem(startItem->m_childItems.front());
     }
   }
 
   return result;
 }
 
 QmitkMultiLabelSegTreeItem* GetLabelItemInGroup(const std::string& labelName, QmitkMultiLabelSegTreeItem* group)
 {
   if (nullptr != group)
   {
     auto predicate = [labelName](const QmitkMultiLabelSegTreeItem* item) { return labelName == item->m_ClassName; };
     auto finding = std::find_if(group->m_childItems.begin(), group->m_childItems.end(), predicate);
     if (group->m_childItems.end() != finding)
     {
       return *finding;
     }
   }
 
   return nullptr;
 }
 
 QmitkMultiLabelTreeModel::QmitkMultiLabelTreeModel(QObject *parent) : QAbstractItemModel(parent)
 {
   m_RootItem = std::make_unique<QmitkMultiLabelSegTreeItem>();
 }
 
 QmitkMultiLabelTreeModel ::~QmitkMultiLabelTreeModel()
 {
   this->SetSegmentation(nullptr);
 };
 
 int QmitkMultiLabelTreeModel::columnCount(const QModelIndex& /*parent*/) const
 {
   return 4;
 }
 
 int QmitkMultiLabelTreeModel::rowCount(const QModelIndex &parent) const
 {
   if (parent.column() > 0)
     return 0;
 
   if (m_Segmentation.IsNull())
     return 0;
 
   QmitkMultiLabelSegTreeItem* parentItem = m_RootItem.get();
 
   if (parent.isValid())
     parentItem = static_cast<QmitkMultiLabelSegTreeItem *>(parent.internalPointer());
 
   if (parentItem->HandleAsInstance())
   {
     return 0;
   }
 
   return parentItem->m_childItems.size();
 }
 
 QVariant QmitkMultiLabelTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
 
   if (!item)
     return QVariant();
 
   if (role == Qt::DisplayRole||role == Qt::EditRole)
   {
     if (TableColumns::NAME_COL == index.column())
     {
       switch (item->m_ItemType)
       {
         case QmitkMultiLabelSegTreeItem::ItemType::Group:
           return QVariant(QString("Group %1").arg(item->GetGroupID()));
 
         case QmitkMultiLabelSegTreeItem::ItemType::Label:
         {
           auto label = item->GetLabel();
 
           if (nullptr == label)
             mitkThrow() << "Invalid internal state. QmitkMultiLabelTreeModel currentItem is refering to a label that does not exist.";
 
           QString name = QString::fromStdString(label->GetName());
 
           if (!item->HandleAsInstance())
             name = name + QString(" (%1 instances)").arg(item->m_childItems.size());
 
           return QVariant(name);
         }
 
         case QmitkMultiLabelSegTreeItem::ItemType::Instance:
         {
           auto label = item->GetLabel();
 
           if (nullptr == label)
             mitkThrow() << "Invalid internal state. QmitkMultiLabelTreeModel currentItem is refering to a label that does not exist.";
 
           return QVariant(QString::fromStdString(label->GetName()) + QString(" [%1]").arg(item->GetLabelValue()));
         }
       }
     }
     else
     {
       if (item->HandleAsInstance())
       {
         auto label = item->GetLabel();
 
         if (TableColumns::LOCKED_COL == index.column())
         {
           return QVariant(label->GetLocked());
         }
         else if (TableColumns::COLOR_COL == index.column())
         {
           return QVariant(QColor(label->GetColor().GetRed() * 255, label->GetColor().GetGreen() * 255, label->GetColor().GetBlue() * 255));
         }
         else if (TableColumns::VISIBLE_COL == index.column())
         {
           return QVariant(label->GetVisible());
         }
       }
     }
   }
   else if (role == Qt::ToolTipRole)
   {
     if (item->m_ItemType == QmitkMultiLabelSegTreeItem::ItemType::Group)
     {
       return QVariant(QString("Group %1").arg(item->GetGroupID()));
     }
     else
     {
       auto label = item->GetLabel();
 
       if (nullptr == label)
         mitkThrow() << "Invalid internal state. QmitkMultiLabelTreeModel currentItem is referring to a label that does not exist.";
 
       QString name = QString::fromStdString("<b>"+label->GetName()+"</b>");
 
       if (!item->HandleAsInstance())
       {
         name = QString("Label class: %1\nContaining %2 instances").arg(name).arg(item->m_childItems.size());
       }
       else
       {
         name = QString::fromStdString(label->GetName()) + QString("\nLabel instance ID: %1\nPixel value: %2").arg(item->GetLabelValue()).arg(item->GetLabelValue());
       }
       return QVariant(name);
     }
   }
   else if (role == ItemModelRole::LabelDataRole)
   {
     auto label = item->GetLabel();
     if (nullptr!=label)  return QVariant::fromValue<void*>(label);
   }
   else if (role == ItemModelRole::LabelValueRole)
   {
     auto label = item->GetLabel();
     if (nullptr != label)  return QVariant(label->GetValue());
   }
   else if (role == ItemModelRole::LabelInstanceDataRole)
   {
     if (item->HandleAsInstance())
     {
       auto label = item->GetLabel();
       return QVariant::fromValue<void*>(label);
     }
   }
   else if (role == ItemModelRole::LabelInstanceValueRole)
   {
     if (item->HandleAsInstance())
     {
       auto label = item->GetLabel();
       return QVariant(label->GetValue());
     }
   }
   else if (role == ItemModelRole::GroupIDRole)
   {
     QVariant v;
     v.setValue(item->GetGroupID());
     return v;
   }
 
   return QVariant();
 }
 
 mitk::Color QtToMitk(const QColor& color)
 {
   mitk::Color mitkColor;
 
   mitkColor.SetRed(color.red() / 255.0f);
   mitkColor.SetGreen(color.green() / 255.0f);
   mitkColor.SetBlue(color.blue() / 255.0f);
 
   return mitkColor;
 }
 
 bool QmitkMultiLabelTreeModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
   if (!index.isValid())
     return false;
 
   auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
 
   if (!item)
     return false;
 
   if (role == Qt::EditRole)
   {
     if (TableColumns::NAME_COL != index.column())
     {
       if (item->HandleAsInstance())
       {
         auto label = item->GetLabel();
 
         if (TableColumns::LOCKED_COL == index.column())
         {
           label->SetLocked(value.toBool());
         }
         else if (TableColumns::COLOR_COL == index.column())
         {
           label->SetColor(QtToMitk(value.value<QColor>()));
         }
         else if (TableColumns::VISIBLE_COL == index.column())
         {
           label->SetVisible(value.toBool());
         }
         m_Segmentation->UpdateLookupTable(label->GetValue());
+        m_Segmentation->GetLookupTable()->Modified();
         m_Segmentation->Modified();
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       }
       else
       {
 
       }
       return true;
     }
   }
   return false;
 }
 
 QModelIndex QmitkMultiLabelTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!hasIndex(row, column, parent))
     return QModelIndex();
 
   auto parentItem = m_RootItem.get();
 
   if (parent.isValid())
     parentItem = static_cast<QmitkMultiLabelSegTreeItem *>(parent.internalPointer());
 
   QmitkMultiLabelSegTreeItem *childItem = parentItem->m_childItems[row];
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 }
 
 QModelIndex QmitkMultiLabelTreeModel::indexOfLabel(mitk::Label::PixelType labelValue) const
 {
   if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return QModelIndex();
   auto relevantItem = GetInstanceItem(labelValue, this->m_RootItem.get());
 
   if (nullptr == relevantItem)
     return QModelIndex();
 
   auto labelItem = relevantItem->ParentItem();
 
   if (labelItem->m_childItems.size() == 1)
   { //was the only instance of the label, therefor return the label item instat.
     relevantItem = labelItem;
   }
 
   return GetIndexByItem(relevantItem, this);
 }
 
 QModelIndex QmitkMultiLabelTreeModel::indexOfGroup(mitk::LabelSetImage::GroupIndexType groupIndex) const
 {
   auto relevantItem = GetGroupItem(groupIndex, this->m_RootItem.get());
 
   if (nullptr == relevantItem) QModelIndex();
 
   return GetIndexByItem(relevantItem, this);
 }
 
 QModelIndex QmitkMultiLabelTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkMultiLabelSegTreeItem *childItem = static_cast<QmitkMultiLabelSegTreeItem *>(child.internalPointer());
   QmitkMultiLabelSegTreeItem *parentItem = childItem->ParentItem();
 
   if (parentItem == m_RootItem.get())
     return QModelIndex();
 
   return createIndex(parentItem->Row(), 0, parentItem);
 }
 
 QModelIndex QmitkMultiLabelTreeModel::ClosestLabelInstanceIndex(const QModelIndex& currentIndex) const
 {
   if (!currentIndex.isValid()) return QModelIndex();
 
   auto currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
   if (!currentItem) return QModelIndex();
 
   if (currentItem->RootItem() != this->m_RootItem.get()) mitkThrow() << "Invalid call. Passed currentIndex does not seem to be a valid index of this model. It is either outdated or from another model.";
 
   const QmitkMultiLabelSegTreeItem* resultItem = nullptr;
   auto searchItem = currentItem;
   const auto rootItem = currentItem->RootItem();
 
   while (searchItem != rootItem)
   {
     const auto* sibling = searchItem;
 
     while (sibling != nullptr)
     {
       sibling = sibling->NextSibblingItem();
       resultItem = GetFirstInstanceLikeItem(sibling);
 
       if (nullptr != resultItem)
         break;
     }
 
     if (nullptr != resultItem)
       break;
 
     // No next closest label instance on this level -> check for closest before
     sibling = searchItem;
 
     while (sibling != nullptr)
     {
       sibling = sibling->PrevSibblingItem();
       resultItem = GetFirstInstanceLikeItem(sibling);
 
       if (nullptr != resultItem)
         break;
     }
 
     if (nullptr != resultItem)
       break;
 
     // No closest label instance before current on this level -> moeve one level up
     searchItem = searchItem->ParentItem();
   }
 
   if (nullptr == resultItem)
     return QModelIndex();
 
   return GetIndexByItem(resultItem, this);
 }
 
 QModelIndex QmitkMultiLabelTreeModel::FirstLabelInstanceIndex(const QModelIndex& currentIndex) const
 {
   const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
 
   if (!currentIndex.isValid())
   {
     currentItem = this->m_RootItem.get();
   }
   else
   {
     currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
   }
 
   if (!currentItem) return QModelIndex();
 
   if (currentItem->RootItem() != this->m_RootItem.get()) mitkThrow() << "Invalid call. Passed currentIndex does not seem to be a valid index of this model. It is either outdated or from another model.";
 
   const QmitkMultiLabelSegTreeItem* resultItem = nullptr;
   resultItem = GetFirstInstanceLikeItem(currentItem);
 
   if (nullptr == resultItem)
     return QModelIndex();
 
   return GetIndexByItem(resultItem, this);
 }
 
 ///** Returns the index to the next node in the tree that behaves like an instance (label node with only one instance
 //or instance node). If current index is at the end, an invalid index is returned.*/
 //QModelIndex QmitkMultiLabelTreeModel::PrevLabelInstanceIndex(const QModelIndex& currentIndex) const;
 
 std::vector <QmitkMultiLabelTreeModel::LabelValueType> QmitkMultiLabelTreeModel::GetLabelsInSubTree(const QModelIndex& currentIndex) const
 {
   const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
 
   if (!currentIndex.isValid())
   {
     currentItem = this->m_RootItem.get();
   }
   else
   {
     currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
   }
 
   if (!currentItem) return {};
 
   return currentItem->GetLabelsInSubTree();
 }
 
 std::vector <QmitkMultiLabelTreeModel::LabelValueType> QmitkMultiLabelTreeModel::GetLabelInstancesOfSameLabelClass(const QModelIndex& currentIndex) const
 {
   const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
 
   if (currentIndex.isValid())
   {
     currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
   }
 
   if (!currentItem)
     return {};
 
   if (QmitkMultiLabelSegTreeItem::ItemType::Group == currentItem->m_ItemType)
     return {};
 
   if (QmitkMultiLabelSegTreeItem::ItemType::Instance == currentItem->m_ItemType)
     currentItem = currentItem->ParentItem();
 
   return currentItem->GetLabelsInSubTree();
 }
 
 Qt::ItemFlags QmitkMultiLabelTreeModel::flags(const QModelIndex &index) const
 {
   if (!index.isValid())
     return Qt::NoItemFlags;
 
   if (!index.isValid())
     return Qt::NoItemFlags;
 
   auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
 
   if (!item)
     return Qt::NoItemFlags;
 
   if (TableColumns::NAME_COL != index.column())
   {
     if (item->HandleAsInstance() &&
       ((TableColumns::VISIBLE_COL == index.column() && m_AllowVisibilityModification) ||
        (TableColumns::COLOR_COL == index.column() && m_AllowVisibilityModification) || //m_AllowVisibilityModification controls visibility and color
        (TableColumns::LOCKED_COL == index.column() && m_AllowLockModification)))
     {
       return Qt::ItemIsEnabled | Qt::ItemIsEditable;
     }
     else
     {
       return Qt::ItemIsEnabled;
     }
   }
   else
   {
     if (item->HandleAsInstance())
     {
       return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
     }
     else
     {
       return Qt::ItemIsEnabled;
     }
   }
 
   return Qt::NoItemFlags;
 }
 
 QVariant QmitkMultiLabelTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
   {
     if (TableColumns::NAME_COL == section)
     {
       return "Name";
     }
     else if (TableColumns::LOCKED_COL == section)
     {
       return "Locked";
     }
     else if (TableColumns::COLOR_COL == section)
     {
       return "Color";
     }
     else if (TableColumns::VISIBLE_COL == section)
     {
       return "Visibility";
     }
   }
   return QVariant();
 }
 
 const mitk::LabelSetImage* QmitkMultiLabelTreeModel::GetSegmentation() const
 {
   return m_Segmentation;
 }
 
 
 void QmitkMultiLabelTreeModel::SetSegmentation(mitk::LabelSetImage* segmentation)
 {
   if (m_Segmentation != segmentation)
   {
     this->m_Segmentation = segmentation;
     this->AddObserver();
 
     this->UpdateInternalTree();
   }
 }
 
 
 /**Helper function that adds a labek into the item tree. Passes back the new created instance iten*/
 QmitkMultiLabelSegTreeItem* AddLabelToGroupTree(mitk::Label* label, QmitkMultiLabelSegTreeItem* groupItem, bool& newLabelItemCreated)
 {
   if (nullptr == groupItem) return nullptr;
   if (nullptr == label) return nullptr;
 
   newLabelItemCreated = false;
 
   std::set<std::string> labelNames;
   for (auto labelItem : groupItem->m_childItems)
   {
     labelNames.emplace(labelItem->GetLabel()->GetName());
   }
 
   QmitkMultiLabelSegTreeItem* labelItem = nullptr;
   auto finding = labelNames.find(label->GetName());
   if (finding != labelNames.end())
   { //other label with same name exists
     labelItem = groupItem->m_childItems[std::distance(labelNames.begin(), finding)];
   }
   else
   {
     newLabelItemCreated = true;
     labelItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Label, groupItem, nullptr, label->GetName());
 
     auto predicate = [label](const std::string& name) { return name > label->GetName(); };
     auto insertFinding = std::find_if(labelNames.begin(), labelNames.end(), predicate);
 
     groupItem->m_childItems.insert(groupItem->m_childItems.begin() + std::distance(labelNames.begin(), insertFinding), labelItem);
   }
 
   auto instanceItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Instance, labelItem, label);
 
   auto predicate = [label](const QmitkMultiLabelSegTreeItem* item) { return item->GetLabelValue() > label->GetValue(); };
   auto insertFinding = std::find_if(labelItem->m_childItems.begin(), labelItem->m_childItems.end(), predicate);
   labelItem->m_childItems.insert(labelItem->m_childItems.begin() + std::distance(labelItem->m_childItems.begin(), insertFinding), instanceItem);
 
   return instanceItem;
 }
 
 void QmitkMultiLabelTreeModel::GenerateInternalGroupTree(unsigned int groupID, QmitkMultiLabelSegTreeItem* groupItem)
 {
   auto labels = m_Segmentation->GetLabelsByValue(m_Segmentation->GetLabelValuesByGroup(groupID));
 
   for (auto& label : labels)
   {
     if (label->GetValue()== mitk::LabelSetImage::UNLABELED_VALUE) continue;
 
     bool newItemCreated = false;
     AddLabelToGroupTree(label, groupItem, newItemCreated);
   }
 }
 
 QmitkMultiLabelSegTreeItem* QmitkMultiLabelTreeModel::GenerateInternalTree()
 {
   auto rootItem = new QmitkMultiLabelSegTreeItem();
 
   if (m_Segmentation.IsNotNull())
   {
     for (unsigned int groupID = 0; groupID < m_Segmentation->GetNumberOfLayers(); ++groupID)
     {
       auto groupItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Group, rootItem);
       rootItem->AppendChild(groupItem);
 
       GenerateInternalGroupTree(groupID, groupItem);
     }
   }
 
   return rootItem;
 }
 
 void QmitkMultiLabelTreeModel::UpdateInternalTree()
 {
   emit beginResetModel();
   auto newTree = this->GenerateInternalTree();
   this->m_RootItem.reset(newTree);
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkMultiLabelTreeModel::ITKEventHandler(const itk::EventObject& e)
 {
   if (mitk::LabelAddedEvent().CheckEvent(&e))
   {
     auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&e);
     this->OnLabelAdded(labelEvent->GetLabelValue());
   }
   else if (mitk::LabelModifiedEvent().CheckEvent(&e))
   {
     auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&e);
     this->OnLabelModified(labelEvent->GetLabelValue());
   }
   else if (mitk::LabelRemovedEvent().CheckEvent(&e))
   {
     auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&e);
     this->OnLabelRemoved(labelEvent->GetLabelValue());
   }
   else if (mitk::GroupAddedEvent().CheckEvent(&e))
   {
     auto labelEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&e);
     this->OnGroupAdded(labelEvent->GetGroupID());
   }
   else if (mitk::GroupModifiedEvent().CheckEvent(&e))
   {
     auto labelEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&e);
     this->OnGroupModified(labelEvent->GetGroupID());
   }
   else if (mitk::GroupRemovedEvent().CheckEvent(&e))
   {
     auto labelEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&e);
     this->OnGroupRemoved(labelEvent->GetGroupID());
   }
 }
 
 void QmitkMultiLabelTreeModel::AddObserver()
 {
   m_LabelAddedObserver.Reset();
   m_LabelModifiedObserver.Reset();
   m_LabelRemovedObserver.Reset();
   m_GroupAddedObserver.Reset();
   m_GroupModifiedObserver.Reset();
   m_GroupRemovedObserver.Reset();
 
   if (this->m_Segmentation.IsNotNull())
   {
     auto& model = *this;
 
     m_LabelAddedObserver.Reset(m_Segmentation, mitk::LabelAddedEvent(), [&model](const itk::EventObject& event){model.ITKEventHandler(event);});
     m_LabelModifiedObserver.Reset(m_Segmentation, mitk::LabelModifiedEvent(), [&model](const itk::EventObject& event) {model.ITKEventHandler(event); });
     m_LabelRemovedObserver.Reset(m_Segmentation, mitk::LabelRemovedEvent(), [&model](const itk::EventObject& event) {model.ITKEventHandler(event); });
     m_GroupAddedObserver.Reset(m_Segmentation, mitk::GroupAddedEvent(), [&model](const itk::EventObject& event) {
       model.ITKEventHandler(event); });
     m_GroupModifiedObserver.Reset(m_Segmentation, mitk::GroupModifiedEvent(), [&model](const itk::EventObject& event) {model.ITKEventHandler(event); });
     m_GroupRemovedObserver.Reset(m_Segmentation, mitk::GroupRemovedEvent(), [&model](const itk::EventObject& event) {model.ITKEventHandler(event); });
   }
 }
 
 void QmitkMultiLabelTreeModel::OnLabelAdded(LabelValueType labelValue)
 {
   GroupIndexType groupIndex = m_Segmentation->GetGroupIndexOfLabel(labelValue);
   auto label = m_Segmentation->GetLabel(labelValue);
   if (nullptr == label) mitkThrow() << "Invalid internal state. Segmentation signaled the addition of an label that does not exist in the segmentation. Invalid label value:" << labelValue;
   if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return;
 
   auto groupItem = GetGroupItem(groupIndex, this->m_RootItem.get());
 
   bool newLabelCreated = false;
   auto instanceItem = AddLabelToGroupTree(label, groupItem, newLabelCreated);
 
   if (newLabelCreated)
   {
     if (groupItem->m_childItems.size() == 1)
     { //first label added
       auto groupIndex = GetIndexByItem(groupItem, this);
       emit dataChanged(groupIndex, groupIndex);
       this->beginInsertRows(groupIndex, instanceItem->ParentItem()->Row(), instanceItem->ParentItem()->Row());
       this->endInsertRows();
     }
     else
     { //whole new label level added to group item
       auto groupIndex = GetIndexByItem(groupItem, this);
       this->beginInsertRows(groupIndex, instanceItem->ParentItem()->Row(), instanceItem->ParentItem()->Row());
       this->endInsertRows();
     }
   }
   else
   {
     if (instanceItem->ParentItem()->m_childItems.size() < 3)
     { //second instance item was added, so label item will now able to collapse
       // -> the whole label node has to be updated.
       auto labelIndex = GetIndexByItem(instanceItem->ParentItem(), this);
       emit dataChanged(labelIndex, labelIndex);
       this->beginInsertRows(labelIndex, 0, instanceItem->ParentItem()->m_childItems.size()-1);
       this->endInsertRows();
     }
     else
     {
       // instance item was added to existing label item with multiple instances
       //-> just notify the row insertion
       auto labelIndex = GetIndexByItem(instanceItem->ParentItem(), this);
       this->beginInsertRows(labelIndex, instanceItem->Row(), instanceItem->Row());
       this->endInsertRows();
     }
   }
 }
 
 void QmitkMultiLabelTreeModel::OnLabelModified(LabelValueType labelValue)
 {
   if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return;
 
   auto instanceItem = GetInstanceItem(labelValue, this->m_RootItem.get());
 
   if (nullptr == instanceItem)
   {
     mitkThrow() << "Internal invalid state. QmitkMultiLabelTreeModel received a LabelModified signal for a label that is not represented in the model. Invalid label: " << labelValue;
   }
 
   auto labelItem = instanceItem->ParentItem();
 
   if (labelItem->m_ClassName == instanceItem->GetLabel()->GetName())
   { //only the state of the label changed, but not its position in the model tree.
     auto index = labelItem->HandleAsInstance() ? GetIndexByItem(labelItem, this) : GetIndexByItem(instanceItem, this);
     auto rightIndex = index.sibling(index.row(), this->columnCount() - 1);
     emit dataChanged(index, rightIndex);
   }
   else
   { //the name of the label changed and thus its place in the model tree, delete the current item and add a new one
     this->OnLabelRemoved(labelValue);
     this->OnLabelAdded(labelValue);
   }
 }
 
 void QmitkMultiLabelTreeModel::OnLabelRemoved(LabelValueType labelValue)
 {
   if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return;
   auto instanceItem = GetInstanceItem(labelValue, this->m_RootItem.get());
 
   if (nullptr == instanceItem)
     mitkThrow() << "Internal invalid state. QmitkMultiLabelTreeModel received a LabelRemoved signal for a label that is not represented in the model. Invalid label: " << labelValue;
 
   auto labelItem = instanceItem->ParentItem();
 
   if (labelItem->m_childItems.size() > 2)
   {
     auto labelIndex = GetIndexByItem(labelItem, this);
     this->beginRemoveRows(labelIndex, instanceItem->Row(), instanceItem->Row());
     labelItem->RemoveChild(instanceItem->Row());
     this->endRemoveRows();
   }
   else if (labelItem->m_childItems.size() == 2)
   { //After removal only one label is left -> the whole label node is about to be changed (no instances are shown any more).
     auto labelIndex = GetIndexByItem(labelItem, this);
     this->beginRemoveRows(labelIndex, instanceItem->Row(), instanceItem->Row());
     labelItem->RemoveChild(instanceItem->Row());
     this->endRemoveRows();
     emit dataChanged(labelIndex, labelIndex);
   }
   else
   { //was the only instance of the label, therefor also remove the label node from the tree.
     auto groupItem = labelItem->ParentItem();
     auto groupIndex = GetIndexByItem(groupItem, this);
     this->beginRemoveRows(groupIndex, labelItem->Row(), labelItem->Row());
     groupItem->RemoveChild(labelItem->Row());
     this->endRemoveRows();
   }
 }
 
 void QmitkMultiLabelTreeModel::OnGroupAdded(GroupIndexType groupIndex)
 {
   if (m_ShowGroups)
   {
     this->beginInsertRows(QModelIndex(), groupIndex, groupIndex);
     auto rootItem = m_RootItem.get();
     auto groupItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Group, rootItem);
     rootItem->AppendChild(groupItem);
     this->GenerateInternalGroupTree(groupIndex, groupItem);
     this->endInsertRows();
   }
 }
 
 void QmitkMultiLabelTreeModel::OnGroupModified(GroupIndexType /*groupIndex*/)
 {
   //currently not needed
 }
 
 void QmitkMultiLabelTreeModel::OnGroupRemoved(GroupIndexType groupIndex)
 {
   if (m_ShowGroups)
   {
     this->beginRemoveRows(QModelIndex(), groupIndex, groupIndex);
     auto root = m_RootItem.get();
     root->RemoveChild(groupIndex);
     this->endRemoveRows();
   }
 }
 
 void QmitkMultiLabelTreeModel::SetAllowVisibilityModification(bool vmod)
 {
   m_AllowVisibilityModification = vmod;
 }
 
 bool QmitkMultiLabelTreeModel::GetAllowVisibilityModification() const
 {
   return m_AllowVisibilityModification;
 }
 
 void QmitkMultiLabelTreeModel::SetAllowLockModification(bool lmod)
 {
   m_AllowLockModification = lmod;
 }
 
 bool QmitkMultiLabelTreeModel::GetAllowLockModification() const
 {
   return m_AllowLockModification;
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.cpp
index cb51f1c1a5..608d084b78 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.cpp
@@ -1,32 +1,51 @@
 /*============================================================================
 
 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 <QmitkMultiLabelTreeView.h>
 
 #include <QmitkMultiLabelTreeModel.h>
-#include <QHelpEvent>
-#include <QToolTip>
+#include <QMouseEvent>
 
 QmitkMultiLabelTreeView::QmitkMultiLabelTreeView(QWidget* parent) : QTreeView(parent)
 {
 }
 
 QItemSelectionModel::SelectionFlags QmitkMultiLabelTreeView::selectionCommand(const QModelIndex& index, const QEvent* event) const
 {
   auto value = index.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
   if (index.column()!=0 || !value.isValid())
   {
     return QItemSelectionModel::NoUpdate;
   }
 
   return   QAbstractItemView::selectionCommand(index, event);
 }
+
+void QmitkMultiLabelTreeView::leaveEvent(QEvent* event)
+{
+  QTreeView::leaveEvent(event);
+  emit MouseLeave();
+}
+
+void QmitkMultiLabelTreeView::mouseMoveEvent(QMouseEvent* event)
+{
+  QModelIndex index = this->indexAt(event->pos());
+  if (!index.isValid())
+  {
+    if (viewport()->rect().contains(event->pos()))
+    {
+      emit MouseLeave();
+    }
+  }
+
+  QTreeView::mouseMoveEvent(event);
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.h b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.h
index ec64a35fa2..7aa5995881 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeView.h
@@ -1,34 +1,40 @@
 /*============================================================================
 
 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 QmitkMultiLabelTreeView_h
 #define QmitkMultiLabelTreeView_h
 
 #include <MitkSegmentationUIExports.h>
 
 #include <QTreeView>
 
 /*
 * @brief This is an inspector that offers a simple list view on a data storage.
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkMultiLabelTreeView : public QTreeView
 {
   Q_OBJECT
 
 public:
   QmitkMultiLabelTreeView(QWidget* parent = nullptr);
 
+Q_SIGNALS:
+  void MouseLeave() const;
+
 protected:
   QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex& index, const QEvent* event = nullptr) const override;
+
+  void leaveEvent(QEvent* event) override;
+  void mouseMoveEvent(QMouseEvent* event) override;
 };
 
 #endif