diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp index 0765d5b286..54f0aa6c22 100644 --- a/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp +++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsContainerManagerTest.cpp @@ -1,347 +1,265 @@ /*=================================================================== 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/mitkImageStatisticsContainerManager.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.cpp index c14998e249..087b38fd99 100644 --- a/Modules/ImageStatistics/mitkImageStatisticsContainerManager.cpp +++ b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.cpp @@ -1,158 +1,166 @@ /*=================================================================== 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 "mitkNodePredicateNot.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 +mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask) 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()); + auto currentPredicate = GetPredicateForSources(imageStatisticOneRule, image, mask); 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 (!mask) { + auto filteredNodes = mitk::DataStorage::SetOfObjects::New(); + for (const auto& node : *nodes) { + auto nodeData = node->GetData(); + bool ok = true; + if (nodeData) { + for (const auto& imageStatisticOneRule : m_ImageStatisticRules) { + for (const auto& aRule : imageStatisticOneRule) { + if (aRule->GetRuleID() == "IDRelation_statisticsToMask") { + auto isSource = aRule->IsSource(nodeData); + if (isSource) { + ok = false; + } + } + } + } + } + if (ok) { + filteredNodes->push_back(node); + } + } + if (filteredNodes->empty()) { + return nullptr; + } + if (filteredNodes->size() > 1) { + MITK_WARN << "multiple statistics (" << filteredNodes->size() << ") for image/mask found. Returning only first one."; + } + return dynamic_cast(filteredNodes->front()->GetData()); } - if (nodes->size() > 1) { - MITK_WARN << "multiple statistics (" << nodes->size() << ") for image/mask/planarfigure found. Returning only first one."; + else { + + if (nodes->empty()) { + return nullptr; + } + if (nodes->size() > 1) { + MITK_WARN << "multiple statistics (" << nodes->size() << ") for image/mask found. Returning only first one."; + for (const auto& node : *nodes) { + MITK_WARN << node->GetName(); + } + } + return dynamic_cast(nodes->front()->GetData()); } - 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 +mitk::NodePredicateBase::ConstPointer mitk::ImageStatisticsContainerManager::GetPredicateForSources(const mitk::PropertyRelations::RuleResultVectorType& rules, mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask) 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) { + if (!mask && 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) { + if ((mask) && 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 index c67fe76820..5d86be4e3f 100644 --- a/Modules/ImageStatistics/mitkImageStatisticsContainerManager.h +++ b/Modules/ImageStatistics/mitkImageStatisticsContainerManager.h @@ -1,63 +1,56 @@ /*=================================================================== 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 #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; + mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask=nullptr) 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::NodePredicateBase::ConstPointer GetPredicateForSources(const mitk::PropertyRelations::RuleResultVectorType& rules, mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask = nullptr) const; mitk::DataStorage::Pointer m_DataStorage = nullptr; std::vector m_ImageStatisticRules; }; } #endif diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp index 2c12575eb9..145fceb450 100644 --- a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp +++ b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.cpp @@ -1,56 +1,48 @@ /*=================================================================== 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 #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; } - mitk::GenericIDRelationRule::Pointer CreateNodeRelationPlanarFigure(BaseData::Pointer statistics, BaseData::ConstPointer planarFigure) - { - using StatisticsPlanarFigureRule = mitk::GenericIDRelationRule; - auto rule = StatisticsPlanarFigureRule::New("statisticsToPlanarFigure"); - rule->Connect(statistics, planarFigure); - return rule; - } - } diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h index 1cf84c4d33..812249a056 100644 --- a/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h +++ b/Modules/ImageStatistics/mitkImageStatisticsContainerNodeHelper.h @@ -1,34 +1,33 @@ /*=================================================================== 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 #include #include #include 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); - MITKIMAGESTATISTICS_EXPORT mitk::GenericIDRelationRule::Pointer CreateNodeRelationPlanarFigure(mitk::BaseData::Pointer statistics, mitk::BaseData::ConstPointer planarFigure); } #endif // MITKIMAGESTATISTICSCONTAINERNODEHELPER 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 2d3d9f6534..9986f2b88c 100644 --- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp +++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp @@ -1,349 +1,349 @@ /*=================================================================== 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 // berry includes #include #include #include #include #include #include #include #include #include #include #include #include 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); m_statisticsManager = mitk::ImageStatisticsContainerManager::New(); m_statisticsManager->SetDataStorage(this->GetDataStorage().GetPointer()); 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& 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& histogram, const std::vector& 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(); if (styleManagerRef) { auto styleManager = context->getService(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); //m_statisticContainerRules.clear(); if (m_selectedImageNode != nullptr) { auto image = dynamic_cast(m_selectedImageNode->GetData()); mitk::Image::Pointer mask = nullptr; mitk::PlanarFigure::Pointer maskPlanarFigure = nullptr; if (m_selectedMaskNode != nullptr) { mask = dynamic_cast(m_selectedMaskNode->GetData()); if (mask == nullptr) { maskPlanarFigure = dynamic_cast(m_selectedMaskNode->GetData()); } } if (mask) { auto imageStatistics = m_statisticsManager->GetImageStatistics(image, mask.GetPointer()); //compute statistics with given mask if (!imageStatistics) { CalculateStatistics(image, mask.GetPointer()); } //statistics already computed else { this->FillStatisticsWidget({ imageStatistics }); this->FillHistogramWidget({ imageStatistics->GetHistogram().GetPointer() }, { m_selectedImageNode->GetName() }); } } 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()); } auto imageStatistics = m_statisticsManager->GetImageStatistics(image, maskPlanarFigure.GetPointer()); //for all planar figures: compute statistics with planarFigure as mask if (!imageStatistics) { CalculateStatistics(image, maskPlanarFigure.GetPointer()); } //statistics already computed else { this->FillStatisticsWidget({ imageStatistics }); if (maskPlanarFigure->IsClosed()) { this->FillHistogramWidget({ imageStatistics->GetHistogram().GetPointer() }, { m_selectedImageNode->GetName() }); } } } else { auto imageStatistics = m_statisticsManager->GetImageStatistics(image); //compute statistics with image only if (!imageStatistics) { CalculateStatistics(image); } //statistics already computed else { this->FillStatisticsWidget({ imageStatistics }); this->FillHistogramWidget({ imageStatistics->GetHistogram().GetPointer() }, { m_selectedImageNode->GetName() }); } } } 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()) { auto statistics = m_CalculationThread->GetStatisticsData(); for (auto& statistic : statistics) { mitk::PropertyRelations::RuleResultVectorType rulesForCurrentStatistic; auto statisticNonConst = statistic->Clone(); auto statisticsNodeName = m_selectedImageNode->GetName(); if (m_selectedMaskNode) { statisticsNodeName += "_" + m_selectedMaskNode->GetName(); } statisticsNodeName += "_statistics"; auto statisticsNode = mitk::CreateImageStatisticsNode(statisticNonConst, statisticsNodeName); auto imageRule = CreateNodeRelationImage(statisticNonConst.GetPointer(), m_CalculationThread->GetStatisticsImage().GetPointer()); rulesForCurrentStatistic.push_back(imageRule.GetPointer()); if (m_CalculationThread->GetMaskImage()) { auto maskRule = CreateNodeRelationMask(statisticNonConst.GetPointer(), m_CalculationThread->GetMaskImage().GetPointer()); rulesForCurrentStatistic.push_back(maskRule.GetPointer()); } - if (m_CalculationThread->GetPlanarFigure()) { - auto planarFigureRule = CreateNodeRelationPlanarFigure(statisticNonConst.GetPointer(), m_CalculationThread->GetPlanarFigure().GetPointer()); + else if (m_CalculationThread->GetPlanarFigure()) { + auto planarFigureRule = CreateNodeRelationMask(statisticNonConst.GetPointer(), m_CalculationThread->GetPlanarFigure().GetPointer()); rulesForCurrentStatistic.push_back(planarFigureRule.GetPointer()); } m_statisticContainerRules.push_back(rulesForCurrentStatistic); this->GetDataStorage()->Add(statisticsNode); m_statisticsManager->SetRules(m_statisticContainerRules); } 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::ConstPointer image, mitk::Image::ConstPointer mask) { CalculateStatisticsInternal(image, mask); } void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::ConstPointer mask) { CalculateStatisticsInternal(image, nullptr, mask); } void QmitkImageStatisticsReloadedView::CalculateStatisticsInternal(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask, mitk::PlanarFigure::ConstPointer maskPlanarFigure) { this->m_StatisticsUpdatePending = true; auto renderPart = this->GetRenderWindowPart(); unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos(); this->m_CalculationThread->Initialize(image, mask, maskPlanarFigure); this->m_CalculationThread->SetTimeStep(timeStep); 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 &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(""); } void QmitkImageStatisticsReloadedView::Activated() { } void QmitkImageStatisticsReloadedView::Deactivated() { } void QmitkImageStatisticsReloadedView::Visible() { connect(m_Controls.imageSelector, static_cast(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged); connect(m_Controls.maskImageSelector, static_cast(&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() { }