diff --git a/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp b/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp
index 5bb52f0556..b9cb50b848 100644
--- a/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp
+++ b/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp
@@ -1,580 +1,594 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPropertyRelationRuleBase.h"
 
 #include <mitkDataNode.h>
 #include <mitkExceptionMacro.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkStringProperty.h>
 #include <mitkUIDGenerator.h>
 
 #include <mutex>
 #include <regex>
 
 bool mitk::PropertyRelationRuleBase::IsSourceCandidate(const IPropertyProvider *owner) const
 {
   return owner != nullptr;
 };
 
 bool mitk::PropertyRelationRuleBase::IsDestinationCandidate(const IPropertyProvider *owner) const
 {
   return owner != nullptr;
 };
 
 mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRootKeyPath()
 {
   return PropertyKeyPath().AddElement("MITK").AddElement("Relations");
 };
 
 mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRuleRootKeyPath() const
 {
   return GetRootKeyPath().AddElement(this->GetRuleID());
 };
 
 bool mitk::PropertyRelationRuleBase::IsSource(const IPropertyProvider *owner) const
 {
   if (!owner)
   {
     mitkThrow() << "Error. Passed owner pointer is NULL";
   }
 
   auto keys = owner->GetPropertyKeys();
 
   auto rootkey = PropertyKeyPathToPropertyName(this->GetRuleRootKeyPath());
 
   for (const auto &key : keys)
   {
     if (key.find(rootkey) == 0)
     {
       return true;
     }
   }
 
   return false;
 };
 
 mitk::PropertyRelationRuleBase::RelationType mitk::PropertyRelationRuleBase::HasRelation(
   const IPropertyProvider *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed owner pointer is NULL";
   }
 
   RelationType result = RelationType::None;
 
   if (this->GetInstanceID_IDLayer(source, destination) != NULL_INSTANCE_ID())
   { // has relations of type Connected_ID;
     result = RelationType::Connected_ID;
   }
 
   if (result == RelationType::None)
   {
     auto instanceIDs_data = this->GetInstanceID_datalayer(source, destination);
 
     if (instanceIDs_data.size() > 1)
     {
       MITK_WARN << "Property relation on data level is ambiguous. First relation is used. Instance ID: "
                 << instanceIDs_data.front();
     }
 
     if (!instanceIDs_data.empty() && instanceIDs_data.front() != NULL_INSTANCE_ID())
     { // has relations of type Connected_Data;
       result = RelationType::Connected_Data;
     }
   }
 
   if (result == RelationType::None)
   {
     if (this->HasImplicitDataRelation(source, destination))
     { // has relations of type Connected_Data;
       result = RelationType::Implicit_Data;
     }
   }
 
   return result;
 };
 
 mitk::PropertyRelationRuleBase::RelationUIDVectorType mitk::PropertyRelationRuleBase::GetExistingRelations(
   const IPropertyProvider *source) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   auto relIDRegExStr =
     PropertyKeyPathToPropertyRegEx(this->GetRuleRootKeyPath().AddAnyElement().AddElement("relationUID"));
   auto regEx = std::regex(relIDRegExStr);
 
   const auto keys = source->GetPropertyKeys();
   RelationUIDVectorType relationUIDs;
 
   for (const auto &key : keys)
   {
     if (std::regex_match(key, regEx))
     {
       auto idProp = source->GetConstProperty(key);
       relationUIDs.push_back(idProp->GetValueAsString());
     }
   }
 
   return relationUIDs;
 };
 
 mitk::PropertyRelationRuleBase::RelationUIDType mitk::PropertyRelationRuleBase::GetRelationUID(
   const IPropertyProvider *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   RelationUIDType result;
 
   auto instanceID = this->GetInstanceID_IDLayer(source, destination);
 
   if (instanceID == NULL_INSTANCE_ID())
   {
     auto instanceID_data = this->GetInstanceID_datalayer(source, destination);
 
     if (!instanceID_data.empty())
     {
       instanceID = instanceID_data.front();
     }
 
     if (instanceID_data.size() > 1)
     {
       MITK_WARN << "Property relation on data level is ambigious. First relation is used. Instance ID: " << instanceID;
     }
   }
 
   return this->GetRelationUIDByInstanceID(source, instanceID);
 };
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::NULL_INSTANCE_ID()
 {
   return std::string();
 };
 
 mitk::PropertyRelationRuleBase::RelationUIDType mitk::PropertyRelationRuleBase::GetRelationUIDByInstanceID(
   const IPropertyProvider *source, const InstanceIDType &instanceID) const
 {
   RelationUIDType result;
 
   if (instanceID != NULL_INSTANCE_ID())
   {
     auto idProp = source->GetConstProperty(
       PropertyKeyPathToPropertyName(this->GetRuleRootKeyPath().AddElement(instanceID).AddElement("relationUID")));
 
     if (idProp.IsNotNull())
     {
       result = idProp->GetValueAsString();
     }
   }
 
   if (result.empty())
   {
     mitkThrowException(NoPropertyRelationException);
   }
 
   return result;
 };
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::GetInstanceIDByRelationUID(
   const IPropertyProvider *source, const RelationUIDType &relationUID) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   InstanceIDType result;
 
   auto destRegExStr =
     PropertyKeyPathToPropertyRegEx(this->GetRuleRootKeyPath().AddAnyElement().AddElement("relationUID"));
   auto regEx = std::regex(destRegExStr);
   std::smatch instance_matches;
 
   auto keys = source->GetPropertyKeys();
 
   for (const auto &key : keys)
   {
     if (std::regex_search(key, instance_matches, regEx))
     {
       auto idProp = source->GetConstProperty(key);
       if (idProp->GetValueAsString() == relationUID)
       {
         if (instance_matches.size()>1)
         {
           result = instance_matches[1];
           break;
         }
       }
     }
   }
 
   return result;
 };
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::GetInstanceID_IDLayer(
   const IPropertyProvider *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   auto identifiable = dynamic_cast<const Identifiable *>(destination);
 
   std::string result;
 
   if (identifiable)
   { // check for relations of type Connected_ID;
 
     auto destRegExStr =
       PropertyKeyPathToPropertyRegEx(this->GetRuleRootKeyPath().AddAnyElement().AddElement("destinationUID"));
     auto regEx = std::regex(destRegExStr);
     std::smatch instance_matches;
 
     auto destUID = identifiable->GetUID();
 
-    auto keys = source->GetPropertyKeys();
+    std::vector<std::string> keys;
+
+    auto sourceCasted = dynamic_cast<const mitk::DataNode*>(source);
+    if (sourceCasted) {
+      auto sourceData = sourceCasted->GetData();
+      if (sourceData) {
+        keys = sourceData->GetPropertyKeys();
+      }
+      else {
+        keys = sourceCasted->GetPropertyKeys();
+      }
+    }
+    else {
+      keys = source->GetPropertyKeys();
+    }
 
     for (const auto &key : keys)
     {
       if (std::regex_search(key, instance_matches, regEx))
       {
         auto idProp = source->GetConstProperty(key);
         if (idProp->GetValueAsString() == destUID)
         {
           if (instance_matches.size()>1)
           {
             result = instance_matches[1];
             break;
           }
         }
       }
     }
   }
 
   return result;
 };
 
 void mitk::PropertyRelationRuleBase::Connect(IPropertyOwner *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   InstanceIDType instanceID = this->GetInstanceID_IDLayer(source, destination);
   bool hasIDlayer = instanceID != NULL_INSTANCE_ID();
 
   auto instanceIDs_data = this->GetInstanceID_datalayer(source, destination);
   if (instanceIDs_data.size() > 1)
   {
     MITK_WARN << "Property relation on data level is ambiguous. First relation is used. Instance ID: "
               << instanceIDs_data.front();
   }
   bool hasDatalayer = !instanceIDs_data.empty();
 
   if (hasIDlayer && hasDatalayer && instanceID != instanceIDs_data.front())
   {
     mitkThrow() << "Property relation information is in an invalid state. ID and data layer point to different "
                    "relation instances. Rule: "
                 << this->GetRuleID() << "; ID based instance: " << instanceID
                 << "; Data base instance: " << instanceIDs_data.front();
   }
 
   RelationUIDType relationUID = this->CreateRelationUID();
 
   if (!hasIDlayer)
   {
     if (hasDatalayer)
     {
       instanceID = instanceIDs_data.front();
     }
     else
     {
       instanceID = this->CreateNewRelationInstance(source, relationUID);
     }
   }
 
   auto relUIDKey =
     PropertyKeyPathToPropertyName(this->GetRuleRootKeyPath().AddElement(instanceID).AddElement("relationUID"));
   source->SetProperty(relUIDKey, mitk::StringProperty::New(relationUID));
 
   if (!hasIDlayer)
   {
     auto identifiable = dynamic_cast<const Identifiable *>(destination);
 
     if (identifiable)
     {
       auto destUIDKey =
         PropertyKeyPathToPropertyName(this->GetRuleRootKeyPath().AddElement(instanceID).AddElement("destinationUID"));
       source->SetProperty(destUIDKey, mitk::StringProperty::New(identifiable->GetUID()));
     }
   }
 
   if (!hasDatalayer)
   {
     this->Connect_datalayer(source, destination, instanceID);
   }
 };
 
 void mitk::PropertyRelationRuleBase::Disconnect(IPropertyOwner *source, const IPropertyProvider *destination) const
 {
   try
   {
     this->Disconnect(source, this->GetRelationUID(source, destination));
   }
   catch (const NoPropertyRelationException &)
   {
     // nothing to do and no real error in context of disconnect.
   }
 };
 
 void mitk::PropertyRelationRuleBase::Disconnect(IPropertyOwner *source, RelationUIDType relationUID) const
 {
   auto instanceID = this->GetInstanceIDByRelationUID(source, relationUID);
 
   if (instanceID != NULL_INSTANCE_ID())
   {
     this->Disconnect_datalayer(source, instanceID);
 
     auto instancePrefix = PropertyKeyPathToPropertyName(this->GetRuleRootKeyPath().AddElement(instanceID));
 
     auto keys = source->GetPropertyKeys();
 
     for (const auto &key : keys)
     {
       if (key.find(instancePrefix) == 0)
       {
         source->RemoveProperty(key);
       }
     }
   }
 };
 
 mitk::PropertyRelationRuleBase::RelationUIDType mitk::PropertyRelationRuleBase::CreateRelationUID()
 {
   UIDGenerator generator;
   return generator.GetUID();
 };
 
 /**This mutex is used to guard mitk::PropertyRelationRuleBase::CreateNewRelationInstance by a class wide mutex to avoid
   racing conditions in a scenario where rules are used concurrently. It is not in the class interface itself, because it
   is an implementation detail.
 */
 std::mutex relationCreationLock;
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::CreateNewRelationInstance(
   IPropertyOwner *source, const RelationUIDType &relationUID) const
 {
   std::lock_guard<std::mutex> guard(relationCreationLock);
 
   //////////////////////////////////////
   // Get all existing instanc IDs
 
   std::vector<int> instanceIDs;
   InstanceIDType newID = "1";
 
   auto destRegExStr =
     PropertyKeyPathToPropertyRegEx(this->GetRuleRootKeyPath().AddAnyElement().AddElement("destinationUID"));
   auto regEx = std::regex(destRegExStr);
   std::smatch instance_matches;
 
   auto keys = source->GetPropertyKeys();
 
   for (const auto &key : keys)
   {
     if (std::regex_search(key, instance_matches, regEx))
     {
       if (instance_matches.size()>1)
       {
         instanceIDs.push_back(std::stoi(instance_matches[1]));
       }
     }
   }
 
   //////////////////////////////////////
   // Get new ID
 
   std::sort(instanceIDs.begin(), instanceIDs.end());
   if (!instanceIDs.empty())
   {
     newID = std::to_string(instanceIDs.back() + 1);
   }
 
   //////////////////////////////////////
   // reserve new ID
   auto relUIDKey =
     PropertyKeyPathToPropertyName(this->GetRuleRootKeyPath().AddElement(newID).AddElement("relationUID"));
   source->SetProperty(relUIDKey, mitk::StringProperty::New(relationUID));
 
   return newID;
 };
 
 itk::LightObject::Pointer mitk::PropertyRelationRuleBase::InternalClone() const
 {
   return Superclass::InternalClone();
 };
 
 
 namespace mitk
 {
   /**
   * \brief Predicate used to wrap rule checks.
   *
   * \ingroup DataStorage
   */
   class NodePredicateRuleFunction : public NodePredicateBase
   {
   public:
     using FunctionType = std::function<bool(const mitk::IPropertyProvider *, const mitk::PropertyRelationRuleBase *)>;
 
     mitkClassMacro(NodePredicateRuleFunction, NodePredicateBase)
       mitkNewMacro2Param(NodePredicateRuleFunction, const FunctionType &, PropertyRelationRuleBase::ConstPointer)
 
     virtual ~NodePredicateRuleFunction() = default;
 
     virtual bool CheckNode(const mitk::DataNode *node) const override 
     {
       if (!node)
       {
         return false;
       }
 
       return m_Function(node, m_Rule);
     };
 
   protected:
     explicit NodePredicateRuleFunction(const FunctionType &function, PropertyRelationRuleBase::ConstPointer rule) : m_Function(function), m_Rule(rule)
     {
     };
 
     FunctionType m_Function;
     PropertyRelationRuleBase::ConstPointer m_Rule;
   };
 
 } // namespace mitk
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetSourceCandidateIndicator() const
 {
   auto check = [](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule) {
     return rule->IsSourceCandidate(node);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 };
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetDestinationCandidateIndicator() const
 {
   auto check = [](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule) {
     return rule->IsDestinationCandidate(node);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 };
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetConnectedSourcesDetector() const
 {
   auto check = [](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule)
   {
     return rule->IsSource(node);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 };
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetSourcesDetector(
   const IPropertyProvider *destination, RelationType minimalRelation) const
 {
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   auto check = [destination, minimalRelation](const mitk::IPropertyProvider *node,
                                               const mitk::PropertyRelationRuleBase *rule) {
     return rule->HasRelation(node, destination) >= minimalRelation;
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 };
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetDestinationsDetector(
   const IPropertyProvider *source, RelationType minimalRelation) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   auto check = [source, minimalRelation](const mitk::IPropertyProvider *node,
                                          const mitk::PropertyRelationRuleBase *rule) {
     return rule->HasRelation(source, node) >= minimalRelation;
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 };
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetDestinationDetector(
   const IPropertyProvider *source, RelationUIDType relationUID) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   auto relUIDs = this->GetExistingRelations(source);
   if (std::find(relUIDs.begin(), relUIDs.end(), relationUID) == relUIDs.end())
   {
     mitkThrow()
       << "Error. Passed relationUID does not identify a relation instance of the passed source for this rule instance.";
   };
 
   auto check = [source, relationUID](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule) {
     try
     {
       return rule->GetRelationUID(source, node) == relationUID;
     }
     catch(const NoPropertyRelationException &)
     {
       return false;
     }
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 };
diff --git a/Modules/ImageStatistics/files.cmake b/Modules/ImageStatistics/files.cmake
index 2744e114d5..c6b003ec03 100644
--- a/Modules/ImageStatistics/files.cmake
+++ b/Modules/ImageStatistics/files.cmake
@@ -1,37 +1,39 @@
 set(CPP_FILES
   mitkImageStatisticsCalculator.cpp
   mitkImageStatisticsContainer.cpp
   mitkPointSetStatisticsCalculator.cpp
   mitkPointSetDifferenceStatisticsCalculator.cpp
   mitkIntensityProfile.cpp
   mitkHotspotMaskGenerator.cpp
   mitkMaskGenerator.cpp
   mitkPlanarFigureMaskGenerator.cpp
   mitkMultiLabelMaskGenerator.cpp
   mitkImageMaskGenerator.cpp
   mitkHistogramStatisticsCalculator.cpp
   mitkMaskUtilities.cpp
   mitkIgnorePixelMaskGenerator.cpp
   mitkImageStatisticsPredicateHelper.cpp
+  mitkImageStatisticsContainerNodeHelper.cpp
 )
 
 set(H_FILES
   mitkImageStatisticsCalculator.h
   mitkImageStatisticsContainer.h
   mitkPointSetDifferenceStatisticsCalculator.h
   mitkPointSetStatisticsCalculator.h
   mitkExtendedStatisticsImageFilter.h
   mitkExtendedLabelStatisticsImageFilter.h
   mitkHotspotMaskGenerator.h
   mitkMaskGenerator.h
   mitkPlanarFigureMaskGenerator.h
   mitkMultiLabelMaskGenerator.h
   mitkImageMaskGenerator.h
   mitkHistogramStatisticsCalculator.h
   mitkMaskUtilities.h
   mitkitkMaskImageFilter.h
   mitkIgnorePixelMaskGenerator.h
   mitkMinMaxImageFilterWithIndex.h
   mitkMinMaxLabelmageFilterWithIndex.h
   mitkImageStatisticsPredicateHelper.h
+  mitkImageStatisticsContainerNodeHelper.h
 )
diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
index 23da99c2e5..7f171201ba 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
@@ -1,517 +1,517 @@
 
 #include <limits>
 #include <math.h>
 
 #include <itkImageToHistogramFilter.h>
 #include <itkMaskedImageToHistogramFilter.h>
 #include <itkHistogram.h>
 #include <itkExtractImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkChangeInformationImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 #include <itkMinimumMaximumImageFilter.h>
 #include <itkMaskImageFilter.h>
 #include <itkExceptionObject.h>
 
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkImage.h>
 #include <mitkHistogramStatisticsCalculator.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageToItk.h>
 #include <mitkExtendedStatisticsImageFilter.h>
 #include <mitkExtendedLabelStatisticsImageFilter.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkMinMaxImageFilterWithIndex.h>
 #include <mitkMinMaxLabelmageFilterWithIndex.h>
 #include <mitkitkMaskImageFilter.h>
 #include <mitkImageCast.h>
 
 
 
 #include <mitkMaskUtilities.h>
 
 #include "itkImageFileWriter.h"
 
 namespace mitk
 {
 
     void ImageStatisticsCalculator::SetInputImage(mitk::Image::Pointer image)
     {
         if (image != m_Image)
         {
             m_Image = image;
             m_StatisticsByTimeStep.resize(m_Image->GetTimeSteps());
             m_StatisticsUpdateTimePerTimeStep.resize(m_Image->GetTimeSteps());
             std::fill(m_StatisticsUpdateTimePerTimeStep.begin(), m_StatisticsUpdateTimePerTimeStep.end(), 0);
             this->Modified();
         }
     }
 
     void ImageStatisticsCalculator::SetMask(mitk::MaskGenerator::Pointer mask)
     {
 
         if (mask != m_MaskGenerator)
         {
             m_MaskGenerator = mask;
             this->Modified();
         }
 
     }
 
     void ImageStatisticsCalculator::SetSecondaryMask(mitk::MaskGenerator::Pointer mask)
     {
 
         if (mask != m_SecondaryMaskGenerator)
         {
             m_SecondaryMaskGenerator = mask;
             this->Modified();
         }
 
     }
 
 
     void ImageStatisticsCalculator::SetNBinsForHistogramStatistics(unsigned int nBins)
     {
         if (nBins != m_nBinsForHistogramStatistics)
         {
             m_nBinsForHistogramStatistics = nBins;
             this->Modified();
             this->m_UseBinSizeOverNBins = false;
         }
         if (m_UseBinSizeOverNBins)
         {
             this->Modified();
             this->m_UseBinSizeOverNBins = false;
         }
     }
 
     unsigned int ImageStatisticsCalculator::GetNBinsForHistogramStatistics() const
     {
         return m_nBinsForHistogramStatistics;
     }
 
     void ImageStatisticsCalculator::SetBinSizeForHistogramStatistics(double binSize)
     {
         if (binSize != m_binSizeForHistogramStatistics)
         {
             m_binSizeForHistogramStatistics = binSize;
             this->Modified();
             this->m_UseBinSizeOverNBins = true;
         }
         if (!m_UseBinSizeOverNBins)
         {
             this->Modified();
             this->m_UseBinSizeOverNBins = true;
         }
     }
 
     double ImageStatisticsCalculator::GetBinSizeForHistogramStatistics() const
     {
         return m_binSizeForHistogramStatistics;
     }
 
     mitk::StatisticsContainer::Pointer ImageStatisticsCalculator::GetStatistics(unsigned int timeStep, unsigned int label)
     {
 
         if (timeStep >= m_StatisticsByTimeStep.size())
         {
              mitkThrow() << "invalid timeStep in ImageStatisticsCalculator_v2::GetStatistics";
         }
 
         if (m_Image.IsNull())
         {
              mitkThrow() << "no image";
         }
 
         if (!m_Image->IsInitialized())
         {
           mitkThrow() << "Image not initialized!";
         }
 
         if (IsUpdateRequired(timeStep))
         {
             if (m_MaskGenerator.IsNotNull())
             {
                 m_MaskGenerator->SetTimeStep(timeStep);
                 m_InternalMask = m_MaskGenerator->GetMask();
                 if (m_MaskGenerator->GetReferenceImage().IsNotNull())
                 {
                     m_InternalImageForStatistics = m_MaskGenerator->GetReferenceImage();
                 }
                 else
                 {
                     m_InternalImageForStatistics = m_Image;
                 }
             }
             else
             {
                 m_InternalImageForStatistics = m_Image;
             }
 
             if (m_SecondaryMaskGenerator.IsNotNull())
             {
                 m_SecondaryMaskGenerator->SetTimeStep(timeStep);
                 m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
             }
 
             ImageTimeSelector::Pointer imgTimeSel = ImageTimeSelector::New();
             imgTimeSel->SetInput(m_InternalImageForStatistics);
             imgTimeSel->SetTimeNr(timeStep);
             imgTimeSel->UpdateLargestPossibleRegion();
             m_ImageTimeSlice = imgTimeSel->GetOutput();
 
 
             // Calculate statistics with/without mask
             if (m_MaskGenerator.IsNull() && m_SecondaryMaskGenerator.IsNull())
             {
                 // 1) calculate statistics unmasked:
                 AccessByItk_1(m_ImageTimeSlice, InternalCalculateStatisticsUnmasked, timeStep)
 
             }
             else
             {
                 // 2) calculate statistics masked
                 AccessByItk_1(m_ImageTimeSlice, InternalCalculateStatisticsMasked, timeStep)
             }
 
 
             //this->Modified();
         }
 
         m_StatisticsUpdateTimePerTimeStep[timeStep] = m_StatisticsByTimeStep[timeStep][m_StatisticsByTimeStep[timeStep].size()-1]->GetMTime();
 
         for (auto it = m_StatisticsByTimeStep[timeStep].begin(); it != m_StatisticsByTimeStep[timeStep].end(); ++it)
         {
             StatisticsContainer::Pointer statCont = *it;
             if (statCont->GetLabel() == label)
             {
-                return statCont->Clone();
+                return statCont;
             }
         }
 
         // these lines will ony be executed if the requested label could not be found!
         MITK_WARN << "Invalid label: " << label << " in time step: " << timeStep;
         return StatisticsContainer::New();
     }
 
     template < typename TPixel, unsigned int VImageDimension > void ImageStatisticsCalculator::InternalCalculateStatisticsUnmasked(
             typename itk::Image< TPixel, VImageDimension >* image, unsigned int timeStep)
     {
         typedef typename itk::Image< TPixel, VImageDimension > ImageType;
         typedef typename itk::ExtendedStatisticsImageFilter<ImageType> ImageStatisticsFilterType;
         typedef typename itk::MinMaxImageFilterWithIndex<ImageType> MinMaxFilterType;
 
         StatisticsContainer::Pointer statisticsResult = StatisticsContainer::New();
 
         typename ImageStatisticsFilterType::Pointer statisticsFilter = ImageStatisticsFilterType::New();
         statisticsFilter->SetInput(image);
         statisticsFilter->SetCoordinateTolerance(0.001);
         statisticsFilter->SetDirectionTolerance(0.001);
 
         // TODO: this is single threaded. Implement our own image filter that does this multi threaded
 //        typename itk::MinimumMaximumImageCalculator<ImageType>::Pointer imgMinMaxFilter = itk::MinimumMaximumImageCalculator<ImageType>::New();
 //        imgMinMaxFilter->SetImage(image);
 //        imgMinMaxFilter->Compute();
         vnl_vector<int> minIndex, maxIndex;
 
         typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
         minMaxFilter->SetInput(image);
         minMaxFilter->UpdateLargestPossibleRegion();
         typename ImageType::PixelType minval = minMaxFilter->GetMin();
         typename ImageType::PixelType maxval = minMaxFilter->GetMax();
 
         typename ImageType::IndexType tmpMinIndex = minMaxFilter->GetMinIndex();
         typename ImageType::IndexType tmpMaxIndex = minMaxFilter->GetMaxIndex();
 
 //        typename ImageType::IndexType tmpMinIndex = imgMinMaxFilter->GetIndexOfMinimum();
 //        typename ImageType::IndexType tmpMaxIndex = imgMinMaxFilter->GetIndexOfMaximum();
 
         minIndex.set_size(tmpMaxIndex.GetIndexDimension());
         maxIndex.set_size(tmpMaxIndex.GetIndexDimension());
 
         for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
         {
             minIndex[i] = tmpMinIndex[i];
             maxIndex[i] = tmpMaxIndex[i];
         }
 
         statisticsResult->SetMinIndex(minIndex);
         statisticsResult->SetMaxIndex(maxIndex);
 
         //convert m_binSize in m_nBins if necessary
         unsigned int nBinsForHistogram;
         if (m_UseBinSizeOverNBins)
         {
             nBinsForHistogram = std::max(static_cast<double>(std::ceil(maxval - minval)) / m_binSizeForHistogramStatistics, 10.); // do not allow less than 10 bins
         }
         else
         {
             nBinsForHistogram = m_nBinsForHistogramStatistics;
         }
 
         statisticsFilter->SetHistogramParameters(nBinsForHistogram, minval, maxval);
 
         try
         {
           statisticsFilter->Update();
         }
         catch (const itk::ExceptionObject& e)
         {
           mitkThrow() << "Image statistics calculation failed due to following ITK Exception: \n " << e.what();
         }
 
         auto voxelVolume = GetVoxelVolume<TPixel, VImageDimension>(image);
 
         // no mask, therefore just one label = the whole image
         m_StatisticsByTimeStep[timeStep].resize(1);
         statisticsResult->SetLabel(1);
         statisticsResult->SetN(image->GetLargestPossibleRegion().GetNumberOfPixels());
         statisticsResult->SetVolume(statisticsResult->GetN()*voxelVolume);
         statisticsResult->SetMean(statisticsFilter->GetMean());
         statisticsResult->SetMin(statisticsFilter->GetMinimum());
         statisticsResult->SetMax(statisticsFilter->GetMaximum());
         statisticsResult->SetStd(statisticsFilter->GetSigma());
         statisticsResult->SetSkewness(statisticsFilter->GetSkewness());
         statisticsResult->SetKurtosis(statisticsFilter->GetKurtosis());
         statisticsResult->SetRMS(std::sqrt(std::pow(statisticsFilter->GetMean(), 2.) + statisticsFilter->GetVariance())); // variance = sigma^2
         statisticsResult->SetMPP(statisticsFilter->GetMPP());
 
         statisticsResult->SetEntropy(statisticsFilter->GetEntropy());
         statisticsResult->SetMedian(statisticsFilter->GetMedian());
         statisticsResult->SetUniformity(statisticsFilter->GetUniformity());
         statisticsResult->SetUPP(statisticsFilter->GetUPP());
         statisticsResult->SetHistogram(statisticsFilter->GetHistogram());
 
         m_StatisticsByTimeStep[timeStep][0] = statisticsResult;
     }
 
     template < typename TPixel, unsigned int VImageDimension >
     double ImageStatisticsCalculator::GetVoxelVolume(typename itk::Image<TPixel, VImageDimension>* image) const
     {
       auto spacing = image->GetSpacing();
       double voxelVolume = 1.;
       for (unsigned int i = 0; i < image->GetImageDimension(); i++) {
         voxelVolume *= spacing[i];
       }
       return voxelVolume;
     }
 
     template < typename TPixel, unsigned int VImageDimension > void ImageStatisticsCalculator::InternalCalculateStatisticsMasked(
             typename itk::Image< TPixel, VImageDimension >* image,
             unsigned int timeStep)
     {
         typedef itk::Image< TPixel, VImageDimension > ImageType;
         typedef itk::Image< MaskPixelType, VImageDimension > MaskType;
         typedef typename MaskType::PixelType LabelPixelType;
         typedef itk::ExtendedLabelStatisticsImageFilter< ImageType, MaskType > ImageStatisticsFilterType;
         typedef MaskUtilities< TPixel, VImageDimension > MaskUtilType;
         typedef typename itk::MinMaxLabelImageFilterWithIndex<ImageType, MaskType> MinMaxLabelFilterType;
         typedef typename ImageType::PixelType InputImgPixelType;
 
         // workaround: if m_SecondaryMaskGenerator ist not null but m_MaskGenerator is! (this is the case if we request a 'ignore zuero valued pixels'
         // mask in the gui but do not define a primary mask)
         bool swapMasks = false;
         if (m_SecondaryMask.IsNotNull() && m_InternalMask.IsNull())
         {
             m_InternalMask = m_SecondaryMask;
             m_SecondaryMask = nullptr;
             swapMasks = true;
         }
 
         // maskImage has to have the same dimension as image
         typename MaskType::Pointer maskImage = MaskType::New();
         try {
             // try to access the pixel values directly (no copying or casting). Only works if mask pixels are of pixelType unsigned short
             maskImage = ImageToItkImage< MaskPixelType, VImageDimension >(m_InternalMask);
         }
         catch (const itk::ExceptionObject &)
 
         {
             // if the pixel type of the mask is not short, then we have to make a copy of m_InternalMask (and cast the values)
             CastToItkImage(m_InternalMask, maskImage);
         }
 
         // if we have a secondary mask (say a ignoreZeroPixelMask) we need to combine the masks (corresponds to AND)
         if (m_SecondaryMask.IsNotNull())
         {
             // dirty workaround for a bug when pf mask + any other mask is used in conjunction. We need a proper fix for this (Fabian Isensee is responsible and probably working on it!)
             if (m_InternalMask->GetDimension() == 2 && (m_SecondaryMask->GetDimension() == 3 || m_SecondaryMask->GetDimension() == 4))
             {
                 mitk::Image::Pointer old_img = m_SecondaryMaskGenerator->GetReferenceImage();
                 m_SecondaryMaskGenerator->SetInputImage(m_MaskGenerator->GetReferenceImage());
                 m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
                 m_SecondaryMaskGenerator->SetInputImage(old_img);
             }
             typename MaskType::Pointer secondaryMaskImage = MaskType::New();
             secondaryMaskImage = ImageToItkImage< MaskPixelType, VImageDimension >(m_SecondaryMask);
 
             // secondary mask should be a ignore zero value pixel mask derived from image. it has to be cropped to the mask region (which may be planar or simply smaller)
             typename MaskUtilities<MaskPixelType, VImageDimension>::Pointer secondaryMaskMaskUtil = MaskUtilities<MaskPixelType, VImageDimension>::New();
             secondaryMaskMaskUtil->SetImage(secondaryMaskImage.GetPointer());
             secondaryMaskMaskUtil->SetMask(maskImage.GetPointer());
             typename MaskType::Pointer adaptedSecondaryMaskImage = secondaryMaskMaskUtil->ExtractMaskImageRegion();
 
             typename itk::MaskImageFilter2<MaskType, MaskType, MaskType>::Pointer maskFilter = itk::MaskImageFilter2<MaskType, MaskType, MaskType>::New();
             maskFilter->SetInput1(maskImage);
             maskFilter->SetInput2(adaptedSecondaryMaskImage);
             maskFilter->SetMaskingValue(1); // all pixels of maskImage where secondaryMaskImage==1 will be kept, all the others are set to 0
             maskFilter->UpdateLargestPossibleRegion();
             maskImage = maskFilter->GetOutput();
         }
 
         typename MaskUtilType::Pointer maskUtil = MaskUtilType::New();
         maskUtil->SetImage(image);
         maskUtil->SetMask(maskImage.GetPointer());
 
         // if mask is smaller than image, extract the image region where the mask is
         typename ImageType::Pointer adaptedImage = ImageType::New();
 
         adaptedImage = maskUtil->ExtractMaskImageRegion(); // this also checks mask sanity
 
         // find min, max, minindex and maxindex
         typename MinMaxLabelFilterType::Pointer minMaxFilter = MinMaxLabelFilterType::New();
         minMaxFilter->SetInput(adaptedImage);
         minMaxFilter->SetLabelInput(maskImage);
         minMaxFilter->UpdateLargestPossibleRegion();
 
         // set histogram parameters for each label individually (min/max may be different for each label)
         typedef typename std::map<LabelPixelType, InputImgPixelType> MapType;
         typedef typename std::pair<LabelPixelType, InputImgPixelType> PairType;
 
         std::vector<LabelPixelType> relevantLabels = minMaxFilter->GetRelevantLabels();
         MapType minVals;
         MapType maxVals;
         std::map<LabelPixelType, unsigned int> nBins;
 
         for (LabelPixelType label:relevantLabels)
         {
             minVals.insert(PairType(label, minMaxFilter->GetMin(label)));
             maxVals.insert(PairType(label, minMaxFilter->GetMax(label)));
 
             unsigned int nBinsForHistogram;
             if (m_UseBinSizeOverNBins)
             {
                 nBinsForHistogram = std::max(static_cast<double>(std::ceil(minMaxFilter->GetMax(label) - minMaxFilter->GetMin(label))) / m_binSizeForHistogramStatistics, 10.); // do not allow less than 10 bins
             }
             else
             {
                 nBinsForHistogram = m_nBinsForHistogramStatistics;
             }
 
             nBins.insert(typename std::pair<LabelPixelType, unsigned int>(label, nBinsForHistogram));
         }
 
         typename ImageStatisticsFilterType::Pointer imageStatisticsFilter = ImageStatisticsFilterType::New();
         imageStatisticsFilter->SetDirectionTolerance(0.001);
         imageStatisticsFilter->SetCoordinateTolerance(0.001);
         imageStatisticsFilter->SetInput(adaptedImage);
         imageStatisticsFilter->SetLabelInput(maskImage);
         imageStatisticsFilter->SetHistogramParametersForLabels(nBins, minVals, maxVals);
         imageStatisticsFilter->Update();
 
         std::list<int> labels = imageStatisticsFilter->GetRelevantLabels();
         auto it = labels.begin();
         m_StatisticsByTimeStep[timeStep].resize(0);
 
         while(it != labels.end())
         {
             StatisticsContainer::Pointer statisticsResult = StatisticsContainer::New();
 
             // find min, max, minindex and maxindex
             // make sure to only look in the masked region, use a masker for this
 
             vnl_vector<int> minIndex, maxIndex;
             mitk::Point3D worldCoordinateMin;
             mitk::Point3D worldCoordinateMax;
             mitk::Point3D indexCoordinateMin;
             mitk::Point3D indexCoordinateMax;
             m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMinIndex(*it), worldCoordinateMin);
             m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMaxIndex(*it), worldCoordinateMax);
             m_Image->GetGeometry()->WorldToIndex(worldCoordinateMin, indexCoordinateMin);
             m_Image->GetGeometry()->WorldToIndex(worldCoordinateMax, indexCoordinateMax);
 
             minIndex.set_size(3);
             maxIndex.set_size(3);
 
             //for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
             for (unsigned int i=0; i < 3; i++)
             {
                 minIndex[i] = indexCoordinateMin[i];
                 maxIndex[i] = indexCoordinateMax[i];
             }
 
             statisticsResult->SetMinIndex(minIndex);
             statisticsResult->SetMaxIndex(maxIndex);
 
             assert(std::abs(minMaxFilter->GetMax(*it) - imageStatisticsFilter->GetMaximum(*it)) < mitk::eps);
             assert(std::abs(minMaxFilter->GetMin(*it) - imageStatisticsFilter->GetMinimum(*it)) < mitk::eps);
 
             auto voxelVolume = GetVoxelVolume<TPixel, VImageDimension>(image);
 
             statisticsResult->SetN(imageStatisticsFilter->GetSum(*it) / (double) imageStatisticsFilter->GetMean(*it));
             statisticsResult->SetVolume(statisticsResult->GetN()*voxelVolume);
             statisticsResult->SetMean(imageStatisticsFilter->GetMean(*it));
             statisticsResult->SetMin(imageStatisticsFilter->GetMinimum(*it));
             statisticsResult->SetMax(imageStatisticsFilter->GetMaximum(*it));
             statisticsResult->SetStd(imageStatisticsFilter->GetSigma(*it));
             statisticsResult->SetSkewness(imageStatisticsFilter->GetSkewness(*it));
             statisticsResult->SetKurtosis(imageStatisticsFilter->GetKurtosis(*it));
             statisticsResult->SetRMS(std::sqrt(std::pow(imageStatisticsFilter->GetMean(*it), 2.) + imageStatisticsFilter->GetVariance(*it))); // variance = sigma^2
             statisticsResult->SetMPP(imageStatisticsFilter->GetMPP(*it));
             statisticsResult->SetLabel(*it);
 
             statisticsResult->SetEntropy(imageStatisticsFilter->GetEntropy(*it));
             statisticsResult->SetMedian(imageStatisticsFilter->GetMedian(*it));
             statisticsResult->SetUniformity(imageStatisticsFilter->GetUniformity(*it));
             statisticsResult->SetUPP(imageStatisticsFilter->GetUPP(*it));
             statisticsResult->SetHistogram(imageStatisticsFilter->GetHistogram(*it));
 
             m_StatisticsByTimeStep[timeStep].push_back(statisticsResult);
             ++it;
         }
 
         // swap maskGenerators back
         if (swapMasks)
         {
             m_SecondaryMask = m_InternalMask;
             m_InternalMask = nullptr;
         }
     }
 
     bool ImageStatisticsCalculator::IsUpdateRequired(unsigned int timeStep) const
     {
         unsigned long thisClassTimeStamp = this->GetMTime();
         unsigned long inputImageTimeStamp = m_Image->GetMTime();
         unsigned long statisticsTimeStamp = m_StatisticsUpdateTimePerTimeStep[timeStep];
 
         if (thisClassTimeStamp > statisticsTimeStamp) // inputs have changed
         {
             return true;
         }
 
         if (inputImageTimeStamp > statisticsTimeStamp) // image has changed
         {
             return true;
         }
 
         if (m_MaskGenerator.IsNotNull())
         {
             unsigned long maskGeneratorTimeStamp = m_MaskGenerator->GetMTime();
             if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a mask generator and it has changed
             {
                 return true;
             }
         }
 
         if (m_SecondaryMaskGenerator.IsNotNull())
         {
             unsigned long maskGeneratorTimeStamp = m_SecondaryMaskGenerator->GetMTime();
             if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a secondary mask generator and it has changed
             {
                 return true;
             }
         }
 
         return false;
     }
 }
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp
new file mode 100644
index 0000000000..16a0597fa8
--- /dev/null
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp
@@ -0,0 +1,52 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+#include "mitkImageStatisticsContainerNodeHelper.h"
+
+#include <mitkProperties.h>
+#include "mitkPropertyRelations.h"
+#include "mitkGenericIDRelationRule.h"
+
+namespace mitk
+{
+  DataNode::Pointer CreateImageStatisticsNode(StatisticsContainer::Pointer statistic, const std::string& name) {
+    auto statisticsNode = mitk::DataNode::New();
+    statisticsNode->SetName(name);
+    statisticsNode->SetData(statistic);
+    statisticsNode->SetProperty("helper object", mitk::BoolProperty::New(true));
+    return statisticsNode;
+  }
+
+  void CreateNodeRelations(mitk::BaseData::Pointer statistics, mitk::BaseData::Pointer image, mitk::BaseData::Pointer mask, mitk::BaseData::Pointer planarFigure)
+  {
+    using StatisticsImageRule = mitk::GenericIDRelationRule;
+    using StatisticsMaskImageRule = mitk::GenericIDRelationRule;
+    using StatisticsPlanarFigureRule = mitk::GenericIDRelationRule;
+
+    auto ruleImage = StatisticsImageRule::New("ruleStatisticsToImage");
+    ruleImage->Connect(statistics, image);
+
+    if (mask) {
+      auto ruleMask = StatisticsMaskImageRule::New("ruleStatisticsToMask");
+      ruleMask->Connect(statistics, mask);
+    }
+    if (planarFigure) {
+      auto rulePlanarFigure = StatisticsPlanarFigureRule::New("ruleStatisticsToPlanarFigure");
+      rulePlanarFigure->Connect(statistics, planarFigure);
+    }
+  }
+
+
+}
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h
new file mode 100644
index 0000000000..0979c303c5
--- /dev/null
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h
@@ -0,0 +1,31 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef MITKIMAGESTATISTICSCONTAINERNODEHELPER
+#define MITKIMAGESTATISTICSCONTAINERNODEHELPER
+
+#include <MitkImageStatisticsExports.h>
+
+#include <mitkImageStatisticsContainer.h>
+#include <mitkDataNode.h>
+
+namespace mitk
+{
+  MITKIMAGESTATISTICS_EXPORT DataNode::Pointer CreateImageStatisticsNode(StatisticsContainer::Pointer statistic, const std::string& name = "statistics");
+  MITKIMAGESTATISTICS_EXPORT void CreateNodeRelations(mitk::BaseData::Pointer statistics, mitk::BaseData::Pointer image, mitk::BaseData::Pointer mask, mitk::BaseData::Pointer planarFigure);
+}
+#endif // MITKIMAGESTATISTICSCONTAINERNODEHELPER
+
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
index dee84afe51..e6251c3754 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
@@ -1,236 +1,246 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkImageStatisticsCalculationJob.h"
 
 //QT headers
 #include <QMessageBox>
 #include <QApplication>
 #include <mitkImageMaskGenerator.h>
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkIgnorePixelMaskGenerator.h>
 
 QmitkImageStatisticsCalculationJob::QmitkImageStatisticsCalculationJob()
   : QThread()
   , m_StatisticsImage(nullptr)
   , m_BinaryMask(nullptr)
   , m_PlanarFigureMask(nullptr)
   , m_TimeStep(0)
   , m_IgnoreZeros(false)
   , m_HistogramNBins(100)
   , m_StatisticChanged(false)
   , m_CalculationSuccessful(false)
 {
 }
 
 QmitkImageStatisticsCalculationJob::~QmitkImageStatisticsCalculationJob()
 {
 }
 
 void QmitkImageStatisticsCalculationJob::Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer planarFig )
 {
   // reset old values
   if( this->m_StatisticsImage.IsNotNull() )
     this->m_StatisticsImage = nullptr;
   if( this->m_BinaryMask.IsNotNull() )
     this->m_BinaryMask = nullptr;
   if( this->m_PlanarFigureMask.IsNotNull())
     this->m_PlanarFigureMask = nullptr;
 
   // set new values if passed in
   if(image.IsNotNull())
     this->m_StatisticsImage = image->Clone();
   if(binaryImage.IsNotNull())
     this->m_BinaryMask = binaryImage->Clone();
   if(planarFig.IsNotNull())
     this->m_PlanarFigureMask = planarFig->Clone();
 }
 
 void QmitkImageStatisticsCalculationJob::SetTimeStep( int times )
 {
   this->m_TimeStep = times;
 }
 
-int QmitkImageStatisticsCalculationJob::GetTimeStep()
+int QmitkImageStatisticsCalculationJob::GetTimeStep() const
 {
   return this->m_TimeStep;
 }
 
-std::vector<mitk::StatisticsContainer::ConstPointer> QmitkImageStatisticsCalculationJob::GetStatisticsData()
+std::vector<mitk::StatisticsContainer::ConstPointer> QmitkImageStatisticsCalculationJob::GetStatisticsData() const
 {
   return this->m_StatisticsVector;
 }
 
-mitk::Image::Pointer QmitkImageStatisticsCalculationJob::GetStatisticsImage()
+mitk::Image::Pointer QmitkImageStatisticsCalculationJob::GetStatisticsImage() const
 {
   return this->m_StatisticsImage;
 }
 
+mitk::Image::Pointer QmitkImageStatisticsCalculationJob::GetMaskImage() const
+{
+  return this->m_BinaryMask;
+}
+
+mitk::PlanarFigure::Pointer QmitkImageStatisticsCalculationJob::GetPlanarFigure() const
+{
+  return this->m_PlanarFigureMask;
+}
+
 void QmitkImageStatisticsCalculationJob::SetIgnoreZeroValueVoxel(bool _arg)
 {
   this->m_IgnoreZeros = _arg;
 }
 
-bool QmitkImageStatisticsCalculationJob::GetIgnoreZeroValueVoxel()
+bool QmitkImageStatisticsCalculationJob::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeros;
 }
 
 void QmitkImageStatisticsCalculationJob::SetHistogramNBins(unsigned int nbins)
 {
   this->m_HistogramNBins = nbins;
 }
 
 unsigned int QmitkImageStatisticsCalculationJob::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
-std::string QmitkImageStatisticsCalculationJob::GetLastErrorMessage()
+std::string QmitkImageStatisticsCalculationJob::GetLastErrorMessage() const
 {
   return m_message;
 }
 
 QmitkImageStatisticsCalculationJob::HistogramType::ConstPointer
-QmitkImageStatisticsCalculationJob::GetTimeStepHistogram(unsigned int t)
+QmitkImageStatisticsCalculationJob::GetTimeStepHistogram(unsigned int t) const
 {
   if (t >= this->m_HistogramVector.size())
     return nullptr;
 
   return this->m_HistogramVector[t];
 }
 
-bool QmitkImageStatisticsCalculationJob::GetStatisticsChangedFlag()
+bool QmitkImageStatisticsCalculationJob::GetStatisticsChangedFlag() const
 {
   return m_StatisticChanged;
 }
 
-bool QmitkImageStatisticsCalculationJob::GetStatisticsUpdateSuccessFlag()
+bool QmitkImageStatisticsCalculationJob::GetStatisticsUpdateSuccessFlag() const
 {
   return m_CalculationSuccessful;
 }
 
 void QmitkImageStatisticsCalculationJob::run()
 {
   bool statisticCalculationSuccessful = true;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
 
   if(this->m_StatisticsImage.IsNotNull())
   {
     calculator->SetInputImage(m_StatisticsImage);
   }
   else
   {
     statisticCalculationSuccessful = false;
   }
 
   // Bug 13416 : The ImageStatistics::SetImageMask() method can throw exceptions, i.e. when the dimensionality
   // of the masked and input image differ, we need to catch them and mark the calculation as failed
   // the same holds for the ::SetPlanarFigure()
   try
   {
     if(this->m_BinaryMask.IsNotNull())
     {
       mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
       imgMask->SetImageMask(m_BinaryMask);
       calculator->SetMask(imgMask.GetPointer());
     }
     if(this->m_PlanarFigureMask.IsNotNull())
     {
       mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
       pfMaskGen->SetInputImage(m_StatisticsImage);
       pfMaskGen->SetPlanarFigure(m_PlanarFigureMask);
       calculator->SetMask(pfMaskGen.GetPointer());
     }
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "MITK Exception: " << e.what();
     statisticCalculationSuccessful = false;
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_ERROR << "ITK Exception:" << e.what();
     statisticCalculationSuccessful = false;
   }
   catch ( const std::runtime_error &e )
   {
     MITK_ERROR<< "Runtime Exception: " << e.what();
     statisticCalculationSuccessful = false;
   }
   catch ( const std::exception &e )
   {
     MITK_ERROR<< "Standard Exception: " << e.what();
     statisticCalculationSuccessful = false;
   }
 
   bool statisticChanged = false;
 
   if (this->m_IgnoreZeros)
   {
       mitk::IgnorePixelMaskGenerator::Pointer ignorePixelValueMaskGen = mitk::IgnorePixelMaskGenerator::New();
       ignorePixelValueMaskGen->SetIgnoredPixelValue(0);
       ignorePixelValueMaskGen->SetInputImage(m_StatisticsImage);
       calculator->SetSecondaryMask(ignorePixelValueMaskGen.GetPointer());
   }
   else
   {
       calculator->SetSecondaryMask(nullptr);
   }
 
   calculator->SetNBinsForHistogramStatistics(m_HistogramNBins);
 
   for (unsigned int i = 0; i < m_StatisticsImage->GetTimeSteps(); i++)
   {
     try
     {
       calculator->GetStatistics(i);
     }
     catch ( mitk::Exception& e)
     {
       //m_message = e.GetDescription();
       MITK_ERROR<< "MITK Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
     catch ( const std::runtime_error &e )
     {
       //m_message = "Failure: " + std::string(e.what());
       MITK_ERROR<< "Runtime Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
     catch ( const std::exception &e )
     {
       //m_message = "Failure: " + std::string(e.what());
       MITK_ERROR<< "Standard Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
   }
 
   this->m_StatisticChanged = statisticChanged;
   this->m_CalculationSuccessful = statisticCalculationSuccessful;
 
   if(statisticCalculationSuccessful)
   {
     this->m_StatisticsVector.clear();
     this->m_HistogramVector.clear();
 
     for (unsigned int i = 0; i < m_StatisticsImage->GetTimeSteps(); i++)
     {
       this->m_StatisticsVector.push_back(calculator->GetStatistics(i).GetPointer());
       this->m_HistogramVector.push_back((HistogramType*)this->m_StatisticsVector[i]->GetHistogram().GetPointer());
     }
   }
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h
index 898e311af1..9721c7d1cc 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h
@@ -1,112 +1,114 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef QMITKIMAGESTATISTICSCALCULATIONTHREAD_H_INCLUDED
 #define QMITKIMAGESTATISTICSCALCULATIONTHREAD_H_INCLUDED
 
 //QT headers
 #include <QThread>
 #include <QEvent>
 
 //mitk headers
 #include "mitkImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkImageStatisticsCalculator.h"
 #include <MitkImageStatisticsUIExports.h>
 
 // itk headers
 #ifndef __itkHistogram_h
 #include <itkHistogram.h>
 #endif
 
 
 /** /brief This class is executed as background thread for image statistics calculation.
   * Documentation: This class is derived from QThread and is intended to be used by QmitkImageStatisticsView
                    to run the image statistics calculation in a background thread keepung the gui usable.
   */
 
 class MITKIMAGESTATISTICSUI_EXPORT QmitkImageStatisticsCalculationJob : public QThread
 {
   Q_OBJECT
 
 public:
 
   typedef itk::Statistics::Histogram<double> HistogramType;
 
   /*!
   /brief standard constructor. */
   QmitkImageStatisticsCalculationJob();
   /*!
   /brief standard destructor. */
   ~QmitkImageStatisticsCalculationJob();
 
   /*!
   /brief Initializes the object with necessary data. */
   void Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer planarFig );
   /*!
   /brief returns the calculated image statistics. */
-  std::vector<mitk::StatisticsContainer::ConstPointer> GetStatisticsData();
-  /*!
-  /brief */
-  mitk::Image::Pointer GetStatisticsImage();
+  std::vector<mitk::StatisticsContainer::ConstPointer> GetStatisticsData() const;
+
+  mitk::Image::Pointer GetStatisticsImage() const;
+  mitk::Image::Pointer GetMaskImage() const;
+  mitk::PlanarFigure::Pointer GetPlanarFigure() const;
+
   /*!
   /brief Set the time step of the image you want to process. */
   void SetTimeStep( int times );
   /*!
   /brief Get the time step of the image you want to process. */
-  int GetTimeStep();
+  int GetTimeStep() const;
   /*!
   /brief Set flag to ignore zero valued voxels */
   void SetIgnoreZeroValueVoxel( bool _arg );
   /*!
   /brief Get status of zero value voxel ignoring. */
-  bool GetIgnoreZeroValueVoxel();
+  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;
   /*!
   /brief Returns the histogram of the currently selected time step. */
-  HistogramType::ConstPointer GetTimeStepHistogram(unsigned int t = 0);
+  HistogramType::ConstPointer GetTimeStepHistogram(unsigned int t = 0) const;
   /*!
   /brief Returns a flag indicating if the statistics have changed during calculation */
-  bool GetStatisticsChangedFlag();
+  bool GetStatisticsChangedFlag() const;
   /*!
   /brief Returns a flag the indicates if the statistics are updated successfully */
-  bool GetStatisticsUpdateSuccessFlag();
+  bool GetStatisticsUpdateSuccessFlag() const;
   /*!
   /brief Method called once the thread is executed. */
   void run() override;
 
-  std::string GetLastErrorMessage();
+  std::string GetLastErrorMessage() const;
 
 private:
   //member declaration
 
   mitk::Image::Pointer m_StatisticsImage;                         ///< member variable holds the input image for which the statistics need to be calculated.
   mitk::Image::Pointer m_BinaryMask;                              ///< member variable holds the binary mask image for segmentation image statistics calculation.
   mitk::PlanarFigure::Pointer m_PlanarFigureMask;                 ///< member variable holds the planar figure for segmentation image statistics calculation.
   std::vector<mitk::StatisticsContainer::ConstPointer> m_StatisticsVector; ///< member variable holds the result structs.
   int m_TimeStep;                                                 ///< member variable holds the time step for statistics calculation
   bool m_IgnoreZeros;                                             ///< member variable holds flag to indicate if zero valued voxel should be suppressed
   unsigned int m_HistogramNBins;                                      ///< member variable holds the bin size for histogram resolution.
   bool m_StatisticChanged;                                        ///< flag set if statistics have changed
   bool m_CalculationSuccessful;                                   ///< flag set if statistics calculation was successful
   std::vector<HistogramType::ConstPointer> m_HistogramVector;          ///< member holds the histograms of all time steps.
   std::string m_message;
 };
 #endif // QMITKIMAGESTATISTICSCALCULATIONTHREAD_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
index bdb15cd89a..1fe3d06cf0 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
@@ -1,280 +1,292 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkImageStatisticsReloadedView.h"
 
+#include <utility>
+
 // berry includes
 #include <berryWorkbenchPlugin.h>
 #include <berryIQtStyleManager.h>
 
 #include <QmitkChartWidget.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkStatusBar.h>
 #include <mitkIntensityProfile.h>
 #include <mitkImageStatisticsPredicateHelper.h>
+#include <mitkImageStatisticsContainerNodeHelper.h>
+#include <mitkNodePredicateAnd.h>
 
 #include <mitkPlanarFigureInteractor.h>
 
 const std::string QmitkImageStatisticsReloadedView::VIEW_ID = "org.mitk.views.imagestatisticsReloaded";
 
 QmitkImageStatisticsReloadedView::QmitkImageStatisticsReloadedView(QObject* /*parent*/, const char* /*name*/)
 {
   this->m_CalculationThread = new QmitkImageStatisticsCalculationJob();
 }
 
 QmitkImageStatisticsReloadedView::~QmitkImageStatisticsReloadedView()
 {
   if (m_selectedPlanarFigure)
     m_selectedPlanarFigure->RemoveObserver(m_PlanarFigureObserverTag);
 }
 
 void QmitkImageStatisticsReloadedView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_intensityProfile->SetTheme(this->GetColorTheme());
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.groupBox_intensityProfile->setVisible(false);
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
   PrepareDataStorageComboBoxes();
   CreateConnections();
 }
 
 void QmitkImageStatisticsReloadedView::CreateConnections()
 {
   connect(this->m_CalculationThread, &QmitkImageStatisticsCalculationJob::finished, this, &QmitkImageStatisticsReloadedView::OnStatisticsCalculationEnds, Qt::QueuedConnection);
 }
 
 void QmitkImageStatisticsReloadedView::PartClosed(const berry::IWorkbenchPartReference::Pointer& )
 {
 }
 
 void QmitkImageStatisticsReloadedView::FillStatisticsWidget(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics)
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->SetStatistics(statistics);
   m_Controls.widget_statistics->SetImageNodes({ m_selectedImageNode });
   if (m_selectedMaskNode) {
     m_Controls.widget_statistics->SetMaskNodes({ m_selectedMaskNode });
   }
   m_Controls.widget_statistics->setEnabled(true);
 }
 
 void QmitkImageStatisticsReloadedView::FillHistogramWidget(const std::vector<HistogramType::ConstPointer>& histogram, const std::vector<std::string>& dataLabels)
 {
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->SetHistogram(histogram.front(), dataLabels.front());
   connect(m_Controls.widget_histogram, &QmitkHistogramVisualizationWidget::RequestHistogramUpdate, this, &QmitkImageStatisticsReloadedView::OnRequestHistogramUpdate);
 }
 
 QmitkChartWidget::ChartStyle QmitkImageStatisticsReloadedView::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::ChartStyle::darkstyle;
     }
     else {
       return QmitkChartWidget::ChartStyle::lightstyle;
     }
   }
   return QmitkChartWidget::ChartStyle::darkstyle;
 }
 
 void QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged()
 {
   if (this->m_selectedPlanarFigure)
   {
     this->m_selectedPlanarFigure->RemoveObserver(this->m_PlanarFigureObserverTag);
     this->m_selectedPlanarFigure = nullptr;
   }
 
   m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
   m_selectedMaskNode = m_Controls.maskImageSelector->GetSelectedNode();
 
   m_Controls.groupBox_intensityProfile->setVisible(false);
 
   if (m_selectedImageNode != nullptr) {
     auto image = dynamic_cast<mitk::Image*>(m_selectedImageNode->GetData());
     mitk::Image::Pointer mask = nullptr;
     mitk::PlanarFigure::Pointer maskPlanarFigure = nullptr;
     if (m_selectedMaskNode != nullptr) {
       mask = dynamic_cast<mitk::Image*>(m_selectedMaskNode->GetData());
       if (mask == nullptr) {
         maskPlanarFigure = dynamic_cast<mitk::PlanarFigure*>(m_selectedMaskNode->GetData());
       }
     }
     if (mask) {
       //compute statistics with given mask
       CalculateStatistics(image, mask);
     }
     else if (maskPlanarFigure) {
       m_selectedPlanarFigure = maskPlanarFigure;
       ITKCommandType::Pointer changeListener = ITKCommandType::New();
       changeListener->SetCallbackFunction(this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
       this->m_PlanarFigureObserverTag =
         m_selectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
       if (!maskPlanarFigure->IsClosed()) {
         //compute line profile and display statistics for voxels on line
         auto intensityProfile = mitk::ComputeIntensityProfile(image, maskPlanarFigure);
         //Don't show histogram for intensity profiles
         m_Controls.groupBox_histogram->setVisible(false);
         m_Controls.groupBox_intensityProfile->setVisible(true);
         m_Controls.widget_intensityProfile->Reset();
         m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile.GetPointer(), "Intensity Profile of " + m_selectedImageNode->GetName());
       }
       //for all planar figures: compute statistics with planarFigure as mask
       CalculateStatistics(image, maskPlanarFigure);
     }
     else {
       //compute statistics with image only
       CalculateStatistics(image);
     }
   }
   else {
     ResetGUI();
   }
 }
 
 void QmitkImageStatisticsReloadedView::ResetGUI()
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->setEnabled(false);
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->setEnabled(false);
 }
 
 void QmitkImageStatisticsReloadedView::OnStatisticsCalculationEnds()
 {
   mitk::StatusBar::GetInstance()->Clear();
 
   if (this->m_CalculationThread->GetStatisticsUpdateSuccessFlag()) {
-    this->FillStatisticsWidget(m_CalculationThread->GetStatisticsData());
+    auto statistics = m_CalculationThread->GetStatisticsData();
+    for (auto& statistic : statistics) {
+      auto statisticNonConst = statistic->Clone();
+      auto statisticsNode = mitk::CreateImageStatisticsNode(statisticNonConst);
+      CreateNodeRelations(statisticNonConst.GetPointer(), m_CalculationThread->GetStatisticsImage().GetPointer(), m_CalculationThread->GetMaskImage().GetPointer(), m_CalculationThread->GetPlanarFigure().GetPointer());
+      this->GetDataStorage()->Add(statisticsNode);
+    }
+
+    this->FillStatisticsWidget(statistics);
     if (!m_selectedPlanarFigure || m_selectedPlanarFigure->IsClosed()) {
       this->FillHistogramWidget({ m_CalculationThread->GetTimeStepHistogram() }, { m_selectedImageNode->GetName() });
     }
   }
   else {
     mitk::StatusBar::GetInstance()->DisplayErrorText(m_CalculationThread->GetLastErrorMessage().c_str());
     m_Controls.widget_histogram->setEnabled(false);
     m_Controls.widget_statistics->setEnabled(false);
   }
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
 }
 
 void QmitkImageStatisticsReloadedView::OnRequestHistogramUpdate(unsigned int nBins)
 {
   m_CalculationThread->SetHistogramNBins(nBins);
   m_CalculationThread->start();
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::Image::Pointer mask)
 {
   CalculateStatisticsInternal(image, mask);
 
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::PlanarFigure::Pointer mask) {
   CalculateStatisticsInternal(image, nullptr, mask);
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatisticsInternal(mitk::Image::Pointer image, mitk::Image::Pointer mask, mitk::PlanarFigure::Pointer maskPlanarFigure)
 {
   this->m_StatisticsUpdatePending = true;
   this->m_CalculationThread->Initialize(image, mask, maskPlanarFigure);
 
   try
   {
     // Compute statistics
     this->m_CalculationThread->start();
     m_Controls.label_currentlyComputingStatistics->setVisible(true);
   }
   catch (const mitk::Exception& e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.GetDescription());
     this->m_StatisticsUpdatePending = false;
     m_Controls.label_currentlyComputingStatistics->setVisible(false);
   }
   catch (const std::runtime_error &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
     this->m_StatisticsUpdatePending = false;
     m_Controls.label_currentlyComputingStatistics->setVisible(false);
   }
   catch (const std::exception &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
     this->m_StatisticsUpdatePending = false;
     m_Controls.label_currentlyComputingStatistics->setVisible(false);
   }
 }
 
 void QmitkImageStatisticsReloadedView::OnSelectionChanged( berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes )
 {
     Q_UNUSED(part);
     Q_UNUSED(nodes);
 }
 
 void QmitkImageStatisticsReloadedView::PrepareDataStorageComboBoxes()
 {
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isImagePredicate = mitk::GetImageStatisticsImagePredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
 
   m_Controls.imageSelector->SetDataStorage(GetDataStorage());
   m_Controls.imageSelector->SetPredicate(isImagePredicate);
 
   m_Controls.maskImageSelector->SetDataStorage(GetDataStorage());
   m_Controls.maskImageSelector->SetPredicate(isMaskOrPlanarFigurePredicate);
   m_Controls.maskImageSelector->SetZeroEntryText("<none>");
 }
 
 void QmitkImageStatisticsReloadedView::Activated()
 {
 }
 
 void QmitkImageStatisticsReloadedView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsReloadedView::Visible()
 {
   connect(m_Controls.imageSelector, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
   connect(m_Controls.maskImageSelector, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
   m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
   if (m_selectedImageNode) {
     OnImageOrMaskSelectorChanged();
   }
   else {
     ResetGUI();
   }
 }
 
 void QmitkImageStatisticsReloadedView::Hidden()
 {
   m_Controls.imageSelector->disconnect();
   m_Controls.maskImageSelector->disconnect();
 }
 
 void QmitkImageStatisticsReloadedView::SetFocus()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h
index cb9dc9babf..d3947c35ed 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h
@@ -1,106 +1,108 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkImageStatisticsReloadedView_H__INCLUDED
 #define QmitkImageStatisticsReloadedView_H__INCLUDED
 
 #include "ui_QmitkImageStatisticsReloadedViewControls.h"
 
 // Qmitk includes
 #include <QmitkAbstractView.h>
 #include <QmitkImageStatisticsCalculationJob.h>
 #include <mitkImageStatisticsContainer.h>
 
 #include <mitkILifecycleAwarePart.h>
 #include <berryIPartListener.h>
+#include <mitkPropertyRelations.h>
 
 /*!
 \brief QmitkImageStatisticsView is a bundle that allows statistics calculation from images. Three modes
 are supported: 1. Statistics of one image, 2. Statistics of an image and a segmentation, 3. Statistics
 of an image and a Planar Figure. The statistics calculation is realized in a separate thread to keep the
 gui accessible during calculation.
 
 \ingroup Plugins/org.mitk.gui.qt.measurementtoolbox
 */
 class QmitkImageStatisticsReloadedView : public QmitkAbstractView, public mitk::ILifecycleAwarePart, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
   using HistogramType = mitk::StatisticsContainer::HistogramType;
+
   /*!
   \brief default constructor */
   QmitkImageStatisticsReloadedView(QObject *parent = nullptr, const char *name = nullptr);
   /*!
   \brief default destructor */
   virtual ~QmitkImageStatisticsReloadedView();
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc. */
   virtual void CreateQtPartControl(QWidget *parent) override;
   /*!
   \brief method for creating the connections of main and control widget */
   virtual void CreateConnections();
   /*!
   \brief  Is called from the selection mechanism once the data manager selection has changed*/
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &selectedNodes) override;
 
   void PrepareDataStorageComboBoxes();
 
   static const std::string VIEW_ID;
 
   void FillStatisticsWidget(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics);
   void FillHistogramWidget(const std::vector<HistogramType::ConstPointer>& histogram, const std::vector<std::string>& dataLabels);
   QmitkChartWidget::ChartStyle GetColorTheme() const;
 protected:
   virtual void Activated() override;
   virtual void Deactivated() override;
   virtual void Visible() override;
   virtual void Hidden() override;
 
   virtual void SetFocus() override;
 
   /** \brief Is called right before the view closes (before the destructor) */
   virtual void PartClosed(const berry::IWorkbenchPartReference::Pointer&) override;
  
   /** \brief Required for berry::IPartListener */
   virtual Events::Types GetPartEventTypes() const override { return Events::CLOSED; }
 
   void OnImageOrMaskSelectorChanged();
 
   void ResetGUI();
 
   void OnStatisticsCalculationEnds();
   void OnRequestHistogramUpdate(unsigned int nBins);
 
   void CalculateStatistics(mitk::Image::Pointer image, mitk::Image::Pointer mask=nullptr);
   void CalculateStatistics(mitk::Image::Pointer image, mitk::PlanarFigure::Pointer mask);
 
   void CalculateStatisticsInternal(mitk::Image::Pointer image, mitk::Image::Pointer mask=nullptr, mitk::PlanarFigure::Pointer maskPlanarFigure=nullptr);
 
   // member variables
   Ui::QmitkImageStatisticsReloadedViewControls m_Controls;
 
 private:
   typedef itk::SimpleMemberCommand< QmitkImageStatisticsReloadedView > ITKCommandType;
-  QmitkImageStatisticsCalculationJob * m_CalculationThread;
+  QmitkImageStatisticsCalculationJob * m_CalculationThread = nullptr;
   bool m_StatisticsUpdatePending=false;
-  mitk::DataNode::ConstPointer m_selectedImageNode, m_selectedMaskNode;
+  mitk::DataNode::ConstPointer m_selectedImageNode = nullptr, m_selectedMaskNode = nullptr;
 
+  mitk::PropertyRelations::RuleResultVectorType m_statisticContainerRules;
   mitk::PlanarFigure::Pointer m_selectedPlanarFigure=nullptr;
   long m_PlanarFigureObserverTag;
- 
 };
 #endif // QmitkImageStatisticsView_H__INCLUDED