diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp
index 54f0aa6c22..1d91a402a4 100644
--- a/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp
@@ -1,265 +1,282 @@
 /*===================================================================
 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>
+#include <mitkStatisticsToImageRelationRule.h>
+#include <mitkStatisticsToMaskRelationRule.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(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()));
 	}
 
+  mitk::StatisticsToImageRelationRule::Pointer CreateNodeRelationImage(mitk::BaseData::Pointer statistics, mitk::BaseData::ConstPointer image)
+  {
+    auto rule = mitk::StatisticsToImageRelationRule::New();
+    rule->Connect(statistics, image);
+    return rule;
+  }
+
+  mitk::StatisticsToMaskRelationRule::Pointer CreateNodeRelationMask(mitk::BaseData::Pointer statistics, mitk::BaseData::ConstPointer image)
+  {
+    auto rule = mitk::StatisticsToMaskRelationRule::New();
+    rule->Connect(statistics, image);
+    return rule;
+  }
+
   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());
+    auto imageRule = 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());
+    imageRule = CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
+    auto imageMaskRule = 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());
+    imageRule = CreateNodeRelationImage(m_statisticsContainer3.GetPointer(), m_image.GetPointer());
+    auto imagePlanarFigureRule = 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());
+    auto imageRule = 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());
+    auto imageRule = CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto maskRule = 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());
+    imageRule = 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());
+    auto imageRule = CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto maskRule = 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 GetImageStatisticsInvalid()
 	{
     mitk::PropertyRelations::RuleResultVectorType rules;
-    auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
+    auto imageRule = 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/mitkImageStatisticsContainerNodeHelper.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp
index 145fceb450..42afdedf47 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp
@@ -1,48 +1,29 @@
 /*===================================================================
 
 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;
   }
-
-  mitk::GenericIDRelationRule::Pointer CreateNodeRelationImage(BaseData::Pointer statistics, BaseData::ConstPointer image)
-  {
-    using StatisticsImageRule = mitk::GenericIDRelationRule;
-    auto rule = StatisticsImageRule::New("statisticsToImage");
-    rule->Connect(statistics, image);
-    return rule;
-  }
-
-  mitk::GenericIDRelationRule::Pointer CreateNodeRelationMask(BaseData::Pointer statistics, BaseData::ConstPointer mask)
-  {
-    using StatisticsMaskImageRule = mitk::GenericIDRelationRule;
-    auto rule = StatisticsMaskImageRule::New("statisticsToMask");
-    rule->Connect(statistics, mask);
-    return rule;
-  }
-
 }
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h
index 812249a056..7a5551332a 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h
@@ -1,33 +1,30 @@
 /*===================================================================
 
 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>
-#include <mitkGenericIDRelationRule.h>
 
 namespace mitk
 {
   MITKIMAGESTATISTICS_EXPORT DataNode::Pointer CreateImageStatisticsNode(StatisticsContainer::Pointer statistic, const std::string& name = "statistics");
-  MITKIMAGESTATISTICS_EXPORT mitk::GenericIDRelationRule::Pointer CreateNodeRelationImage(mitk::BaseData::Pointer statistics, mitk::BaseData::ConstPointer image);
-  MITKIMAGESTATISTICS_EXPORT mitk::GenericIDRelationRule::Pointer CreateNodeRelationMask(mitk::BaseData::Pointer statistics, mitk::BaseData::ConstPointer mask);
 }
 #endif // MITKIMAGESTATISTICSCONTAINERNODEHELPER