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 +#include +#include +#include +#include +#include +#include + +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& 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(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 +#include +#include +#include +#include +#include +#include + +/** +\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) + + void SetDataStorage(mitk::DataStorage::Pointer dataStorage); + void SetRules(const std::vector& 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 m_ImageStatisticRules; + }; +} +#endif