diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.cpp
index 70a8da970b..38f4484430 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.cpp
@@ -1,273 +1,274 @@
 /*============================================================================
 
 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 "QmitkImageStatisticsDataGenerator.h"
 
 #include "mitkImageStatisticsContainer.h"
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 #include "mitkNodePredicateFunction.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateDataProperty.h"
 #include "mitkProperties.h"
 #include "mitkImageStatisticsContainerManager.h"
 
 #include "QmitkImageStatisticsCalculationRunnable.h"
 
 void QmitkImageStatisticsDataGenerator::SetIgnoreZeroValueVoxel(bool _arg)
 {
   if (m_IgnoreZeroValueVoxel != _arg)
   {
     m_IgnoreZeroValueVoxel = _arg;
 
     if (m_AutoUpdate)
     {
       this->EnsureRecheckingAndGeneration();
     }
   }
 }
 
 bool QmitkImageStatisticsDataGenerator::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeroValueVoxel;
 }
 
 void QmitkImageStatisticsDataGenerator::SetHistogramNBins(unsigned int nbins)
 {
   if (m_HistogramNBins != nbins)
   {
     m_HistogramNBins = nbins;
 
     if (m_AutoUpdate)
     {
       this->EnsureRecheckingAndGeneration();
     }
   }
 }
 
 unsigned int QmitkImageStatisticsDataGenerator::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 bool QmitkImageStatisticsDataGenerator::ChangedNodeIsRelevant(const mitk::DataNode* changedNode) const
 {
   auto result = QmitkImageAndRoiDataGeneratorBase::ChangedNodeIsRelevant(changedNode);
 
   if (!result)
   {
     if (changedNode->GetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str()) == nullptr)
     {
       auto stats = dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData());
       result = stats != nullptr;
     }
   }
   return result;
 }
 
 bool QmitkImageStatisticsDataGenerator::IsValidResultAvailable(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const
 {
   auto resultNode = this->GetLatestResult(imageNode, roiNode, true, true);
   return resultNode.IsNotNull();
 }
 
 mitk::DataNode::Pointer QmitkImageStatisticsDataGenerator::GetLatestResult(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode, bool onlyIfUpToDate, bool noWIP) const
 {
   auto storage = m_Storage.Lock();
 
   if (imageNode == nullptr || !imageNode->GetData())
   {
     mitkThrow() << "Image is nullptr";
   }
 
   const auto image = imageNode->GetData();
   const mitk::BaseData* mask = nullptr;
   if (roiNode)
   {
     mask = roiNode->GetData();
   }
     
   std::lock_guard<std::mutex> mutexguard(m_DataMutex);
   return mitk::ImageStatisticsContainerManager::GetImageStatisticsNode(storage, image, mask, m_IgnoreZeroValueVoxel, m_HistogramNBins, onlyIfUpToDate, noWIP);
 }
 
 void QmitkImageStatisticsDataGenerator::IndicateFutureResults(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const
 {
   if (imageNode == nullptr || !imageNode->GetData())
   {
     mitkThrow() << "Image node is nullptr";
   }
 
   auto image = dynamic_cast<const mitk::Image*>(imageNode->GetData());
   if (!image)
   {
     mitkThrow() << "Image node date is nullptr or no image.";
   }
 
   const mitk::BaseData* mask = nullptr;
   if (roiNode != nullptr)
   {
     mask = roiNode->GetData();
   }
 
   auto resultDataNode = this->GetLatestResult(imageNode, roiNode, true, false);
   if (resultDataNode.IsNull())
   {
     auto dummyStats = mitk::ImageStatisticsContainer::New();
+    dummyStats->SetTimeGeometry(image->GetTimeGeometry()->Clone());
 
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     imageRule->Connect(dummyStats, image);
 
     if (nullptr != mask)
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       maskRule->Connect(dummyStats, mask);
     }
 
     dummyStats->SetProperty(mitk::STATS_HISTOGRAM_BIN_PROPERTY_NAME.c_str(), mitk::UIntProperty::New(m_HistogramNBins));
     dummyStats->SetProperty(mitk::STATS_IGNORE_ZERO_VOXEL_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(m_IgnoreZeroValueVoxel));
 
     auto dummyNode = CreateWIPDataNode(dummyStats, "WIP_"+GenerateStatisticsNodeName(image, mask));
 
     auto storage = m_Storage.Lock();
     if (storage != nullptr)
     {
       std::lock_guard<std::mutex> mutexguard(m_DataMutex);
       storage->Add(dummyNode);
     }
   }
 }
 
 std::pair<QmitkDataGenerationJobBase*, mitk::DataNode::Pointer> QmitkImageStatisticsDataGenerator::GetNextMissingGenerationJob(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const
 {
   auto resultDataNode = this->GetLatestResult(imageNode, roiNode, true, false);
 
   std::string status;
   if (resultDataNode.IsNull() || (resultDataNode->GetStringProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str(), status) && status == mitk::STATS_GENERATION_STATUS_VALUE_PENDING))
   {
     if (imageNode == nullptr || !imageNode->GetData())
     {
       mitkThrow() << "Image node is nullptr";
     }
 
     auto image = dynamic_cast<const mitk::Image*>(imageNode->GetData());
     if (image == nullptr)
     {
       mitkThrow() << "Image node date is nullptr or no image.";
     }
 
     const mitk::Image* mask = nullptr;
     const mitk::PlanarFigure* planar = nullptr;
     if (roiNode != nullptr)
     {
       mask = dynamic_cast<const mitk::Image*>(roiNode->GetData());
       planar = dynamic_cast<const mitk::PlanarFigure*>(roiNode->GetData());
     }
 
     auto newJob = new QmitkImageStatisticsCalculationRunnable;
 
     newJob->Initialize(image, mask, planar);
     newJob->SetIgnoreZeroValueVoxel(m_IgnoreZeroValueVoxel);
     newJob->SetHistogramNBins(m_HistogramNBins);
 
     return std::pair<QmitkDataGenerationJobBase*, mitk::DataNode::Pointer>(newJob, resultDataNode.GetPointer());
   }
   else if (resultDataNode->GetStringProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str(), status) && status == mitk::STATS_GENERATION_STATUS_VALUE_WORK_IN_PROGRESS)
   {
     return std::pair<QmitkDataGenerationJobBase*, mitk::DataNode::Pointer>(nullptr, resultDataNode.GetPointer());
   }
   return std::pair<QmitkDataGenerationJobBase*, mitk::DataNode::Pointer>(nullptr, nullptr);
 }
 
 void QmitkImageStatisticsDataGenerator::RemoveObsoleteDataNodes(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const
 {
   if (imageNode == nullptr || !imageNode->GetData())
   {
     mitkThrow() << "Image is nullptr";
   }
 
   const auto image = imageNode->GetData();
   const mitk::BaseData* mask = nullptr;
   if (roiNode != nullptr)
   {
     mask = roiNode->GetData();
   }
 
   auto lastResult = this->GetLatestResult(imageNode, roiNode, false, false);
 
   auto rulePredicate = mitk::ImageStatisticsContainerManager::GetStatisticsPredicateForSources(image, mask);
   auto notLatestPredicate = mitk::NodePredicateFunction::New([lastResult](const mitk::DataNode* node) { return node != lastResult; });
   auto binPredicate = mitk::NodePredicateDataProperty::New(mitk::STATS_HISTOGRAM_BIN_PROPERTY_NAME.c_str(), mitk::UIntProperty::New(m_HistogramNBins));
   auto zeroPredicate = mitk::NodePredicateDataProperty::New(mitk::STATS_IGNORE_ZERO_VOXEL_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(m_IgnoreZeroValueVoxel));
 
   mitk::NodePredicateBase::ConstPointer predicate = mitk::NodePredicateAnd::New(rulePredicate, notLatestPredicate).GetPointer();
   predicate = mitk::NodePredicateAnd::New(predicate, binPredicate, zeroPredicate).GetPointer();
 
   auto storage = m_Storage.Lock();
   if (storage != nullptr)
   {
     std::lock_guard<std::mutex> mutexguard(m_DataMutex);
 
     auto oldStatisticContainerNodes = storage->GetSubset(predicate);
     storage->Remove(oldStatisticContainerNodes);
   }
 }
 
 mitk::DataNode::Pointer QmitkImageStatisticsDataGenerator::PrepareResultForStorage(const std::string& /*label*/, mitk::BaseData* result, const QmitkDataGenerationJobBase* job) const
 {
   auto statsJob = dynamic_cast<const QmitkImageStatisticsCalculationRunnable*>(job);
 
   if (statsJob != nullptr)
   {
     auto resultNode = mitk::DataNode::New();
     resultNode->SetProperty("helper object", mitk::BoolProperty::New(true));
     resultNode->SetVisibility(false);
     resultNode->SetData(result);
     
     const mitk::BaseData* roi = statsJob->GetMaskImage();
     if (roi == nullptr)
     {
       roi = statsJob->GetPlanarFigure();
     }
     resultNode->SetName(this->GenerateStatisticsNodeName(statsJob->GetStatisticsImage(), roi));
 
     return resultNode;
   }
 
   return nullptr;
 }
 
 std::string QmitkImageStatisticsDataGenerator::GenerateStatisticsNodeName(const mitk::Image* image, const mitk::BaseData* roi) const
 {
   std::stringstream statisticsNodeName;
   statisticsNodeName << "statistics_bins-" << m_HistogramNBins <<"_";
 
   if (m_IgnoreZeroValueVoxel)
   {
     statisticsNodeName << "noZeros_";
   }
 
   if (image == nullptr)
   {
     mitkThrow() << "Image is nullptr";
   }
 
   statisticsNodeName << image->GetUID();
 
   if (roi != nullptr)
   {
     statisticsNodeName << "_" + roi->GetUID();
   }
 
   return statisticsNodeName.str();
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
index 3ee475c4e8..87c477439b 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
@@ -1,132 +1,132 @@
 /*============================================================================
 
 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 "QmitkImageStatisticsTreeItem.h"
 
 QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(
   ImageStatisticsObject statisticsData,
   StatisticNameVector statisticNames,
   QVariant label, bool isWIP,
   QmitkImageStatisticsTreeItem *parent)
   : m_statistics(statisticsData) , m_statisticNames(statisticNames), m_label(label), m_parentItem(parent), m_IsWIP(isWIP)
 {
 }
 
- QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(StatisticNameVector statisticNames,
+ QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(const StatisticNameVector& statisticNames,
                                                            QVariant label,
                                                            bool isWIP,
                                                            QmitkImageStatisticsTreeItem *parentItem)
   : QmitkImageStatisticsTreeItem(ImageStatisticsObject(), statisticNames, label, isWIP, parentItem )
 {
 }
 
  QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem() : QmitkImageStatisticsTreeItem(StatisticNameVector(), QVariant(), false, nullptr ) {}
 
 QmitkImageStatisticsTreeItem::~QmitkImageStatisticsTreeItem()
 {
   qDeleteAll(m_childItems);
 }
 
 void QmitkImageStatisticsTreeItem::appendChild(QmitkImageStatisticsTreeItem *item)
 {
   m_childItems.append(item);
 }
 
 QmitkImageStatisticsTreeItem *QmitkImageStatisticsTreeItem::child(int row)
 {
   return m_childItems.value(row);
 }
 
 int QmitkImageStatisticsTreeItem::childCount() const
 {
   return m_childItems.count();
 }
 
 int QmitkImageStatisticsTreeItem::columnCount() const
 {
   return m_statisticNames.size() + 1;
 }
 
 struct StatValueVisitor : boost::static_visitor<QVariant>
 {
   QVariant operator()(const mitk::ImageStatisticsContainer::RealType& val) const
   {
     return QVariant(val);
   }
 
   QVariant operator()(const mitk::ImageStatisticsContainer::VoxelCountType& val) const
   {
     return QVariant::fromValue<mitk::ImageStatisticsContainer::VoxelCountType>(val);
   }
 
   QVariant operator()(const mitk::ImageStatisticsContainer::IndexType& val) const
   {
     std::stringstream ss;
     ss << val;
     return QVariant(QString::fromStdString(ss.str()));
   }
 
 };
 
 QVariant QmitkImageStatisticsTreeItem::data(int column) const
 {
   QVariant result;
   if (column > 0 && !m_statisticNames.empty())
   {
     if (column - 1 < static_cast<int>(m_statisticNames.size()))
     {
       if (m_IsWIP)
       {
         result = QVariant(QString("..."));
       }
       else
       {
         auto statisticKey = m_statisticNames.at(column - 1);
         if (m_statistics.HasStatistic(statisticKey))
         {
           return boost::apply_visitor(StatValueVisitor(), m_statistics.GetValueNonConverted(statisticKey));
         }
         else
         {
           return QVariant();
         }
       }
     }
     else
     {
       return QVariant();
     }
   }
   else if (column == 0)
   {
     result = m_label;
   }
   return result;
 }
 
 QmitkImageStatisticsTreeItem *QmitkImageStatisticsTreeItem::parentItem()
 {
   return m_parentItem;
 }
 
 int QmitkImageStatisticsTreeItem::row() const
 {
   if (m_parentItem)
     return m_parentItem->m_childItems.indexOf(const_cast<QmitkImageStatisticsTreeItem *>(this));
 
   return 0;
 }
 
 bool QmitkImageStatisticsTreeItem::isWIP() const
 {
   return m_IsWIP;
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
index 69236fe49e..40e0ca3b87 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
@@ -1,59 +1,59 @@
 /*============================================================================
 
 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 QmitkImageStatisticsTreeItem_h
 #define QmitkImageStatisticsTreeItem_h
 
 #include <QList>
 #include <QVariant>
 
 #include "mitkImageStatisticsContainer.h"
 
 /*!
 \class QmitkImageStatisticsTreeItem
 An item that represents an entry (usually ImageStatisticsObject) for the QmitkImageStatisticsTreeModel
 */
 class QmitkImageStatisticsTreeItem
 {
 public:
   using ImageStatisticsObject = mitk::ImageStatisticsContainer::ImageStatisticsObject;
   using StatisticNameVector = mitk::ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector;
   QmitkImageStatisticsTreeItem();
   explicit QmitkImageStatisticsTreeItem(ImageStatisticsObject statisticsData,
     StatisticNameVector statisticNames, QVariant label, bool isWIP, QmitkImageStatisticsTreeItem *parentItem = nullptr);
-  explicit QmitkImageStatisticsTreeItem(StatisticNameVector statisticNames,
+  explicit QmitkImageStatisticsTreeItem(const StatisticNameVector& statisticNames,
     QVariant label, bool isWIP, QmitkImageStatisticsTreeItem *parentItem = nullptr);
   ~QmitkImageStatisticsTreeItem();
 
   void appendChild(QmitkImageStatisticsTreeItem *child);
 
   QmitkImageStatisticsTreeItem *child(int row);
   int childCount() const;
   int columnCount() const;
   QVariant data(int column) const;
   int row() const;
   QmitkImageStatisticsTreeItem *parentItem();
 
   /**indicates that the statistic container owned by this instance is only a dummy
-  WIP containter and the calculation of the up-to-date statistic is not yet finished.**/
+  WIP container and the calculation of the up-to-date statistic is not yet finished.**/
   bool isWIP() const;
 
 private:
   ImageStatisticsObject m_statistics;
   StatisticNameVector m_statisticNames;
   QVariant m_label;
   QmitkImageStatisticsTreeItem *m_parentItem = nullptr;
   QList<QmitkImageStatisticsTreeItem *> m_childItems;
   bool m_IsWIP;
 };
 
 #endif
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
index 65c86e2024..82dbe49401 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
@@ -1,424 +1,497 @@
 /*============================================================================
 
 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 "QmitkImageStatisticsTreeModel.h"
 
 #include "QmitkImageStatisticsTreeItem.h"
 #include "mitkImageStatisticsContainerManager.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 
 #include "QmitkStyleManager.h"
 
 QmitkImageStatisticsTreeModel::QmitkImageStatisticsTreeModel(QObject *parent) : QmitkAbstractDataStorageModel(parent)
 {
-  m_RootItem = new QmitkImageStatisticsTreeItem();
+  m_RootItem = std::make_unique<QmitkImageStatisticsTreeItem>();
 }
 
 QmitkImageStatisticsTreeModel ::~QmitkImageStatisticsTreeModel()
 {
   // set data storage to nullptr so that the event listener gets removed
   this->SetDataStorage(nullptr);
-  delete m_RootItem;
 };
 
 void QmitkImageStatisticsTreeModel::DataStorageChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodePredicateChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 int QmitkImageStatisticsTreeModel::columnCount(const QModelIndex& /*parent*/) const
 {
   int columns = m_StatisticNames.size() + 1;
   return columns;
 }
 
 int QmitkImageStatisticsTreeModel::rowCount(const QModelIndex &parent) const
 {
   QmitkImageStatisticsTreeItem *parentItem;
   if (parent.column() > 0)
     return 0;
 
   if (!parent.isValid())
-    parentItem = m_RootItem;
+    parentItem = m_RootItem.get();
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   return parentItem->childCount();
 }
 
 QVariant QmitkImageStatisticsTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   QmitkImageStatisticsTreeItem* item = static_cast<QmitkImageStatisticsTreeItem*>(index.internalPointer());
 
   if (role == Qt::DisplayRole)
   {
     return item->data(index.column());
   }
   else if (role == Qt::DecorationRole && index.column() == 0 && item->isWIP() && item->childCount()==0)
   {
     return QVariant(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/hourglass-half-solid.svg")));
   }
   return QVariant();
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!hasIndex(row, column, parent))
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *parentItem;
 
   if (!parent.isValid())
-    parentItem = m_RootItem;
+    parentItem = m_RootItem.get();
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   QmitkImageStatisticsTreeItem *childItem = parentItem->child(row);
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *childItem = static_cast<QmitkImageStatisticsTreeItem *>(child.internalPointer());
   QmitkImageStatisticsTreeItem *parentItem = childItem->parentItem();
 
-  if (parentItem == m_RootItem)
+  if (parentItem == m_RootItem.get())
     return QModelIndex();
 
   return createIndex(parentItem->row(), 0, parentItem);
 }
 
 Qt::ItemFlags QmitkImageStatisticsTreeModel::flags(const QModelIndex &index) const
 {
   if (!index.isValid())
     return {};
 
   return QAbstractItemModel::flags(index);
 }
 
 QVariant QmitkImageStatisticsTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
   {
     if (section == 0)
     {
       return m_HeaderFirstColumn;
     }
     else
     {
       return QVariant(m_StatisticNames.at(section - 1).c_str());
     }
   }
   return QVariant();
 }
 
 void QmitkImageStatisticsTreeModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedImageNodes = std::move(tempNodes);
   m_ImageNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
-      // special case: apply one mask to each timestep of an 4D image
+      // special case: apply one mask to each time step of an 4D image
       if (timeSteps == 1 && m_TimeStepResolvedImageNodes.size() > 1)
       {
         timeSteps = m_TimeStepResolvedImageNodes.size();
       }
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedMaskNodes = std::move(tempNodes);
   m_MaskNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::Clear()
 {
   emit beginResetModel();
   m_Statistics.clear();
   m_ImageNodes.clear();
   m_TimeStepResolvedImageNodes.clear();
   m_MaskNodes.clear();
   m_StatisticNames.clear();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::SetIgnoreZeroValueVoxel(bool _arg)
 {
   if (m_IgnoreZeroValueVoxel != _arg)
   {
     emit beginResetModel();
     m_IgnoreZeroValueVoxel = _arg;
     UpdateByDataStorage();
     emit endResetModel();
     emit modelChanged();
   }
 }
 
 bool QmitkImageStatisticsTreeModel::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeroValueVoxel;
 }
 
 void QmitkImageStatisticsTreeModel::SetHistogramNBins(unsigned int nbins)
 {
   if (m_HistogramNBins != nbins)
   {
     emit beginResetModel();
     m_HistogramNBins = nbins;
     UpdateByDataStorage();
     emit endResetModel();
     emit modelChanged();
   }
 }
 
 unsigned int QmitkImageStatisticsTreeModel::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 void QmitkImageStatisticsTreeModel::UpdateByDataStorage()
 {
   StatisticsContainerVector newStatistics;
 
   auto datamanager = m_DataStorage.Lock();
 
   if (datamanager.IsNotNull())
   {
     for (const auto &image : m_ImageNodes)
     {
       if (m_MaskNodes.empty())
       {
         auto stats = mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), nullptr, m_IgnoreZeroValueVoxel, m_HistogramNBins, true, false);
 
         if (stats.IsNotNull())
         {
           newStatistics.emplace_back(stats);
         }
       }
       else
       {
         for (const auto &mask : m_MaskNodes)
         {
           auto stats =
             mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), mask->GetData(), m_IgnoreZeroValueVoxel, m_HistogramNBins, true, false);
           if (stats.IsNotNull())
           {
             newStatistics.emplace_back(stats);
           }
         }
       }
     }
     if (!newStatistics.empty())
     {
       emit dataAvailable();
     }
   }
 
   {
     std::lock_guard<std::mutex> locked(m_Mutex);
     m_Statistics = newStatistics;
+
+    m_StatisticNames = mitk::GetAllStatisticNames(m_Statistics);
+    BuildHierarchicalModel();
+    m_BuildTime.Modified();
   }
+}
 
-  m_StatisticNames = mitk::GetAllStatisticNames(m_Statistics);
-  BuildHierarchicalModel();
+void AddTimeStepTreeItems(const mitk::ImageStatisticsContainer* statistic, mitk::ImageStatisticsContainer::LabelValueType labelValue, const std::vector<std::string>& statisticNames, bool isWIP, QmitkImageStatisticsTreeItem* parentItem, bool& hasMultipleTimesteps)
+{
+  // 4. hierarchy level: time steps (optional, only if >1 time step)
+  if (statistic->GetTimeSteps() > 1)
+  {
+    for (unsigned int i = 0; i < statistic->GetTimeSteps(); i++)
+    {
+      QString timeStepLabel = "[" + QString::number(i) + "] " +
+        QString::number(statistic->GetTimeGeometry()->TimeStepToTimePoint(i)) + " ms";
+      if (statistic->StatisticsExist(labelValue, i))
+      {
+        auto statisticsItem = new QmitkImageStatisticsTreeItem(
+          statistic->GetStatistics(labelValue,i), statisticNames, timeStepLabel, isWIP, parentItem);
+        parentItem->appendChild(statisticsItem);
+      }
+      else
+      {
+        auto statisticsItem = new QmitkImageStatisticsTreeItem(statisticNames, QStringLiteral("N/A"), isWIP, parentItem);
+      }
+    }
+  }
+  hasMultipleTimesteps = hasMultipleTimesteps || (statistic->GetTimeSteps() > 1);
+}
+
+void AddLabelTreeItems(const mitk::ImageStatisticsContainer* statistic, const mitk::DataNode* maskNode, mitk::ImageStatisticsContainer::LabelValueVectorType labelValues, const std::vector<std::string>& statisticNames, bool isWIP, QmitkImageStatisticsTreeItem* parentItem, bool& hasMultipleTimesteps)
+{
+  // 3. hierarchy level: labels (optional, only if labels >1)
+  for (const auto labelValue : labelValues)
+  {
+    if (labelValue != mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE)
+    {
+      //currently we only show statistics of the labeled pixel if a mask is provided
+      QString labelLabel = QStringLiteral("unnamed label");
+      const auto multiLabelSeg = dynamic_cast<mitk::LabelSetImage*>(maskNode->GetData());
+      if (nullptr != multiLabelSeg)
+      {
+        auto labelInstance = multiLabelSeg->GetLabel(labelValue);
+        labelLabel = QString::fromStdString(labelInstance->GetName() + " (" + labelInstance->GetTrackingID() + ")");
+      }
+      QmitkImageStatisticsTreeItem* labelItem = nullptr;
+
+      if (statistic->GetTimeSteps() == 1)
+      {
+        // add statistical values directly in this hierarchy level
+        auto statisticsObject = statistic->GetStatistics(labelValue, 0);
+        labelItem = new QmitkImageStatisticsTreeItem(statisticsObject, statisticNames, labelLabel, isWIP, parentItem);
+      }
+      else
+      {
+        labelItem = new QmitkImageStatisticsTreeItem(statisticNames, labelLabel, isWIP, parentItem);
+        AddTimeStepTreeItems(statistic, labelValue, statisticNames, isWIP, labelItem, hasMultipleTimesteps);
+      }
+
+      parentItem->appendChild(labelItem);
+    }
+  }
 }
 
 void QmitkImageStatisticsTreeModel::BuildHierarchicalModel()
 {
   // reset old model
-  delete m_RootItem;
-  m_RootItem = new QmitkImageStatisticsTreeItem();
+  m_RootItem.reset(new QmitkImageStatisticsTreeItem());
 
   bool hasMask = false;
   bool hasMultipleTimesteps = false;
 
   std::map<mitk::DataNode::ConstPointer, QmitkImageStatisticsTreeItem *> dataNodeToTreeItem;
 
   for (const auto &statistic : m_Statistics)
   {
     bool isWIP = statistic->GetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str()).IsNotNull();
     // get the connected image data node/mask data node
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     auto imageOfStatisticsPredicate = imageRule->GetDestinationsDetector(statistic);
     auto imageFinding = std::find_if(m_ImageNodes.begin(), m_ImageNodes.end(), [&imageOfStatisticsPredicate](const mitk::DataNode::ConstPointer& testNode) { return imageOfStatisticsPredicate->CheckNode(testNode); });
 
     auto maskRule = mitk::StatisticsToMaskRelationRule::New();
     auto maskOfStatisticsPredicate = maskRule->GetDestinationsDetector(statistic);
     auto maskFinding = std::find_if(m_MaskNodes.begin(), m_MaskNodes.end(), [&maskOfStatisticsPredicate](const mitk::DataNode::ConstPointer& testNode) { return maskOfStatisticsPredicate->CheckNode(testNode); });
 
     if (imageFinding == m_ImageNodes.end())
     {
       mitkThrow() << "no image found connected to statistic" << statistic << " Aborting.";
     }
 
     auto& image = *imageFinding;
 
     // image: 1. hierarchy level
     QmitkImageStatisticsTreeItem *imageItem = nullptr;
     auto search = dataNodeToTreeItem.find(image);
-    // the tree item was created previously
     if (search != dataNodeToTreeItem.end())
     {
+      // the tree item was created previously
       imageItem = search->second;
     }
-    // create the tree item
     else
     {
       QString imageLabel = QString::fromStdString(image->GetName());
       if (statistic->GetTimeSteps() == 1 && maskFinding == m_MaskNodes.end())
       {
-        auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
-        imageItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, imageLabel, isWIP, m_RootItem);
+        // create the final statistics tree item
+        auto statisticsObject = isWIP ? mitk::ImageStatisticsContainer::ImageStatisticsObject() : statistic->GetStatistics(mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE, 0);
+        imageItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, imageLabel, isWIP, m_RootItem.get());
       }
       else
       {
-        imageItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, imageLabel, isWIP, m_RootItem);
+        imageItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, imageLabel, isWIP, m_RootItem.get());
       }
       m_RootItem->appendChild(imageItem);
       dataNodeToTreeItem.emplace(image, imageItem);
     }
 
-    // mask: 2. hierarchy level (optional, only if mask exists)
-    QmitkImageStatisticsTreeItem *lastParent = nullptr;
+    const auto labelValues = statistic->GetExistingLabelValues(true); //currently we not support showing the statistics for unlabeled pixels if a mask exist
     if (maskFinding != m_MaskNodes.end())
     {
+      // mask: 2. hierarchy level exists
       auto& mask = *maskFinding;
       QString maskLabel = QString::fromStdString(mask->GetName());
-      QmitkImageStatisticsTreeItem *maskItem;
-      // add statistical values directly in this hierarchy level
-      if (statistic->GetTimeSteps() == 1)
+      QmitkImageStatisticsTreeItem* maskItem;
+
+      if (statistic->GetTimeSteps() == 1 && labelValues.size() == 1)
       {
-        auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
+        // add statistical values directly in this hierarchy level
+        auto statisticsObject = isWIP ? mitk::ImageStatisticsContainer::ImageStatisticsObject() : statistic->GetStatistics(labelValues.front(), 0);
         maskItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, maskLabel, isWIP, imageItem);
       }
       else
       {
         maskItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, maskLabel, isWIP, imageItem);
       }
 
       imageItem->appendChild(maskItem);
-      lastParent = maskItem;
       hasMask = true;
+
+      // 3. hierarchy level: labels (optional, only if more then one label in statistic)
+      if (labelValues.size() > 1)
+      {
+        AddLabelTreeItems(statistic, mask, labelValues, m_StatisticNames, isWIP, maskItem, hasMultipleTimesteps);
+      }
+      else
+      {
+        mitk::Label::PixelType labelValue = isWIP ? 0 : labelValues.front();
+        AddTimeStepTreeItems(statistic, labelValue, m_StatisticNames, isWIP, maskItem, hasMultipleTimesteps);
+      }
     }
     else
     {
-      lastParent = imageItem;
-    }
-    // 3. hierarchy level (optional, only if >1 timestep)
-    if (statistic->GetTimeSteps() > 1)
-    {
-      for (unsigned int i = 0; i < statistic->GetTimeSteps(); i++)
-      {
-        QString timeStepLabel = "[" + QString::number(i) + "] " +
-                                QString::number(statistic->GetTimeGeometry()->TimeStepToTimePoint(i)) + " ms";
-        if (statistic->TimeStepExists(i))
-        {
-          auto statisticsItem = new QmitkImageStatisticsTreeItem(
-                statistic->GetStatisticsForTimeStep(i), m_StatisticNames, timeStepLabel, isWIP, lastParent);
-          lastParent->appendChild(statisticsItem);
-        }
-      }
-      hasMultipleTimesteps = true;
+      //no mask -> but multi time step
+      AddTimeStepTreeItems(statistic, mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE, m_StatisticNames, isWIP, imageItem, hasMultipleTimesteps);
     }
   }
   QString headerString = "Images";
   if (hasMask)
   {
     headerString += "/Masks";
   }
   if (hasMultipleTimesteps)
   {
     headerString += "/Timesteps";
   }
   m_HeaderFirstColumn = headerString;
 }
 
-void QmitkImageStatisticsTreeModel::NodeRemoved(const mitk::DataNode *)
+void QmitkImageStatisticsTreeModel::NodeRemoved(const mitk::DataNode* changedNode)
 {
-  emit beginResetModel();
-  UpdateByDataStorage();
-  emit endResetModel();
-  emit modelChanged();
+  bool isRelevantNode = (nullptr != dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData()));
+
+  if (isRelevantNode)
+  {
+    emit beginResetModel();
+    UpdateByDataStorage();
+    emit endResetModel();
+    emit modelChanged();
+  }
 }
 
-void QmitkImageStatisticsTreeModel::NodeAdded(const mitk::DataNode *)
+void QmitkImageStatisticsTreeModel::NodeAdded(const mitk::DataNode * changedNode)
 {
-  emit beginResetModel();
-  UpdateByDataStorage();
-  emit endResetModel();
-  emit modelChanged();
+  bool isRelevantNode = (nullptr != dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData()));
+
+  if (isRelevantNode)
+  {
+      emit beginResetModel();
+      UpdateByDataStorage();
+      emit endResetModel();
+      emit modelChanged();
+  }
 }
 
-void QmitkImageStatisticsTreeModel::NodeChanged(const mitk::DataNode *)
+void QmitkImageStatisticsTreeModel::NodeChanged(const mitk::DataNode * changedNode)
 {
-  emit beginResetModel();
-  UpdateByDataStorage();
-  emit endResetModel();
-  emit modelChanged();
+  bool isRelevantNode = m_ImageNodes.end() != std::find(m_ImageNodes.begin(), m_ImageNodes.end(), changedNode);
+  isRelevantNode = isRelevantNode || (m_MaskNodes.end() != std::find(m_MaskNodes.begin(), m_MaskNodes.end(), changedNode));
+  isRelevantNode = isRelevantNode || (nullptr != dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData()));
+
+  if (isRelevantNode)
+  {
+    if (m_BuildTime.GetMTime() < changedNode->GetData()->GetMTime())
+    {
+      emit beginResetModel();
+      UpdateByDataStorage();
+      emit endResetModel();
+      emit modelChanged();
+    }
+  }
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.h
index a32ecf4d94..7797c328cb 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.h
@@ -1,127 +1,129 @@
 /*============================================================================
 
 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 QmitkImageStatisticsTreeModel_h
 #define QmitkImageStatisticsTreeModel_h
 
 #include "QmitkAbstractDataStorageModel.h"
 
 //MITK
 #include <MitkImageStatisticsUIExports.h>
 #include "mitkImageStatisticsContainer.h"
 
 #include <mutex>
 
 class QmitkImageStatisticsTreeItem;
 
 /*!
 \class QmitkImageStatisticsTreeModel
 The class is used to represent the information of mitk::ImageStatisticsContainer in the set datastorage in the context of the QT view-model-concept.
 The represented ImageStatisticContainer are specified by setting the image and mask nodes that should be regarded.
 In addition you may specified the statistic computation property HistorgramNBins and IgnoreZeroValueVoxel to select the correct
 statistics.
 */
 class MITKIMAGESTATISTICSUI_EXPORT QmitkImageStatisticsTreeModel : public QmitkAbstractDataStorageModel
 {
     Q_OBJECT
 
 public:
 
   QmitkImageStatisticsTreeModel(QObject *parent = nullptr);
   ~QmitkImageStatisticsTreeModel() override;
 
   void SetImageNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes);
   void SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes);
   void Clear();
 
   /*! /brief Set flag to ignore zero valued voxels */
   void SetIgnoreZeroValueVoxel(bool _arg);
   /*! /brief Get status of zero value voxel ignoring. */
   bool GetIgnoreZeroValueVoxel() const;
 
   /*! /brief Set bin size for histogram resolution.*/
   void SetHistogramNBins(unsigned int nbins);
   /*! /brief Get bin size for histogram resolution.*/
   unsigned int GetHistogramNBins() const;
 
   Qt::ItemFlags flags(const QModelIndex &index) const override;
   QVariant data(const QModelIndex &index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
   int rowCount(const QModelIndex &parent = QModelIndex()) const override;
   int columnCount(const QModelIndex &parent = QModelIndex()) const override;
 
   QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex &child) const override;
 
 signals:
   void dataAvailable();
   /** Is emitted whenever the model changes are finished (usually a bit later than dataAvailable()).*/
   void modelChanged();
 
 protected:
   /*
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void DataStorageChanged() override;
   /*
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodePredicateChanged() override;
   /*
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeAdded(const mitk::DataNode *node) override;
   /*
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeChanged(const mitk::DataNode *node) override;
   /*
   * @brief See 'QmitkAbstractDataStorageModel'
   */
   void NodeRemoved(const mitk::DataNode *node) override;
 
 private:
     void UpdateByDataStorage();
 
     using StatisticsContainerVector = std::vector<mitk::ImageStatisticsContainer::ConstPointer>;
     /* builds a hierarchical tree model for the image statistics
     1. Level: Image
     --> 2. Level: Mask [if exist]
-        --> 3. Level: Timestep [if >1 exist] */
+        --> 3. Level: Label instances [if Mask has more then one label]
+           --> 4. Level: Timestep [if >1 exist] */
     void BuildHierarchicalModel();
 
     StatisticsContainerVector m_Statistics;
 
     /** Relevant images set by the user.*/
     std::vector<mitk::DataNode::ConstPointer> m_ImageNodes;
     /** Helper that is constructed when m_ImageNodes is set. It has the same order
     like m_ImageNodes, but each image is represented n times, while n is the number
     of time steps the respective image has. This structure makes the business logic
     to select the correct image given a QIndex much simpler and therefore easy to
     understand/maintain. */
     std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int> > m_TimeStepResolvedImageNodes;
     /** relevant masks set by the user.*/
     std::vector<mitk::DataNode::ConstPointer> m_MaskNodes;
     /** @sa m_TimeStepResolvedImageNodes */
     std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> m_TimeStepResolvedMaskNodes;
     std::vector<std::string> m_StatisticNames;
 
     std::mutex m_Mutex;
-    QmitkImageStatisticsTreeItem *m_RootItem;
+    std::unique_ptr<QmitkImageStatisticsTreeItem> m_RootItem;
     QVariant m_HeaderFirstColumn;
+    itk::TimeStamp m_BuildTime;
 
     bool m_IgnoreZeroValueVoxel = false;
     unsigned int m_HistogramNBins = 100;
 };
 
 #endif
diff --git a/Modules/Multilabel/mitkLabel.cpp b/Modules/Multilabel/mitkLabel.cpp
index 6972b9f126..e71e6c3b7a 100644
--- a/Modules/Multilabel/mitkLabel.cpp
+++ b/Modules/Multilabel/mitkLabel.cpp
@@ -1,304 +1,309 @@
 /*============================================================================
 
 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 "mitkLabel.h"
 
 #include "itkProcessObject.h"
 #include <itkCommand.h>
 #include <mitkProperties.h>
 #include <mitkDICOMSegmentationPropertyHelper.h>
 #include <mitkStringProperty.h>
 
 const mitk::Label::PixelType mitk::Label::MAX_LABEL_VALUE = std::numeric_limits<mitk::Label::PixelType>::max();
 
 mitk::Label::Label() : PropertyList()
 {
   if (GetProperty("locked") == nullptr)
     SetLocked(true);
   if (GetProperty("visible") == nullptr)
     SetVisible(true);
   if (GetProperty("opacity") == nullptr)
     SetOpacity(0.6);
   if (GetProperty("center.coordinates") == nullptr)
   {
     mitk::Point3D pnt;
     pnt.SetElement(0, 0);
     pnt.SetElement(1, 0);
     pnt.SetElement(2, 0);
     SetCenterOfMassCoordinates(pnt);
   }
   if (GetProperty("center.index") == nullptr)
   {
     mitk::Point3D pnt;
     pnt.SetElement(0, 0);
     pnt.SetElement(1, 0);
     pnt.SetElement(2, 0);
     SetCenterOfMassIndex(pnt);
   }
   if (GetProperty("color") == nullptr)
   {
     mitk::Color col;
     col.Set(0, 0, 0);
     SetColor(col);
   }
   if (GetProperty("name") == nullptr)
     SetName("noName!");
   if (GetProperty("value") == nullptr)
     SetValue(0);
   if (GetProperty("layer") == nullptr)
     SetLayer(0);
 
   DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(this);
 }
 
 mitk::Label::Label(PixelType value, const std::string& name) : Label()
 {
   this->SetValue(value);
   this->SetName(name);
 }
 
 mitk::Label::Label(const Label &other) : PropertyList(other)
 // copyconstructer of property List handles the coping action
 {
   auto *map = this->GetMap();
   auto it = map->begin();
   auto end = map->end();
 
   for (; it != end; ++it)
   {
     itk::SimpleMemberCommand<Label>::Pointer command = itk::SimpleMemberCommand<Label>::New();
     command->SetCallbackFunction(this, &Label::Modified);
     it->second->AddObserver(itk::ModifiedEvent(), command);
   }
 }
 
 mitk::Label::~Label()
 {
 }
 
 void mitk::Label::SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
 {
   itk::SimpleMemberCommand<Label>::Pointer command = itk::SimpleMemberCommand<Label>::New();
   command->SetCallbackFunction(this, &Label::Modified);
   property->AddObserver(itk::ModifiedEvent(), command);
 
   Superclass::SetProperty(propertyKey, property, contextName, fallBackOnDefaultContext);
 }
 
 void mitk::Label::SetLocked(bool locked)
 {
   mitk::BoolProperty *property = dynamic_cast<mitk::BoolProperty *>(GetProperty("locked"));
   if (property != nullptr)
     // Update Property
     property->SetValue(locked);
   else
     // Create new Property
     SetBoolProperty("locked", locked);
 }
 
 bool mitk::Label::GetLocked() const
 {
   bool locked;
   GetBoolProperty("locked", locked);
   return locked;
 }
 
 void mitk::Label::SetVisible(bool visible)
 {
   mitk::BoolProperty *property = dynamic_cast<mitk::BoolProperty *>(GetProperty("visible"));
   if (property != nullptr)
     // Update Property
     property->SetValue(visible);
   else
     // Create new Property
     SetBoolProperty("visible", visible);
 }
 
 bool mitk::Label::GetVisible() const
 {
   bool visible;
   GetBoolProperty("visible", visible);
   return visible;
 }
 
 void mitk::Label::SetOpacity(float opacity)
 {
   mitk::FloatProperty *property = dynamic_cast<mitk::FloatProperty *>(GetProperty("opacity"));
   if (property != nullptr)
     // Update Property
     property->SetValue(opacity);
   else
     // Create new Property
     SetFloatProperty("opacity", opacity);
 }
 
 float mitk::Label::GetOpacity() const
 {
   float opacity;
   GetFloatProperty("opacity", opacity);
   return opacity;
 }
 
 void mitk::Label::SetName(const std::string &name)
 {
   SetStringProperty("name", name.c_str());
 }
 
 std::string mitk::Label::GetName() const
 {
   std::string name;
   GetStringProperty("name", name);
   return name;
 }
 
+std::string mitk::Label::GetTrackingID() const
+{
+  return std::to_string(this->GetValue());
+}
+
 void mitk::Label::SetValue(PixelType pixelValue)
 {
   mitk::UShortProperty *property = dynamic_cast<mitk::UShortProperty *>(GetProperty("value"));
   if (property != nullptr)
     // Update Property
     property->SetValue(pixelValue);
   else
     // Create new Property
     SetProperty("value", mitk::UShortProperty::New(pixelValue));
 }
 
 mitk::Label::PixelType mitk::Label::GetValue() const
 {
   PixelType pixelValue;
   mitk::UShortProperty *property = dynamic_cast<UShortProperty *>(GetProperty("value"));
   assert(property);
   pixelValue = property->GetValue();
   return pixelValue;
 }
 
 void mitk::Label::SetLayer(unsigned int layer)
 {
   mitk::UIntProperty *property = dynamic_cast<mitk::UIntProperty *>(GetProperty("layer"));
   if (property != nullptr)
     // Update Property
     property->SetValue(layer);
   else
     // Create new Property
     SetProperty("layer", mitk::UIntProperty::New(layer));
 }
 
 unsigned int mitk::Label::GetLayer() const
 {
   unsigned int layer;
   mitk::UIntProperty *prop = dynamic_cast<mitk::UIntProperty *>(GetProperty("layer"));
   layer = prop->GetValue();
   return layer;
 }
 
 const mitk::Color &mitk::Label::GetColor() const
 {
   mitk::ColorProperty *colorProp = dynamic_cast<mitk::ColorProperty *>(GetProperty("color"));
   return colorProp->GetColor();
 }
 
 void mitk::Label::SetColor(const mitk::Color &_color)
 {
   mitk::ColorProperty *colorProp = dynamic_cast<mitk::ColorProperty *>(GetProperty("color"));
   if (colorProp != nullptr)
     // Update Property
     colorProp->SetColor(_color);
   else
     // Create new Property
     SetProperty("color", mitk::ColorProperty::New(_color));
 }
 
 void mitk::Label::SetCenterOfMassIndex(const mitk::Point3D &center)
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.index"));
   if (property != nullptr)
     // Update Property
     property->SetValue(center);
   else
     // Create new Property
     SetProperty("center.index", mitk::Point3dProperty::New(center));
 }
 
 mitk::Point3D mitk::Label::GetCenterOfMassIndex() const
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.index"));
   return property->GetValue();
 }
 
 void mitk::Label::SetCenterOfMassCoordinates(const mitk::Point3D &center)
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.coordinates"));
   if (property != nullptr)
     // Update Property
     property->SetValue(center);
   else
     // Create new Property
     SetProperty("center.coordinates", mitk::Point3dProperty::New(center));
 }
 
 mitk::Point3D mitk::Label::GetCenterOfMassCoordinates() const
 {
   mitk::Point3dProperty *property = dynamic_cast<mitk::Point3dProperty *>(GetProperty("center.coordinates"));
   return property->GetValue();
 }
 
 itk::LightObject::Pointer mitk::Label::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   result->UnRegister();
   return result;
 }
 
 void mitk::Label::PrintSelf(std::ostream & /*os*/, itk::Indent /*indent*/) const
 {
   // todo
 }
 
 bool mitk::Equal(const mitk::Label &leftHandSide, const mitk::Label &rightHandSide, ScalarType /*eps*/, bool verbose)
 {
   MITK_INFO(verbose) << "--- Label Equal ---";
 
   bool returnValue = true;
   // have to be replaced until a PropertyList Equal was implemented :
   // returnValue = mitk::Equal((const mitk::PropertyList &)leftHandSide,(const mitk::PropertyList
   // &)rightHandSide,eps,verbose);
 
   const mitk::PropertyList::PropertyMap *lhsmap = leftHandSide.GetMap();
   const mitk::PropertyList::PropertyMap *rhsmap = rightHandSide.GetMap();
 
   returnValue = lhsmap->size() == rhsmap->size();
 
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Labels in label container are not equal.";
     return returnValue;
   }
 
   auto lhsmapIt = lhsmap->begin();
   auto lhsmapItEnd = lhsmap->end();
 
   for (; lhsmapIt != lhsmapItEnd; ++lhsmapIt)
   {
     if (rhsmap->find(lhsmapIt->first) == rhsmap->end())
     {
       returnValue = false;
       break;
     }
   }
 
   if (!returnValue)
   {
     MITK_INFO(verbose) << "Labels in label container are not equal.";
     return returnValue;
   }
 
   return returnValue;
 }
diff --git a/Modules/Multilabel/mitkLabel.h b/Modules/Multilabel/mitkLabel.h
index 3a3b963f67..8452a9cea3 100644
--- a/Modules/Multilabel/mitkLabel.h
+++ b/Modules/Multilabel/mitkLabel.h
@@ -1,113 +1,115 @@
 /*============================================================================
 
 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 mitkLabel_h
 #define mitkLabel_h
 
 #include "MitkMultilabelExports.h"
 #include <mitkColorProperty.h>
 #include <mitkPropertyList.h>
 #include <mitkPoint.h>
 #include <mitkVector.h>
 
 namespace mitk
 {
   //##
   //##Documentation
   //## @brief A data structure describing a label.
   //## @ingroup Data
   //##
   class MITKMULTILABEL_EXPORT Label : public PropertyList
   {
   public:
     mitkClassMacro(Label, mitk::PropertyList);
 
     typedef unsigned short PixelType;
 
     itkNewMacro(Self);
     mitkNewMacro2Param(Self, PixelType, const std::string&);
 
     /// The maximum value a label can get: Since the value is of type unsigned short MAX_LABEL_VALUE = 65535
     static const PixelType MAX_LABEL_VALUE;
 
     //** Value indicating pixels that are not labeled at all.*/
     const static PixelType UNLABELED_VALUE = 0;
 
     void SetLocked(bool locked);
     bool GetLocked() const;
 
     void SetVisible(bool visible);
     bool GetVisible() const;
 
     void SetOpacity(float opacity);
     float GetOpacity() const;
 
     void SetName(const std::string &name);
     std::string GetName() const;
 
+    std::string GetTrackingID() const;
+
     void SetCenterOfMassIndex(const mitk::Point3D &center);
     mitk::Point3D GetCenterOfMassIndex() const;
 
     void SetCenterOfMassCoordinates(const mitk::Point3D &center);
     mitk::Point3D GetCenterOfMassCoordinates() const;
 
     void SetColor(const mitk::Color &);
     const mitk::Color &GetColor() const;
 
     void SetValue(PixelType pixelValue);
     PixelType GetValue() const;
 
     void SetLayer(unsigned int layer);
     unsigned int GetLayer() const;
 
     void SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
 
     using itk::Object::Modified;
     void Modified() { Superclass::Modified(); }
     Label();
     Label(PixelType value, const std::string& name);
     ~Label() override;
 
   protected:
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     Label(const Label &other);
 
   private:
     itk::LightObject::Pointer InternalClone() const override;
   };
 
   using LabelVector = std::vector<Label::Pointer>;
   using ConstLabelVector = std::vector<Label::ConstPointer>;
 
   /**
   * @brief Equal A function comparing two labels for beeing equal in data
   *
   * @ingroup MITKTestingAPI
   *
   * Following aspects are tested for equality:
   *  - Lebel equality via Equal-PropetyList
   *
   * @param rightHandSide An image to be compared
   * @param leftHandSide An image to be compared
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return true, if all subsequent comparisons are true, false otherwise
   */
   MITKMULTILABEL_EXPORT bool Equal(const mitk::Label &leftHandSide,
                                    const mitk::Label &rightHandSide,
                                    ScalarType eps,
                                    bool verbose);
 
 } // namespace mitk
 
 #endif
diff --git a/Modules/Multilabel/mitkLabelSetImage.cpp b/Modules/Multilabel/mitkLabelSetImage.cpp
index a8f0632437..1acb843c38 100644
--- a/Modules/Multilabel/mitkLabelSetImage.cpp
+++ b/Modules/Multilabel/mitkLabelSetImage.cpp
@@ -1,1630 +1,1630 @@
 /*============================================================================
 
 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 <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 (afte 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];
 
   // 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::Pointer layerImage, ConstLabelVector labels)
 {
   GroupIndexType newGroupID = m_Groups.size();
 
   // 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
   auto 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[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)
 {
   if (m_LabelMap.find(pixelValue) == m_LabelMap.end()) return;
 
   auto 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)
 {
   unsigned int max_size = mitk::Label::MAX_LABEL_VALUE + 1;
   if (m_LayerContainer.size() >= max_size)
     return nullptr;
 
   mitk::Label::Pointer newLabel = addAsClone ? label->Clone() : Label::Pointer(label);
 
   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::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)
 {
   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.";
   }
 }
 
 mitk::Image::Pointer mitk::LabelSetImage::CreateLabelMask(PixelType index)
 {
   if (!this->ExistLabel(index)) mitkThrow() << "Error, cannot return label mask. Label ID is invalid. Invalid ID: " << index;
 
   auto mask = mitk::Image::New();
 
   // mask->Initialize(this) does not work here if this label set image has a single slice,
   // since the mask would be automatically flattened to a 2-d image, whereas we expect the
   // original dimension of this label set image. Hence, initialize the mask more explicitly:
   mask->Initialize(this->GetPixelType(), this->GetDimension(), this->GetDimensions());
   mask->SetTimeGeometry(this->GetTimeGeometry()->Clone());
 
   ClearImageBuffer(mask);
 
   const auto groupID = this->GetGroupIndexOfLabel(index);
 
   auto destinationLabel = this->GetLabel(index)->Clone();
   destinationLabel->SetValue(1);
 
   TransferLabelContent(this->GetGroupImage(groupID), mask.GetPointer(),
     {destinationLabel},
     LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, false,
     { { index, destinationLabel->GetValue()}}, MultiLabelSegmentation::MergeStyle::Replace, MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
 
   return mask;
 }
 
 void mitk::LabelSetImage::InitializeByLabeledImage(mitk::Image::Pointer image)
 {
   if (image.IsNull() || image->IsEmpty() || !image->IsInitialized())
     mitkThrow() << "Invalid labeled image.";
 
   try
   {
     this->Initialize(image);
 
     unsigned int byteSize = sizeof(LabelSetImage::PixelType);
     for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
     {
       byteSize *= image->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor *accessor = new mitk::ImageWriteAccessor(static_cast<mitk::Image *>(this));
     memset(accessor->GetData(), 0, byteSize);
     delete accessor;
 
     auto geometry = image->GetTimeGeometry()->Clone();
     this->SetTimeGeometry(geometry);
 
     if (image->GetDimension() == 3)
     {
       AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 3);
     }
     else if (image->GetDimension() == 4)
     {
       AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 4);
     }
     else
     {
       mitkThrow() << image->GetDimension() << "-dimensional label set images not yet supported";
     }
   }
   catch (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(itk::Image<TPixel, VImageDimension> *source,
                                                           unsigned int layer) const
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename ImageType::Pointer itkTarget;
   // mitk::CastToItkImage(m_LayerContainer[layer], itkTarget);
   itkTarget = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
 
   typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
   typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
 
   SourceIteratorType sourceIter(source, source->GetLargestPossibleRegion());
   sourceIter.GoToBegin();
 
   TargetIteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
   targetIter.GoToBegin();
 
   while (!sourceIter.IsAtEnd())
   {
     targetIter.Set(sourceIter.Get());
     ++sourceIter;
     ++targetIter;
   }
 }
 
 template <typename ImageType>
 void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue)
 {
   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)
 {
   UpdateLookupTable(label->GetValue());
 
   auto command = itk::MemberCommand<LabelSetImage>::New();
   command->SetCallbackFunction(this, &LabelSetImage::OnLabelModified);
   label->AddObserver(itk::ModifiedEvent(), command);
 }
 
 void mitk::LabelSetImage::ReleaseLabel(Label* label)
 {
   if (nullptr == label) mitkThrow() << "Invalid call of ReleaseLabel with a nullptr.";
   label->RemoveAllObservers();
 }
 
 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, std::string_view name) const
+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 = [visible](Label* l) { l->SetVisible(visible); };
 
   this->ApplyToLabels(this->GetAllLabelValues(), setVisibility);
 }
 
 void mitk::LabelSetImage::SetAllLabelsVisibleByGroup(GroupIndexType group, bool visible)
 {
   auto setVisibility = [visible](Label* l) { l->SetVisible(visible); };
 
   this->ApplyToLabels(this->GetLabelValuesByGroup(group), setVisibility);
 }
 
-void mitk::LabelSetImage::SetAllLabelsVisibleByName(GroupIndexType group, std::string_view name, bool visible)
+void mitk::LabelSetImage::SetAllLabelsVisibleByName(GroupIndexType group, const std::string_view name, bool visible)
 {
   auto setVisibility = [visible](Label* l) { l->SetVisible(visible); };
 
   this->ApplyToLabels(this->GetLabelValuesByName(group, name), setVisibility);
 }
 
 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, std::string_view name, bool locked)
+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;
   }
 
   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/mitkLabelSetImage.h b/Modules/Multilabel/mitkLabelSetImage.h
index dda7565751..35ffd15e03 100644
--- a/Modules/Multilabel/mitkLabelSetImage.h
+++ b/Modules/Multilabel/mitkLabelSetImage.h
@@ -1,672 +1,672 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkLabelSetImage_h
 #define mitkLabelSetImage_h
 
 #include <mitkImage.h>
 #include <mitkLabel.h>
 #include <mitkLookupTable.h>
 #include <mitkMultiLabelEvents.h>
 #include <mitkMessage.h>
 
 #include <MitkMultilabelExports.h>
 
 namespace mitk
 {
   /** @brief LabelSetImage class for handling labels and layers in a segmentation session.
   *
   * Events that are potentially send by the class in regard to groups or labels:
   * - LabelAddedEvent is emitted whenever a new label has been added.
   * - LabelModifiedEvent is emitted whenever a label has been modified.
   * - LabelRemovedEvent is emitted whenever a label has been removed.
   * - LabelsChangedEvent is emitted when labels are changed (added, removed, modified). In difference to the other label events LabelsChanged is send only *one time* after the modification of the
   * MultiLableImage instance is finished. So e.g. even if 4 labels are changed by a merge operation, this event will
   * only be sent once (compared to LabelRemoved or LabelModified).
   * - GroupAddedEvent is emitted whenever a new group has been added.
   * - GroupModifiedEvent is emitted whenever a group has been modified.
   * - GroupRemovedEvent is emitted whenever a label has been removed.
   *
   * @ingroup Data
   */
   class MITKMULTILABEL_EXPORT LabelSetImage : public Image
   {
   public:
     /**
     * \brief BeforeChangeLayerEvent (e.g. used for GUI integration)
     * As soon as active labelset should be changed, the signal emits.
     * Emitted by SetActiveLayer(int layer);
     */
     Message<> BeforeChangeLayerEvent;
 
     /**
     * \brief AfterchangeLayerEvent (e.g. used for GUI integration)
     * As soon as active labelset was changed, the signal emits.
     * Emitted by SetActiveLayer(int layer);
     */
     Message<> AfterChangeLayerEvent;
 
     ///////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////
     // FUTURE MultiLabelSegmentation:
     // Section that already contains declarations used in the new class.
     // So this part of the interface will stay after refactoring towards
     // the new MultiLabelSegmentation class (see T28524). This section was introduced
     // because some of the planned features are already urgently needed.
     ///////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////
     mitkClassMacro(LabelSetImage, Image);
     itkNewMacro(Self);
 
     typedef mitk::Label::PixelType PixelType;
 
     using GroupIndexType = std::size_t;
     using LabelValueType = mitk::Label::PixelType;
     using ConstLabelVectorType = ConstLabelVector;
     using LabelVectorType = LabelVector;
     using LabelValueVectorType = std::vector<LabelValueType>;
 
     const static LabelValueType UNLABELED_VALUE;
 
     /** \brief Adds a label instance to a group of the multi label image.
     * @remark By default, if the pixel value of the label is already used in the image, the label
     * will get a new none conflicting value assigned. This can be controlled by correctLabelValue.
     * @param label Instance of an label that should be added or used as template
     * @param groupID The id of the group the label should be added to.
     * @param addAsClone Flag that controls, if the passed instance should be added (false; the image will then take ownership,
     * be aware that e.g. event observers will be added)
     * a clone of the instance (true).
     * @param correctLabelValue Flag that controls, if the value of the passed label should be correct, if this value is already used in
     * the multi label image. True: Conflicting values will be corrected, be assigning a none conflicting value. False: If the value is conflicting
     * an exception will be thrown.
     * @return Instance of the label as it was added to the label set.
     * @pre label must point to a valid instance.
     * @pre If correctLabelValue==false, label value must be non conflicting.
     * @pre groupID must indicate an existing group.
     */
     mitk::Label* AddLabel(mitk::Label* label, GroupIndexType groupID, bool addAsClone = true, bool correctLabelValue = true);
 
     /** \brief Adds a new label to a group of the image by providing name and color.
     * @param name (Class) name of the label instance that should be added.
     * @param color Color of the new label sinstance.
     * @param groupID The id of the group the label should be added to.
     * @return Instance of the label as it was added to the label set.
     * @pre groupID must indicate an existing group.
     */
     mitk::Label* AddLabel(const std::string& name, const Color& color, GroupIndexType groupID);
 
     /** \brief allows to adapt name and color of a certain label
     * @param labelValue Value of the label that should be changed
     * @param name New name for the label
     * @param color New color for the label
     * @pre Indicated label value must exist.
     */
     void RenameLabel(LabelValueType labelValue, const std::string& name, const Color& color);
 
     /**
      * @brief Removes the label with the given value.
      * The label is removed from the labelset and
      * the pixel with the value of the label are set to UNLABELED_VALUE.
      * @param labelValue the pixel value of the label to be removed. If the label is unknown,
      * the method will return without doing anything.
      */
     void RemoveLabel(LabelValueType labelValue);
 
     /**
      * @brief Removes labels from the mitk::MultiLabelSegmentation.
      * The label is removed from the labelset and
      * the pixel with the value of the label are set to UNLABELED_VALUE.
      * If a label value does not exist, it will be ignored.
      * @param vectorOfLabelPixelValues a list of labels to be removed
      */
     void RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues);
 
     /**
      * @brief Erases the label with the given value from the labelset image.
      * The label itself will not be erased from the respective mitk::LabelSet. In order to
      * remove the label itself use mitk::LabelSetImage::RemoveLabels()
      * @param labelValue the pixel value of the label that will be erased from the labelset image
      * @pre labelValue must exist.
      */
     void EraseLabel(LabelValueType labelValue);
 
     /**
      * @brief Erases a list of labels with the given values from the labelset image.
      * @param labelValues the list of pixel values of the labels
      * that will be erased from the labelset image
      * @pre label values must exist
      */
     void EraseLabels(const LabelValueVectorType& labelValues);
 
     /**
      * @brief Removes a whole group including all its labels.
      * @remark with removing a group all groups with greater index will be re-indexed to
      * close the gap. Hence externally stored spatial group indices may become invalid.
      * @param group Group index of the spatial group that should be removed. If the spatial group does not exist, an
      * exception will be raised.
      * @pre group index must be valid.
      */
     void RemoveGroup(GroupIndexType group);
 
     /** \brief  Returns true if the value exists in the MultiLabelSegmentation instance*/
     bool ExistLabel(LabelValueType value) const;
 
     /**
      * @brief Checks if a label belongs in a certain spatial group
      * @param value the label value
      * @param groupIndex Index of the spacial group which should be checked for the label
      * @return true if the label exists otherwise false
      */
     bool ExistLabel(LabelValueType value, GroupIndexType groupIndex) const;
 
     /**
       * @brief  Returns true if the spatial group exists in the MultiLabelSegmentation instance.
       *
       * @param index Group index of the group that should be checked for existance.
       */
     bool ExistGroup(GroupIndexType index) const;
 
     /** Returns the group id of the based label value.
     * @pre label value must exists.
     */
     GroupIndexType GetGroupIndexOfLabel(LabelValueType value) const;
 
     /**
      * @brief Returns the mitk::Label with the given value.
      * @param value the pixel value of the label
      * @return the label instance if defined in the segmentation, otherwise nullptr.
      */
     const mitk::Label* GetLabel(LabelValueType value) const;
     mitk::Label* GetLabel(LabelValueType value);
 
     /** Returns a vector with pointers to all labels currently defined in the MultiLabelSegmentation
     instance.*/
     const ConstLabelVectorType GetLabels() const;
     const LabelVectorType GetLabels();
 
     /** Returns a vector of all label values currently defined in the MultiLabelSegmentation
     instance.*/
     const LabelValueVectorType GetAllLabelValues() const;
 
     /** @brief Returns a vector with pointers to all labels in the MultiLabelSegmentation indicated
     * by the passed label value vector.
     * @param labelValues Vector of values of labels that should be returned.
     * @ignoreMissing If true(Default) unknown labels Will be skipped in the result. If false,
     * an exception will be raised, if a label is requested.
     instance.*/
     const LabelVectorType GetLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing = true);
 
     /** @brief Returns a vector with const pointers to all labels in the MultiLabelSegmentation indicated
     * by the passed label value vector.
     * For details see GetLabelsByValue();
     */
     const ConstLabelVectorType GetConstLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing = false) const;
 
     /** Helper function that can be used to extract a vector of label values of a vector of label instance pointers.
      @overload.*/
     static LabelValueVectorType ExtractLabelValuesFromLabelVector(const ConstLabelVectorType& labels);
     /** Helper function that can be used to extract a vector of label values are vector of label instances.*/
     static LabelValueVectorType ExtractLabelValuesFromLabelVector(const LabelVectorType& labels);
 
     /** Helper function that converts a given vector of label instance pointers into a vector of const pointers.*/
     static ConstLabelVectorType ConvertLabelVectorConst(const LabelVectorType& labels);
 
     /**
      * @brief Returns a vector of all label values located on the specified group.
      * @param index the index of the group for which the vector of labels should be retrieved.
      * If an invalid index is passed an exception will be raised.
      * @return the respective vector of label values.
      * @pre group index must exist.
      */
     const LabelValueVectorType GetLabelValuesByGroup(GroupIndexType index) const;
 
     /**
      * @brief Returns a vector of all label values located on the specified group having a certain name.
      * @param index the index of the group for which the vector of labels should be retrieved.
      * If an invalid index is passed an exception will be raised.
      * @param name Name of the label instances one is looking for.
      * @return the respective vector of label values.
      * @pre group index must exist.
      */
-    const LabelValueVectorType GetLabelValuesByName(GroupIndexType index, std::string_view name) const;
+    const LabelValueVectorType GetLabelValuesByName(GroupIndexType index, const std::string_view name) const;
 
     /**
     * Returns a vector with (class) names of all label instances used in the segmentation (over all groups)
     */
     std::vector<std::string> GetLabelClassNames() const;
 
     /**
     * Returns a vector with (class) names of all label instances present in a certain group.
     * @param index ID of the group, for which the label class names should be returned
     * @pre Indicated group must exist. */
     std::vector<std::string> GetLabelClassNamesByGroup(GroupIndexType index) const;
 
     /** Helper that returns an unused label value, that could be used e.g. if one wants to define a label externally
     * before adding it.
     * @return A label value currently not in use.
     * @remark is no unused label value can be provided an exception will be thrown.*/
     LabelValueType GetUnusedLabelValue() const;
 
     itkGetConstMacro(UnlabeledLabelLock, bool);
     itkSetMacro(UnlabeledLabelLock, bool);
     itkBooleanMacro(UnlabeledLabelLock);
 
     /** Set the visibility of all label instances accordingly to the passed state.
     */
     void SetAllLabelsVisible(bool visible);
 
     /** Set the visibility of all label instances in a group accordingly to the passed state.
     * @pre The specified group must exist.
     */
     void SetAllLabelsVisibleByGroup(GroupIndexType group, bool visible);
 
     /** Set the visibility of all label instances In a group with a given class name
     * accordingly to the passed state.
     * @pre The specified group must exist.
     */
-    void SetAllLabelsVisibleByName(GroupIndexType group, std::string_view name, bool visible);
+    void SetAllLabelsVisibleByName(GroupIndexType group, const std::string_view name, bool visible);
 
     /** Returns the lock state of the label (including UnlabeledLabel value).
      @pre Requested label does exist.*/
     bool IsLabelLocked(LabelValueType value) const;
 
     /** Set the lock state of all label instances accordingly to the passed state.
     */
     void SetAllLabelsLocked(bool locked);
 
     /** Set the lock state of all label instances in a group accordingly to the passed state.
     * @pre The specified group must exist.
     */
     void SetAllLabelsLockedByGroup(GroupIndexType group, bool locked);
 
     /** Set the lock state of all label instances In a group with a given class name
     * accordingly to the passed state.
     * @pre The specified group must exist.
     */
-    void SetAllLabelsLockedByName(GroupIndexType group, std::string_view name, bool locked);
+    void SetAllLabelsLockedByName(GroupIndexType group, const std::string_view name, bool locked);
 
     /**
     * \brief Replaces the labels of a group with a given vector of labels.
     *
     * @remark The passed label instances will be cloned before added to ensure clear ownership
     * of the new labels.
     * @remark The pixel content of the old labels will not be removed.
     * @param groupID The index of the group that should have its labels replaced
     * @param newLabels The vector of new labels
     * @pre Group that should be replaced must exist.
     * @pre new label values must not be used in other groups.
     */
     void ReplaceGroupLabels(const GroupIndexType groupID, const ConstLabelVectorType& newLabels);
 
     /**@overload for none-const label vectors. */
     void ReplaceGroupLabels(const GroupIndexType groupID, const LabelVectorType& newLabels);
 
     /** Returns the pointer to the image that contains the labeling of the indicate group.
      *@pre groupID must reference an existing group.*/
     mitk::Image* GetGroupImage(GroupIndexType groupID);
 
     /** Returns the pointer to the image that contains the labeling of the indicate group.
      *@pre groupID must reference an existing group.*/
     const mitk::Image* GetGroupImage(GroupIndexType groupID) const;
 
     itkGetModifiableObjectMacro(LookupTable, mitk::LookupTable);
     void SetLookupTable(LookupTable* lut);
     /** Updates the lookup table for a label indicated by the passed label value using the color of the label.
     * @pre labelValue must exist.
     */
     void UpdateLookupTable(PixelType pixelValue);
 
     protected:
 
       void OnLabelModified(const Object* sender, const itk::EventObject&);
 
       /** Helper to ensure that the maps are correctly populated for a new label instance.*/
       void AddLabelToMap(LabelValueType labelValue, Label* label, GroupIndexType groupID);
       void RemoveLabelFromMap(LabelValueType labelValue);
       /** Helper to ensure label events are correctly connected and lookup table is updated for a new label instance.*/
       void RegisterLabel(Label* label);
       /** Helper to ensure label events are unregistered.*/
       void ReleaseLabel(Label* label);
 
       /** Helper class used internally to apply lambda functions to the labels specified by the passed label value vector.
       */
       void ApplyToLabels(const LabelValueVectorType& values, std::function<void(Label*)>&& lambda);
       /** Helper class used internally to for visiting the labels specified by the passed label value vector
       * with the lambda function.
       */
       void VisitLabels(const LabelValueVectorType& values, std::function<void(const Label*)>&& lambda) const;
 
       LabelValueType m_ActiveLabelValue;
 
     private:
       using LabelMapType = std::map<LabelValueType, Label::Pointer>;
       /** Dictionary that holds all known labels (label value is the key).*/
       LabelMapType m_LabelMap;
 
       using GroupNameVectorType = std::vector<std::string>;
       /** Vector storing the names of all groups. If a group has no user name defined, string is empty.*/
       GroupNameVectorType m_Groups;
 
       /**This type is internally used to track which label is currently
        * associated with which layer.*/
       using GroupToLabelMapType = std::vector<LabelValueVectorType>;
       /* Dictionary that maps between group id (key) and label values in the group (vector of label value).*/
       GroupToLabelMapType m_GroupToLabelMap;
       using LabelToGroupMapType = std::map<LabelValueType, GroupIndexType>;
       /* Dictionary that maps between label value (key) and group id (value)*/
       LabelToGroupMapType m_LabelToGroupMap;
 
       LookupTable::Pointer m_LookupTable;
 
       /** Indicates if the MultiLabelSegmentation allows to overwrite unlabeled pixels in normal pixel manipulation operations (e.g. TransferLabelConent).*/
       bool m_UnlabeledLabelLock;
 
     public:
 
 
     ///////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////
     // END FUTURE MultiLabelSegmentation
     ///////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////
     /**
       * \brief  */
       void UpdateCenterOfMass(PixelType pixelValue);
 
     /**
      * @brief Initialize an empty mitk::LabelSetImage using the information
      *        of an mitk::Image
      * @param image the image which is used for initializing the mitk::LabelSetImage
      */
     using mitk::Image::Initialize;
     void Initialize(const mitk::Image *image) override;
 
     /**
       * \brief removes all pixel content form the active layer.*/
     void ClearBuffer();
 
     /**
      * @brief Merges the mitk::Label with a given target value with the active label
      *
      * @param pixelValue          the value of the label that should be the new merged label
      * @param sourcePixelValue    the value of the label that should be merged into the specified one
      */
     void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue);
 
     /**
      * @brief Merges a list of mitk::Labels with the mitk::Label that has a specific value
      *
      * @param pixelValue                  the value of the label that should be the new merged label
      * @param vectorOfSourcePixelValues   the list of label values that should be merge into the specified one
      */
     void MergeLabels(PixelType pixelValue, const std::vector<PixelType>& vectorOfSourcePixelValues);
 
     /**
      * @brief Gets the ID of the currently active layer
      * @return the ID of the active layer
      * @pre at least on group must exist.
      */
     unsigned int GetActiveLayer() const;
 
     /** \brief
 */
     Label* GetActiveLabel();
     /** \brief
     */
     const Label* GetActiveLabel() const;
 
     /**
      * @brief Get the number of all existing mitk::Labels for a given layer
      * @param layer the layer ID for which the active mitk::Labels should be retrieved
      * @return the number of all existing mitk::Labels for the given layer
      */
     unsigned int GetNumberOfLabels(unsigned int layer) const;
 
     /**
      * @brief Returns the number of all labels summed up across all layers
      * @return the overall number of labels across all layers
      */
     unsigned int GetTotalNumberOfLabels() const;
 
     /**
       * \brief  */
     mitk::Image::Pointer CreateLabelMask(PixelType index);
 
     /**
      * @brief Initialize a new mitk::LabelSetImage by a given image.
      * For all distinct pixel values of the parameter image new labels will
      * be created. If the number of distinct pixel values exceeds mitk::Label::MAX_LABEL_VALUE
      * an exception will be raised.
      * @param image the image which is used for initialization
      */
     void InitializeByLabeledImage(mitk::Image::Pointer image);
 
     /**
       * \brief  */
     void MaskStamp(mitk::Image *mask, bool forceOverwrite);
 
     /**
       * \brief  */
     void SetActiveLayer(unsigned int layer);
     void SetActiveLabel(LabelValueType label);
 
     /**
       * \brief  */
     unsigned int GetNumberOfLayers() const;
 
     /**
      * \brief Adds a new layer to the LabelSetImage. The new layer will be set as the active one.
      * \param labelSet a labelset that will be added to the new layer if provided
      * \return the layer ID of the new layer
      */
     GroupIndexType AddLayer(ConstLabelVector labels = {});
 
     /**
     * \brief Adds a layer based on a provided mitk::Image.
     * \param layerImage is added to the vector of label images
     * \param labels labels that will be cloned and added to the new layer if provided
     * \return the layer ID of the new layer
     */
     GroupIndexType AddLayer(mitk::Image::Pointer layerImage, ConstLabelVector labels = {});
 
   protected:
     mitkCloneMacro(Self);
 
       LabelSetImage();
     LabelSetImage(const LabelSetImage &other);
     ~LabelSetImage() override;
 
     template <typename TPixel, unsigned int VImageDimension>
     void LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer);
 
     template <typename TPixel, unsigned int VImageDimension>
     void ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
 
     template <typename ImageType>
     void CalculateCenterOfMassProcessing(ImageType *input, LabelValueType index);
 
     template <typename ImageType>
     void EraseLabelProcessing(ImageType *input, PixelType index);
 
     template <typename ImageType>
     void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);
 
     template <typename ImageType>
     void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);
 
     template <typename LabelSetImageType, typename ImageType>
     void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);
 
     /** helper needed for ensuring unique values.
       returns a sorted list of all labels (including the value for Unlabeled pixels..*/
     LabelValueVectorType GetUsedLabelValues() const;
 
     std::vector<Image::Pointer> m_LayerContainer;
 
     int m_ActiveLayer;
     bool m_activeLayerInvalid;
   };
 
   /**
   * @brief Equal A function comparing two label set images for beeing equal in meta- and imagedata
   *
   * @ingroup MITKTestingAPI
   *
   * Following aspects are tested for equality:
   *  - LabelSetImage members
   *  - working image data
   *  - layer image data
   *  - labels in label set
   *
   * @param rightHandSide An image to be compared
   * @param leftHandSide An image to be compared
   * @param eps Tolerance for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return true, if all subsequent comparisons are true, false otherwise
   */
   MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
                                    const mitk::LabelSetImage &rightHandSide,
                                    ScalarType eps,
                                    bool verbose);
 
   /**
   * @brief Equal A function comparing two vectors of labels for being equal in data
   *
   * @ingroup MITKTestingAPI
   *
   * Following aspects are tested for equality:
   *  - Labels in vector
   *
   * @param rightHandSide An vector of labels to be compared
   * @param leftHandSide An vector of labels to be compared
   * @param eps Tolerance for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return true, if all subsequent comparisons are true, false otherwise
   */
   MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage::ConstLabelVectorType& leftHandSide,
     const mitk::LabelSetImage::ConstLabelVectorType& rightHandSide,
     ScalarType eps,
     bool verbose);
 
 
   /** temporary namespace that is used until the new class MultiLabelSegmentation is
     introduced. It allows to already introduce/use some upcoming definitions, while
     refactoring code.*/
   namespace MultiLabelSegmentation
   {
     enum class MergeStyle
     {
       Replace, //The old label content of a label value will be replaced by its new label content.
                //Therefore pixels that are labeled might become unlabeled again.
                //(This means that a lock of the value is also ignored).
       Merge //The union of old and new label content will be generated.
     };
 
     enum class OverwriteStyle
     {
       RegardLocks, //Locked labels in the same spatial group will not be overwritten/changed.
       IgnoreLocks //Label locks in the same spatial group will be ignored, so these labels might be changed.
     };
   }
 
   using LabelValueMappingVector = std::vector < std::pair<Label::PixelType, Label::PixelType> >;
 
   /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
   a specified destination label for a specific time step. Function processes the whole image volume of the specified time step.
   @remark in its current implementation the function only transfers contents of the active layer of the passed LabelSetImages.
   @remark the function assumes that it is only called with source and destination image of same geometry.
   @remark CAUTION: The function is not save if sourceImage and destinationImage are the same instance and more than one label is transferred,
   because the changes are made in-place for performance reasons in multiple passes. If a mapped value A equals an "old value"
   that occurs later in the mapping, one ends up with a wrong transfer, as a pixel would be first mapped to A and then later again, because
   it is also an "old" value in the mapping table.
   @param sourceImage Pointer to the LabelSetImage which active layer should be used as source for the transfer.
   @param destinationImage Pointer to the LabelSetImage which active layer should be used as destination for the transfer.
   @param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
   label in the source image. The second element is the label that transferred pixels should become in the destination image.
   The order in which the labels will be transfered is the same order of elements in the labelMapping.
   If you use a heterogeneous label mapping (e.g. (1,2); so changing the label while transferring), keep in mind that
   for the MergeStyle and OverwriteStyle only the destination label (second element) is relevant (e.g. what should be
   altered with MergeStyle Replace).
   @param mergeStyle indicates how the transfer should be done (merge or replace). For more details see documentation of
   MultiLabelSegmentation::MergeStyle.
   @param overwriteStlye indicates if label locks in the destination image should be regarded or not. For more details see
   documentation of MultiLabelSegmentation::OverwriteStyle.
   @param timeStep indicate the time step that should be transferred.
   @pre sourceImage and destinationImage must be valid
   @pre sourceImage and destinationImage must contain the indicated timeStep
   @pre sourceImage must contain all indicated sourceLabels in its active layer.
   @pre destinationImage must contain all indicated destinationLabels in its active layer.*/
   MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
     const TimeStepType timeStep, LabelValueMappingVector labelMapping = { {1,1} },
     MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
     MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
   /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
   a specified destination label. Function processes the whole image volume for all time steps.
   For more details please see TransferLabelContentAtTimeStep for LabelSetImages.
   @sa TransferLabelContentAtTimeStep*/
   MITKMULTILABEL_EXPORT void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage, LabelValueMappingVector labelMapping = { {1,1} },
     MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
     MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
 
   /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
   a specified destination label for a specific time step. Function processes the whole image volume of the specified time step.
   @remark the function assumes that it is only called with source and destination image of same geometry.
   @remark CAUTION: The function is not save, if sourceImage and destinationImage are the same instance and you transfer more then one
   label, because the changes are made in-place for performance reasons but not in one pass. If a mapped value A equals a "old value"
   that is later in the mapping, one ends up with a wrong transfer, as a pixel would be first mapped to A and then latter again, because
   it is also an "old" value in the mapping table.
   @param sourceImage Pointer to the image that should be used as source for the transfer.
   @param destinationImage Pointer to the image that should be used as destination for the transfer.
   @param destinationLabelVector Reference to the vector of labels (incl. lock states) in the destination image. Unknown pixel
   values in the destinationImage will be assumed to be unlocked.
   @param sourceBackground Value indicating the background in the source image.
   @param destinationBackground Value indicating the background in the destination image.
   @param destinationBackgroundLocked Value indicating the lock state of the background in the destination image.
   @param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
   label in the source image. The second element is the label that transferred pixels should become in the destination image.
   The order in which the labels will be transfered is the same order of elements in the labelMapping.
   If you use a heterogeneous label mapping (e.g. (1,2); so changing the label while transferring), keep in mind that
   for the MergeStyle and OverwriteStyle only the destination label (second element) is relevant (e.g. what should be
   altered with MergeStyle Replace).
   @param mergeStyle indicates how the transfer should be done (merge or replace). For more details see documentation of
   MultiLabelSegmentation::MergeStyle.
   @param overwriteStlye indicates if label locks in the destination image should be regarded or not. For more details see
   documentation of MultiLabelSegmentation::OverwriteStyle.
   @param timeStep indicate the time step that should be transferred.
   @pre sourceImage, destinationImage and destinationLabelVector must be valid
   @pre sourceImage and destinationImage must contain the indicated timeStep
   @pre destinationLabelVector must contain all indicated destinationLabels for mapping.*/
   MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabelVector,
     const TimeStepType timeStep, mitk::Label::PixelType sourceBackground = LabelSetImage::UNLABELED_VALUE,
     mitk::Label::PixelType destinationBackground = LabelSetImage::UNLABELED_VALUE,
     bool destinationBackgroundLocked = false,
     LabelValueMappingVector labelMapping = { {1,1} },
     MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
     MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
   /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
   a specified destination label. Function processes the whole image volume for all time steps.
   For more details please see TransferLabelContentAtTimeStep.
   @sa TransferLabelContentAtTimeStep*/
   MITKMULTILABEL_EXPORT void TransferLabelContent(const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabelVector,
     mitk::Label::PixelType sourceBackground = LabelSetImage::UNLABELED_VALUE,
     mitk::Label::PixelType destinationBackground = LabelSetImage::UNLABELED_VALUE,
     bool destinationBackgroundLocked = false,
     LabelValueMappingVector labelMapping = { {1,1} },
     MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
     MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
 } // namespace mitk
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index 3e2fc21535..73d178103c 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,487 +1,493 @@
 /*============================================================================
 
 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 "QmitkImageStatisticsView.h"
 
 #include <utility>
 
 // berry includes
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <QmitkChartWidget.h>
 #include <mitkImageStatisticsContainerNodeHelper.h>
 #include <mitkImageStatisticsPredicateHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkIntensityProfile.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateGeometry.h>
 #include <mitkNodePredicateSubGeometry.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkStatusBar.h>
 #include <mitkPlanarFigure.h>
 #include "mitkPlanarFigureMaskGenerator.h"
 
 #include "QmitkImageStatisticsDataGenerator.h"
 
 #include "mitkImageStatisticsContainerManager.h"
 #include <mitkPlanarFigureInteractor.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 
 namespace {
   bool CheckPlanarFigureMatchesGeometry(const mitk::PlanarFigure* planarFigure, const mitk::BaseGeometry* imageGeometry)
   {
     if (!planarFigure || !imageGeometry)
       return false;
 
     if (!mitk::PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(planarFigure->GetPlaneGeometry(), imageGeometry))
       return false;
 
     // The rest from here on is only needed until T30279 has been solved.
     if (planarFigure->IsClosed())
       return true;
 
     const auto numControlPoints = planarFigure->GetNumberOfControlPoints();
     for (unsigned int i = 0; i < numControlPoints; ++i)
     {
       if (!imageGeometry->IsInside(planarFigure->GetWorldControlPoint(i)))
         return false;
     }
 
     return true;
   }
 } // unnamed namespace
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
 }
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.widget_intensityProfile->SetTheme(GetColorTheme());
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.groupBox_intensityProfile->setVisible(false);
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
   m_Controls.sliderWidget_histogram->setPrefix("Time: ");
   m_Controls.sliderWidget_histogram->setDecimals(0);
   m_Controls.sliderWidget_histogram->setVisible(false);
   m_Controls.sliderWidget_intensityProfile->setPrefix("Time: ");
   m_Controls.sliderWidget_intensityProfile->setDecimals(0);
   m_Controls.sliderWidget_intensityProfile->setVisible(false);
   ResetGUI();
 
   m_DataGenerator = new QmitkImageStatisticsDataGenerator(parent);
   m_DataGenerator->SetDataStorage(this->GetDataStorage());
   m_DataGenerator->SetAutoUpdate(true);
   m_Controls.widget_statistics->SetDataStorage(this->GetDataStorage());
 
   m_Controls.imageNodesSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.imageNodesSelector->SetNodePredicate(mitk::GetImageStatisticsImagePredicate());
   m_Controls.imageNodesSelector->SetSelectionCheckFunction(this->CheckForSameGeometry());
   m_Controls.imageNodesSelector->SetSelectionIsOptional(false);
   m_Controls.imageNodesSelector->SetInvalidInfo(QStringLiteral("Please select images for statistics"));
   m_Controls.imageNodesSelector->SetPopUpTitel(QStringLiteral("Select input images"));
   m_Controls.roiNodesSelector->SetPopUpHint(QStringLiteral("You may select multiple images for the statistics computation. But all selected images must have the same geometry."));
 
   m_Controls.roiNodesSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
   m_Controls.roiNodesSelector->SetSelectionIsOptional(true);
   m_Controls.roiNodesSelector->SetEmptyInfo(QStringLiteral("Please select ROIs"));
   m_Controls.roiNodesSelector->SetPopUpTitel(QStringLiteral("Select ROIs for statistics computation"));
   m_Controls.roiNodesSelector->SetPopUpHint(QStringLiteral("You may select ROIs (e.g. planar figures, segmentations) that should be used for the statistics computation. The statistics will only computed for the image parts defined by the ROIs."));
 
   CreateConnections();
 
   this->m_TimePointChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
   connect(&m_TimePointChangeListener, &QmitkSliceNavigationListener::SelectedTimePointChanged, this, & QmitkImageStatisticsView::OnSelectedTimePointChanged);
 }
 
 void QmitkImageStatisticsView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   this->m_TimePointChangeListener.RenderWindowPartActivated(renderWindowPart);
 }
 
 void QmitkImageStatisticsView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   this->m_TimePointChangeListener.RenderWindowPartDeactivated(renderWindowPart);
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   connect(m_Controls.widget_statistics, &QmitkImageStatisticsWidget::IgnoreZeroValuedVoxelStateChanged,
     this, &QmitkImageStatisticsView::OnIgnoreZeroValuedVoxelStateChanged);
   connect(m_Controls.buttonSelection, &QAbstractButton::clicked,
     this, &QmitkImageStatisticsView::OnButtonSelectionPressed);
 
   connect(m_Controls.widget_histogram, &QmitkHistogramVisualizationWidget::RequestHistogramUpdate,
     this, &QmitkImageStatisticsView::OnRequestHistogramUpdate);
 
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::DataGenerationStarted,
     this, &QmitkImageStatisticsView::OnGenerationStarted);
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::GenerationFinished,
     this, &QmitkImageStatisticsView::OnGenerationFinished);
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::JobError,
     this, &QmitkImageStatisticsView::OnJobError);
 
   connect(m_Controls.imageNodesSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageStatisticsView::OnImageSelectionChanged);
   connect(m_Controls.roiNodesSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageStatisticsView::OnROISelectionChanged);
 
   connect(m_Controls.sliderWidget_intensityProfile, &ctkSliderWidget::valueChanged, this, &QmitkImageStatisticsView::UpdateIntensityProfile);
 }
 
 void QmitkImageStatisticsView::UpdateIntensityProfile()
 {
   m_Controls.groupBox_intensityProfile->setVisible(false);
 
   const auto selectedImageNodes = m_Controls.imageNodesSelector->GetSelectedNodes();
   const auto selectedROINodes = m_Controls.roiNodesSelector->GetSelectedNodes();
 
   if (selectedImageNodes.size()==1 && selectedROINodes.size()==1)
   { //only supported for one image and roi currently
     auto image = dynamic_cast<mitk::Image*>(selectedImageNodes.front()->GetData());
 
     auto maskPlanarFigure = dynamic_cast<mitk::PlanarFigure*>(selectedROINodes.front()->GetData());
 
     if (maskPlanarFigure != nullptr)
     {
       if (!maskPlanarFigure->IsClosed())
       {
         mitk::Image::Pointer inputImage;
         if (image->GetDimension() == 4)
         {
           m_Controls.sliderWidget_intensityProfile->setVisible(true);
           unsigned int maxTimestep = image->GetTimeSteps();
           m_Controls.sliderWidget_intensityProfile->setMaximum(maxTimestep - 1);
           // Intensity profile can only be calculated on 3D, so extract if 4D
           mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
           int currentTimestep = static_cast<int>(m_Controls.sliderWidget_intensityProfile->value());
           timeSelector->SetInput(image);
           timeSelector->SetTimeNr(currentTimestep);
           timeSelector->Update();
 
           inputImage = timeSelector->GetOutput();
         }
         else
         {
           m_Controls.sliderWidget_intensityProfile->setVisible(false);
           inputImage = image;
         }
 
         auto intensityProfile = mitk::ComputeIntensityProfile(inputImage, maskPlanarFigure);
         m_Controls.groupBox_intensityProfile->setVisible(true);
         m_Controls.widget_intensityProfile->Reset();
         m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile.GetPointer(),
           "Intensity Profile of " + selectedImageNodes.front()->GetName());
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::UpdateHistogramWidget()
 {
   m_Controls.groupBox_histogram->setVisible(false);
 
   const auto selectedImageNodes = m_Controls.imageNodesSelector->GetSelectedNodes();
   const auto selectedMaskNodes = m_Controls.roiNodesSelector->GetSelectedNodes();
 
   if (selectedImageNodes.size() == 1 && selectedMaskNodes.size()<=1)
   { //currently only supported for one image and roi due to histogram widget limitations.
     auto imageNode = selectedImageNodes.front();
     const mitk::DataNode* roiNode = nullptr;
     const mitk::PlanarFigure* planarFigure = nullptr;
     if (!selectedMaskNodes.empty())
     {
       roiNode = selectedMaskNodes.front();
       planarFigure = dynamic_cast<const mitk::PlanarFigure*>(roiNode->GetData());
     }
 
     if ((planarFigure == nullptr || planarFigure->IsClosed())
         && imageNode->GetData()->GetTimeGeometry()->IsValidTimePoint(m_TimePointChangeListener.GetCurrentSelectedTimePoint()))
     { //if a planar figure is not closed, we show the intensity profile instead of the histogram.
       auto statisticsNode = m_DataGenerator->GetLatestResult(imageNode, roiNode, true);
 
       if (statisticsNode.IsNotNull())
       {
         auto statistics = dynamic_cast<const mitk::ImageStatisticsContainer*>(statisticsNode->GetData());
 
         if (statistics)
         {
-          const auto timeStep = imageNode->GetData()->GetTimeGeometry()->TimePointToTimeStep(m_TimePointChangeListener.GetCurrentSelectedTimePoint());
+          auto labelValues = statistics->GetExistingLabelValues(true);
 
-          if (statistics->TimeStepExists(timeStep))
+          if (labelValues.size() == 1)
           {
-            std::stringstream label;
-            label << imageNode->GetName();
-            if (imageNode->GetData()->GetTimeSteps() > 1)
-            {
-              label << "[" << timeStep << "]";
-            }
+            //currently only supported rois with one label due to histogram widget limitations.
+            const auto timeStep = imageNode->GetData()->GetTimeGeometry()->TimePointToTimeStep(m_TimePointChangeListener.GetCurrentSelectedTimePoint());
 
-            if (roiNode)
+            if (statistics->StatisticsExist(labelValues.front(), timeStep))
             {
-              label << " with " << roiNode->GetName();
+              std::stringstream label;
+              label << imageNode->GetName();
+              if (imageNode->GetData()->GetTimeSteps() > 1)
+              {
+                label << "[" << timeStep << "]";
+              }
+
+              if (roiNode)
+              {
+                label << " with " << roiNode->GetName();
+              }
+
+              //Hardcoded labels are currently needed because the current histogram widget (and ChartWidget)
+              //do not allow correct removal or sound update/insertion of several charts.
+              //only thing that works for now is always to update/overwrite the same data label
+              //This is a quick fix for T28223 and T28221
+              m_Controls.widget_histogram->SetHistogram(statistics->GetHistogram(labelValues.front(), timeStep), "histogram");
+              m_Controls.groupBox_histogram->setVisible(true);
             }
-
-            //Hardcoded labels are currently needed because the current histogram widget (and ChartWidget)
-            //do not allow correct removal or sound update/insertion of several charts.
-            //only thing that works for now is always to update/overwrite the same data label
-            //This is a quick fix for T28223 and T28221
-            m_Controls.widget_histogram->SetHistogram(statistics->GetHistogramForTimeStep(timeStep), "histogram");
-            m_Controls.groupBox_histogram->setVisible(true);
           }
         }
       }
     }
   }
 }
 
 QmitkChartWidget::ColorTheme QmitkImageStatisticsView::GetColorTheme() const
 {
   ctkPluginContext *context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     if (styleManager->GetStyle().name == "Dark")
     {
       return QmitkChartWidget::ColorTheme::darkstyle;
     }
     else
     {
       return QmitkChartWidget::ColorTheme::lightstyle;
     }
   }
   return QmitkChartWidget::ColorTheme::darkstyle;
 }
 
 void QmitkImageStatisticsView::ResetGUI()
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->setEnabled(false);
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->setEnabled(false);
   m_Controls.widget_histogram->SetTheme(GetColorTheme());
 }
 
 void QmitkImageStatisticsView::OnGenerationStarted(const mitk::DataNode* /*imageNode*/, const mitk::DataNode* /*roiNode*/, const QmitkDataGenerationJobBase* /*job*/)
 {
   m_Controls.label_currentlyComputingStatistics->setVisible(true);
 }
 
 void QmitkImageStatisticsView::OnGenerationFinished()
 {
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
 
   mitk::StatusBar::GetInstance()->Clear();
 
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnSelectedTimePointChanged(const mitk::TimePointType& /*newTimePoint*/)
 {
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnJobError(QString error, const QmitkDataGenerationJobBase* /*failedJob*/)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(error.toStdString().c_str());
   MITK_WARN << "Error when calculating statistics: " << error;
 }
 
 void QmitkImageStatisticsView::OnRequestHistogramUpdate(unsigned int nbins)
 {
   m_Controls.widget_statistics->SetHistogramNBins(nbins);
   m_DataGenerator->SetHistogramNBins(nbins);
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnIgnoreZeroValuedVoxelStateChanged(int state)
 {
   auto ignoreZeroValueVoxel = (state == Qt::Unchecked) ? false : true;
   m_Controls.widget_statistics->SetIgnoreZeroValueVoxel(ignoreZeroValueVoxel);
   m_DataGenerator->SetIgnoreZeroValueVoxel(ignoreZeroValueVoxel);
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnImageSelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList /*nodes*/)
 {
   auto images = m_Controls.imageNodesSelector->GetSelectedNodesStdVector();
   m_Controls.widget_statistics->SetImageNodes(images);
 
   m_Controls.widget_statistics->setEnabled(!images.empty());
 
   m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
 
   m_DataGenerator->SetAutoUpdate(false);
   m_DataGenerator->SetImageNodes(images);
   m_DataGenerator->Generate();
   m_DataGenerator->SetAutoUpdate(true);
 
   this->UpdateHistogramWidget();
   this->UpdateIntensityProfile();
 }
 
 void QmitkImageStatisticsView::OnROISelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList /*nodes*/)
 {
   auto rois = m_Controls.roiNodesSelector->GetSelectedNodesStdVector();
 
   m_Controls.widget_statistics->SetMaskNodes(rois);
 
   m_DataGenerator->SetAutoUpdate(false);
   m_DataGenerator->SetROINodes(rois);
   m_DataGenerator->Generate();
   m_DataGenerator->SetAutoUpdate(true);
 
   this->UpdateHistogramWidget();
   this->UpdateIntensityProfile();
 }
 
 void QmitkImageStatisticsView::OnButtonSelectionPressed()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(nullptr, "Select input for the statistic","You may select images and ROIs to compute their statistic. ROIs may be segmentations or planar figures.");
   dialog->SetDataStorage(GetDataStorage());
   dialog->SetSelectionCheckFunction(CheckForSameGeometry());
 
   // set predicates
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isImagePredicate = mitk::GetImageStatisticsImagePredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
   auto isImageOrMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isMaskOrPlanarFigurePredicate, isImagePredicate);
   dialog->SetNodePredicate(isImageOrMaskOrPlanarFigurePredicate);
   dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
   dialog->SetCurrentSelection(m_Controls.imageNodesSelector->GetSelectedNodes()+m_Controls.roiNodesSelector->GetSelectedNodes());
 
   if (dialog->exec())
   {
     auto selectedNodeList = dialog->GetSelectedNodes();
 
     m_Controls.imageNodesSelector->SetCurrentSelection(selectedNodeList);
     m_Controls.roiNodesSelector->SetCurrentSelection(selectedNodeList);
   }
 
   delete dialog;
 }
 
 QmitkNodeSelectionDialog::SelectionCheckFunctionType QmitkImageStatisticsView::CheckForSameGeometry() const
 {
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
 
   auto lambda = [isMaskPredicate](const QmitkNodeSelectionDialog::NodeList& nodes)
   {
     if (nodes.empty())
     {
       return std::string();
     }
 
     const mitk::Image* imageNodeData = nullptr;
     for (auto& node : nodes)
     {
       auto castedData = dynamic_cast<const mitk::Image*>(node->GetData());
       if (castedData != nullptr && !isMaskPredicate->CheckNode(node))
       {
         imageNodeData = castedData;
         break;
       }
     }
 
     if (imageNodeData == nullptr)
     {
       std::stringstream ss;
       ss << "<font class=\"warning\"><p>Select at least one image.</p></font>";
       return ss.str();
     }
 
     auto imageGeoPredicate = mitk::NodePredicateGeometry::New(imageNodeData->GetGeometry());
     auto maskGeoPredicate = mitk::NodePredicateSubGeometry::New(imageNodeData->GetGeometry());
 
     for (auto& rightNode : nodes)
     {
       if (imageNodeData != rightNode->GetData())
       {
         bool validGeometry = true;
 
         if (isMaskPredicate->CheckNode(rightNode))
         {
           validGeometry = maskGeoPredicate->CheckNode(rightNode);
         }
         else if (dynamic_cast<const mitk::Image*>(rightNode->GetData()))
         {
           validGeometry = imageGeoPredicate->CheckNode(rightNode);
         }
         else
         {
           const auto planarFigure = dynamic_cast<const mitk::PlanarFigure*>(rightNode->GetData());
           const auto imageGeometry = imageNodeData->GetGeometry();
           validGeometry = CheckPlanarFigureMatchesGeometry(planarFigure, imageGeometry);
         }
 
         if (!validGeometry)
         {
           std::stringstream ss;
           ss << "<font class=\"warning\"><p>Invalid selection: All selected nodes must have the same geometry.</p><p>Differing node i.a.: \"";
           ss << rightNode->GetName() <<"\"</p></font>";
           return ss.str();
         }
       }
     }
 
     return std::string();
   };
 
   return lambda;
 }
 
 mitk::NodePredicateBase::Pointer QmitkImageStatisticsView::GenerateROIPredicate() const
 {
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
 
   mitk::NodePredicateBase::Pointer result = isMaskOrPlanarFigurePredicate.GetPointer();
 
   if(!m_Controls.imageNodesSelector->GetSelectedNodes().empty())
   {
     auto image = m_Controls.imageNodesSelector->GetSelectedNodes().front()->GetData();
     auto imageGeoPredicate = mitk::NodePredicateSubGeometry::New(image->GetGeometry());
 
     auto lambda = [image, imageGeoPredicate](const mitk::DataNode* node)
     {
       bool sameGeometry = true;
 
       if (dynamic_cast<const mitk::Image*>(node->GetData()) != nullptr)
       {
         sameGeometry = imageGeoPredicate->CheckNode(node);
       }
       else
       {
         const auto planarFigure = dynamic_cast<const mitk::PlanarFigure*>(node->GetData());
         sameGeometry = CheckPlanarFigureMatchesGeometry(planarFigure, image->GetGeometry());
       }
 
       return sameGeometry;
     };
 
     result = mitk::NodePredicateAnd::New(isMaskOrPlanarFigurePredicate, mitk::NodePredicateFunction::New(lambda)).GetPointer();
   }
 
   return result;
 }