diff --git a/Modules/ImageStatistics/Testing/files.cmake b/Modules/ImageStatistics/Testing/files.cmake
index 41431d2af0..2be45c6a95 100644
--- a/Modules/ImageStatistics/Testing/files.cmake
+++ b/Modules/ImageStatistics/Testing/files.cmake
@@ -1,11 +1,12 @@
 set(MODULE_TESTS
   mitkImageStatisticsCalculatorTest.cpp
   mitkPointSetStatisticsCalculatorTest.cpp
   mitkPointSetDifferenceStatisticsCalculatorTest.cpp
   mitkImageStatisticsTextureAnalysisTest.cpp
+  mitkImageStatisticsContainerManagerTest.cpp
 )
 
 set(MODULE_CUSTOM_TESTS
   mitkImageStatisticsHotspotTest.cpp
 #  mitkMultiGaussianTest.cpp # TODO: activate test to generate new test cases for mitkImageStatisticsHotspotTest
 )
diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp
new file mode 100644
index 0000000000..0765d5b286
--- /dev/null
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp
@@ -0,0 +1,347 @@
+/*===================================================================
+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.
+===================================================================*/
+// Testing
+#include "mitkTestingMacros.h"
+#include "mitkTestFixture.h"
+
+//MITK includes
+#include <mitkIOUtil.h>
+#include <mitkImageStatisticsContainerManager.h>
+#include <mitkDataStorage.h>
+#include <mitkStandaloneDataStorage.h>
+#include <mitkImageStatisticsContainer.h>
+#include <mitkPlanarCircle.h>
+#include <mitkImageStatisticsContainerNodeHelper.h>
+
+class mitkImageStatisticsContainerManagerTestSuite : public mitk::TestFixture
+{
+	CPPUNIT_TEST_SUITE(mitkImageStatisticsContainerManagerTestSuite);
+  MITK_TEST(SetDataStorageNull);
+  MITK_TEST(SetDataStorage);
+  MITK_TEST(GetImageStatisticsNoRules);
+	MITK_TEST(GetImageStatisticsWithImageConnected);
+  MITK_TEST(GetImageStatisticsWithImageNotConnected);
+	MITK_TEST(GetImageStatisticsWithImageAndMaskConnected);
+  MITK_TEST(GetImageStatisticsWithImageAndMaskNotConnected);
+	MITK_TEST(GetImageStatisticsWithImageAndPlanarFigureConnected);
+  MITK_TEST(GetImageStatisticsWithImageAndPlanarFigureNotConnected);
+	MITK_TEST(GetImageStatisticsInvalid);
+	CPPUNIT_TEST_SUITE_END();
+
+private:
+  mitk::ImageStatisticsContainerManager::Pointer m_manager;
+  mitk::StatisticsContainer::Pointer m_statisticsContainer, m_statisticsContainer2, m_statisticsContainer3;
+  mitk::Image::Pointer m_image, m_image2;
+  mitk::Image::Pointer m_mask, m_mask2;
+  mitk::PlanarFigure::Pointer m_planarFigure, m_planarFigure2;
+
+public:
+	void setUp() override
+	{
+    m_manager = mitk::ImageStatisticsContainerManager::New();
+    m_statisticsContainer = mitk::StatisticsContainer::New();
+    m_statisticsContainer2 = mitk::StatisticsContainer::New();
+    m_statisticsContainer3 = mitk::StatisticsContainer::New();
+    m_image = mitk::Image::New();
+    m_image2 = mitk::Image::New();
+    m_mask = mitk::Image::New();
+    m_mask2 = mitk::Image::New();
+    m_planarFigure = mitk::PlanarCircle::New().GetPointer();
+    m_planarFigure2 = mitk::PlanarCircle::New().GetPointer();
+	}
+
+	void tearDown() override
+	{
+	}
+
+	void SetDataStorageNull()
+	{
+    CPPUNIT_ASSERT_THROW(m_manager->SetDataStorage(nullptr), mitk::Exception);
+	}
+	
+	void SetDataStorage()
+  {
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    CPPUNIT_ASSERT_NO_THROW(m_manager->SetDataStorage(standaloneDataStorage.GetPointer()));
+	}
+
+  void GetImageStatisticsNoRules() {
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+
+    //no rules + 1 image --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer emptyStatistic;
+    CPPUNIT_ASSERT_NO_THROW(emptyStatistic = m_manager->GetImageStatistics(m_image.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
+
+    //no rules + 1 image + 1 mask --> test return nullptr
+    CPPUNIT_ASSERT_NO_THROW(emptyStatistic = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
+
+    //no rules + 1 image + 1 planarFigure --> test return nullptr
+    CPPUNIT_ASSERT_NO_THROW(emptyStatistic = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
+  }
+	
+	void GetImageStatisticsWithImageConnected()
+	{
+    //create rules connection
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+
+    //rule: (image-->statistics), 1 connected image --> test return image statistics
+    m_manager->SetRules({ rules });
+    mitk::StatisticsContainer::ConstPointer statisticsWithImage;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImage->GetUID(), m_statisticsContainer->GetUID());
+    
+    //new rule: (image-->statistics2 AND mask --> statistics2)
+    mitk::PropertyRelations::RuleResultVectorType rules2;
+    imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
+    auto imageMaskRule = mitk::CreateNodeRelationMask(m_statisticsContainer2.GetPointer(), m_mask.GetPointer());
+    rules2.push_back(imageRule.GetPointer());
+    rules2.push_back(imageMaskRule.GetPointer());
+    m_manager->SetRules({ rules2, rules });
+
+    auto statisticsNode2 = mitk::CreateImageStatisticsNode(m_statisticsContainer2, "testStatistics2");
+    standaloneDataStorage->Add(statisticsNode2);
+
+    //--> test return (still) image statistics (!= statistics2)
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAgain;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAgain = m_manager->GetImageStatistics(m_image.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID(), m_statisticsContainer->GetUID());
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID()!= m_statisticsContainer2->GetUID(), true);
+
+    //new rule: (image-->statistics3 AND planarFigure --> statistics3)
+    mitk::PropertyRelations::RuleResultVectorType rules3;
+    imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer3.GetPointer(), m_image.GetPointer());
+    auto imagePlanarFigureRule = mitk::CreateNodeRelationMask(m_statisticsContainer3.GetPointer(), m_planarFigure.GetPointer());
+    rules3.push_back(imageRule.GetPointer());
+    rules3.push_back(imagePlanarFigureRule.GetPointer());
+    m_manager->SetRules({ rules3, rules2, rules });
+
+    auto statisticsNode3 = mitk::CreateImageStatisticsNode(m_statisticsContainer3, "testStatistics3");
+    standaloneDataStorage->Add(statisticsNode3);
+
+    //--> test return (still) image statistics (!= statistics3)
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAgain = m_manager->GetImageStatistics(m_image.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID(), m_statisticsContainer->GetUID());
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID() != m_statisticsContainer3->GetUID(), true);
+	}
+
+  void GetImageStatisticsWithImageNotConnected() {
+    //create rules connection
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+    m_manager->SetRules({ rules });
+
+    //rule: (image-->statistics), 1 unconnected image --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImage;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image2.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
+
+    //rule: (image-->statistics), 1 connected image + 1 unconnected mask --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMask;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMask = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMask.IsNull(), true);
+
+    //rule: (image-->statistics), 1 connected image + 1 unconnected planar figure --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigure;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigure = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigure.IsNull(), true);
+  }
+	
+	void GetImageStatisticsWithImageAndMaskConnected()
+	{
+    //create rules connection + add statistics to dataStorage
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto maskRule = mitk::CreateNodeRelationMask(m_statisticsContainer.GetPointer(), m_mask.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    rules.push_back(maskRule.GetPointer());
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+    m_manager->SetRules({ rules });
+    
+    //rule: (image-->statistics, mask-->statistics), 1 connected image, 1 connected mask --> test return statistics
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMask;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMask = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMask.IsNull(),false);
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMask->GetUID(), m_statisticsContainer->GetUID());
+    
+    //new rule: (image-->statistics2)
+    mitk::PropertyRelations::RuleResultVectorType rules2;
+    imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
+    rules2.push_back(imageRule.GetPointer());
+    m_manager->SetRules({ rules2, rules });
+
+    auto statisticsNode2 = mitk::CreateImageStatisticsNode(m_statisticsContainer2, "testStatistics2");
+    standaloneDataStorage->Add(statisticsNode2);
+
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMaskAgain;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskAgain = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskAgain->GetUID(), m_statisticsContainer->GetUID());
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskAgain->GetUID() != m_statisticsContainer2->GetUID(), true);
+	}
+
+  void GetImageStatisticsWithImageAndMaskNotConnected()
+  {
+    //create rules connection + add statistics to dataStorage
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto maskRule = mitk::CreateNodeRelationMask(m_statisticsContainer.GetPointer(), m_mask.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    rules.push_back(maskRule.GetPointer());
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+
+    //rule: (image-->statistics, mask-->statistics), 1 connected image --> test return nullptr
+    m_manager->SetRules({ rules });
+    mitk::StatisticsContainer::ConstPointer statisticsWithImage;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected mask --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndMaskNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageNotConnectedAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask2.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageNotConnectedAndMaskNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 connected mask --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMaskNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected planarFigure --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected planarFigure --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndPlanarFigureNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_planarFigure.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
+  }
+	
+	void GetImageStatisticsWithImageAndPlanarFigureConnected()
+	{
+    //create rules connection + add statistics to dataStorage
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto planarFigureRule = mitk::CreateNodeRelationPlanarFigure(m_statisticsContainer.GetPointer(), m_planarFigure.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    rules.push_back(planarFigureRule.GetPointer());
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+    m_manager->SetRules({ rules });
+
+    //rule: (image-->statistics, planarFigure-->statistics), 1 connected image, 1 connected planarFigure --> test return statistics
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigure;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigure = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigure.IsNull(), false);
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigure->GetUID(), m_statisticsContainer->GetUID());
+
+    //new rule: (image-->statistics2)
+    mitk::PropertyRelations::RuleResultVectorType rules2;
+    imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
+    rules2.push_back(imageRule.GetPointer());
+    m_manager->SetRules({ rules2, rules });
+
+    auto statisticsNode2 = mitk::CreateImageStatisticsNode(m_statisticsContainer2, "testStatistics2");
+    standaloneDataStorage->Add(statisticsNode2);
+
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureAgain;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureAgain = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureAgain->GetUID(), m_statisticsContainer->GetUID());
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureAgain->GetUID() != m_statisticsContainer2->GetUID(), true);
+	}
+
+  void GetImageStatisticsWithImageAndPlanarFigureNotConnected()
+  {
+    //create rules connection + add statistics to dataStorage
+    auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto planarFigureRule = mitk::CreateNodeRelationPlanarFigure(m_statisticsContainer.GetPointer(), m_planarFigure.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    rules.push_back(planarFigureRule.GetPointer());
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    standaloneDataStorage->Add(statisticsNode);
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+
+    //rule: (image-->statistics, mask-->statistics), 1 connected image --> test return nullptr
+    m_manager->SetRules({ rules });
+    mitk::StatisticsContainer::ConstPointer statisticsWithImage;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected mask --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndMaskNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageNotConnectedAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask2.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageNotConnectedAndMaskNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 connected mask --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMaskNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected mask --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageConnectedAndMaskNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageConnectedAndMaskNotConnected = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageConnectedAndMaskNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected planarFigure --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure2.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
+
+    //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected planarFigure --> test return nullptr
+    mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndPlanarFigureNotConnected;
+    CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_planarFigure2.GetPointer()));
+    CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
+  }
+	
+	void GetImageStatisticsInvalid()
+	{
+    mitk::PropertyRelations::RuleResultVectorType rules;
+    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    rules.push_back(imageRule.GetPointer());
+    m_manager->SetRules({ rules });
+
+    CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(m_image.GetPointer()), mitk::Exception);
+
+    auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
+    m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
+
+    CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(nullptr), mitk::Exception);
+    CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(nullptr, m_mask.GetPointer()), mitk::Exception);
+    CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(nullptr, m_planarFigure.GetPointer()), mitk::Exception);
+	}
+
+};
+MITK_TEST_SUITE_REGISTRATION(mitkImageStatisticsContainerManager)
\ No newline at end of file
diff --git a/Modules/ImageStatistics/files.cmake b/Modules/ImageStatistics/files.cmake
index c6b003ec03..3aca95e1b9 100644
--- a/Modules/ImageStatistics/files.cmake
+++ b/Modules/ImageStatistics/files.cmake
@@ -1,39 +1,41 @@
 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
+  mitkImageStatisticsContainerManager.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
+  mitkImageStatisticsContainerManager.h
 )
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerManager.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.cpp
new file mode 100644
index 0000000000..c14998e249
--- /dev/null
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.cpp
@@ -0,0 +1,158 @@
+/*===================================================================
+
+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 "mitkImageStatisticsContainerManager.h"
+
+#include "mitkNodePredicateBase.h"
+#include "mitkNodePredicateAnd.h"
+#include "mitkNodePredicateOr.h"
+#include "mitkNodePredicateDataType.h"
+
+mitk::ImageStatisticsContainerManager::ImageStatisticsContainerManager()
+{
+}
+
+void mitk::ImageStatisticsContainerManager::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
+{
+  if (!dataStorage) {
+    mitkThrow() << "dataStorage is nullptr";
+  }
+  m_DataStorage = dataStorage;
+}
+
+void mitk::ImageStatisticsContainerManager::SetRules(const std::vector<mitk::PropertyRelations::RuleResultVectorType>& rules)
+{
+  m_ImageStatisticRules = rules;
+}
+
+mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image) const
+{
+  return GetImageStatistics(image, nullptr, nullptr);
+}
+
+mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask) const
+{
+  return GetImageStatistics(image, mask, nullptr);
+}
+
+mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::ConstPointer planarFigure) const
+{
+  return GetImageStatistics(image, nullptr, planarFigure);
+}
+
+mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask, mitk::PlanarFigure::ConstPointer planarFigure) const
+{
+  if (m_ImageStatisticRules.empty()) {
+    return nullptr;
+  }
+
+  if (!m_DataStorage) {
+    mitkThrow() << "data storage is nullptr!";
+  }
+
+  mitk::NodePredicateBase::ConstPointer allPredicates = nullptr;
+
+  for (const auto& imageStatisticOneRule : m_ImageStatisticRules) {
+    auto currentPredicate = GetPredicateForSources(imageStatisticOneRule, image.GetPointer(), mask.GetPointer(), planarFigure.GetPointer());
+    if (currentPredicate) {
+      if (!allPredicates) {
+        allPredicates = currentPredicate;
+      }
+      else {
+        allPredicates = mitk::NodePredicateOr::New(allPredicates, currentPredicate);
+      }
+    }
+  }
+
+  if (allPredicates) {
+    auto nodePredicateImageStatisticsContainer = mitk::NodePredicateDataType::New("StatisticsContainer");
+    allPredicates = mitk::NodePredicateAnd::New(allPredicates, nodePredicateImageStatisticsContainer);
+
+    auto nodes = m_DataStorage->GetSubset(allPredicates);
+
+    if (nodes->empty()) {
+      return nullptr;
+    }
+    if (nodes->size() > 1) {
+      MITK_WARN << "multiple statistics (" << nodes->size() << ") for image/mask/planarfigure found. Returning only first one.";
+    }
+    return dynamic_cast<mitk::StatisticsContainer*>(nodes->front()->GetData());
+  }
+  else {
+    return nullptr;
+  }
+}
+
+mitk::NodePredicateBase::ConstPointer mitk::ImageStatisticsContainerManager::GetPredicateForSources(const mitk::PropertyRelations::RuleResultVectorType& rules, mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask, mitk::BaseData::ConstPointer planarFigure) const
+{
+  if (image.IsNull()) {
+    mitkThrow() << "Image is nullptr";
+  }
+  if (mask && planarFigure) {
+    mitkThrow() << "only mask OR planar figure can be handled";
+  }
+
+  if (rules.empty()) {
+    return nullptr;
+  }
+
+  //only image as input, but !=1 rules: can't find any imageStatistic object
+  if (!mask && !planarFigure && rules.size() != 1) {
+    return nullptr;
+  }
+  //image+(mask || planarFigure) as input, but !=2 rules: can't find any imageStatistic object
+  /*if ((mask || planarFigure) && rules.size() != 2) {
+    return nullptr;
+  }*/
+
+  mitk::NodePredicateBase::ConstPointer statisticsFromImageAndMaskAndPlanarFigure = nullptr;
+
+    for (const auto& rule : rules) {
+      //choose correct rule for image, mask or planarFigure
+      if (rule->GetRuleID() == "IDRelation_statisticsToImage") {
+        auto statisticsFromImagePredicate = rule->GetSourcesDetector(image);
+        if (!statisticsFromImageAndMaskAndPlanarFigure) {
+          statisticsFromImageAndMaskAndPlanarFigure = statisticsFromImagePredicate;
+        }
+        else {
+          statisticsFromImageAndMaskAndPlanarFigure = mitk::NodePredicateAnd::New(statisticsFromImagePredicate, statisticsFromImageAndMaskAndPlanarFigure);
+        }
+      }
+      else if (mask && rule->GetRuleID() == "IDRelation_statisticsToMask") {
+        auto statisticsFromMaskPredicate = rule->GetSourcesDetector(mask);
+        if (!statisticsFromImageAndMaskAndPlanarFigure) {
+          statisticsFromImageAndMaskAndPlanarFigure = statisticsFromMaskPredicate;
+        }
+        else {
+          statisticsFromImageAndMaskAndPlanarFigure = mitk::NodePredicateAnd::New(statisticsFromMaskPredicate, statisticsFromImageAndMaskAndPlanarFigure);
+        }
+      }
+      else if (planarFigure && rule->GetRuleID() == "IDRelation_statisticsToPlanarFigure") {
+        auto statisticsFromPlanarFigurePredicate = rule->GetSourcesDetector(planarFigure);
+        if (!statisticsFromImageAndMaskAndPlanarFigure) {
+          statisticsFromImageAndMaskAndPlanarFigure = statisticsFromPlanarFigurePredicate;
+        }
+        else {
+          statisticsFromImageAndMaskAndPlanarFigure = mitk::NodePredicateAnd::New(statisticsFromPlanarFigurePredicate, statisticsFromImageAndMaskAndPlanarFigure);
+        }
+      }
+      else {
+        return nullptr;
+      }
+    }
+
+  return statisticsFromImageAndMaskAndPlanarFigure;
+}
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerManager.h b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.h
new file mode 100644
index 0000000000..c67fe76820
--- /dev/null
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.h
@@ -0,0 +1,63 @@
+/*===================================================================
+
+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 QmitkImageStatisticsContainerManager_H__INCLUDED
+#define QmitkImageStatisticsContainerManager_H__INCLUDED
+
+#include "MitkImageStatisticsExports.h"
+
+#include <mitkDataStorage.h>
+#include <mitkImageStatisticsContainer.h>
+#include <mitkImage.h>
+#include <mitkPlanarFigure.h>
+#include <mitkNodePredicateBase.h>
+#include <mitkGenericIDRelationRule.h>
+#include <mitkPropertyRelations.h>
+
+/**
+\brief Returns the image statistic to the given input
+\details
+
+*/
+namespace mitk
+{
+  class MITKIMAGESTATISTICS_EXPORT ImageStatisticsContainerManager : public itk::Object
+  {
+  public:
+    mitkClassMacroItkParent(ImageStatisticsContainerManager, itk::Object)
+    itkNewMacro(Self)
+
+    //mitkGetObjectMacroConst(DataStorage, mitk::DataStorage)
+    //itkGetConstMacro(ImageStatisticRules, std::vector<mitk::PropertyRelations::RuleResultVectorType>)
+
+    void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
+    void SetRules(const std::vector<mitk::PropertyRelations::RuleResultVectorType>& rules);
+
+    mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image) const;
+    mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask) const;
+    mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::ConstPointer planarFigure) const;
+
+  protected:
+    ImageStatisticsContainerManager();
+
+  private:
+    mitk::NodePredicateBase::ConstPointer GetPredicateForSources(const mitk::PropertyRelations::RuleResultVectorType& rules, mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask = nullptr, mitk::BaseData::ConstPointer planarFigure = nullptr) const;
+    mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask, mitk::PlanarFigure::ConstPointer planarFigure) const;
+
+    mitk::DataStorage::Pointer m_DataStorage = nullptr;
+    std::vector<mitk::PropertyRelations::RuleResultVectorType> m_ImageStatisticRules;
+  };
+}
+#endif