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 <mitkIOUtil.h>
#include <mitkImageStatisticsContainerManager.h>
#include <mitkDataStorage.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkImageStatisticsContainer.h>
#include <mitkPlanarCircle.h>
#include <mitkImageStatisticsContainerNodeHelper.h>
class mitkImageStatisticsContainerManagerTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkImageStatisticsContainerManagerTestSuite);
MITK_TEST(SetDataStorageNull);
MITK_TEST(SetDataStorage);
MITK_TEST(GetImageStatisticsNoRules);
MITK_TEST(GetImageStatisticsWithImageConnected);
MITK_TEST(GetImageStatisticsWithImageNotConnected);
MITK_TEST(GetImageStatisticsWithImageAndMaskConnected);
MITK_TEST(GetImageStatisticsWithImageAndMaskNotConnected);
- MITK_TEST(GetImageStatisticsWithImageAndPlanarFigureConnected);
- MITK_TEST(GetImageStatisticsWithImageAndPlanarFigureNotConnected);
MITK_TEST(GetImageStatisticsInvalid);
CPPUNIT_TEST_SUITE_END();
private:
mitk::ImageStatisticsContainerManager::Pointer m_manager;
mitk::StatisticsContainer::Pointer m_statisticsContainer, m_statisticsContainer2, m_statisticsContainer3;
mitk::Image::Pointer m_image, m_image2;
mitk::Image::Pointer m_mask, m_mask2;
mitk::PlanarFigure::Pointer m_planarFigure, m_planarFigure2;
public:
void setUp() override
{
m_manager = mitk::ImageStatisticsContainerManager::New();
m_statisticsContainer = mitk::StatisticsContainer::New();
m_statisticsContainer2 = mitk::StatisticsContainer::New();
m_statisticsContainer3 = mitk::StatisticsContainer::New();
m_image = mitk::Image::New();
m_image2 = mitk::Image::New();
m_mask = mitk::Image::New();
m_mask2 = mitk::Image::New();
m_planarFigure = mitk::PlanarCircle::New().GetPointer();
m_planarFigure2 = mitk::PlanarCircle::New().GetPointer();
}
void tearDown() override
{
}
void SetDataStorageNull()
{
CPPUNIT_ASSERT_THROW(m_manager->SetDataStorage(nullptr), mitk::Exception);
}
void SetDataStorage()
{
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
CPPUNIT_ASSERT_NO_THROW(m_manager->SetDataStorage(standaloneDataStorage.GetPointer()));
}
void GetImageStatisticsNoRules() {
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
//no rules + 1 image --> test return nullptr
mitk::StatisticsContainer::ConstPointer emptyStatistic;
CPPUNIT_ASSERT_NO_THROW(emptyStatistic = m_manager->GetImageStatistics(m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
//no rules + 1 image + 1 mask --> test return nullptr
CPPUNIT_ASSERT_NO_THROW(emptyStatistic = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
//no rules + 1 image + 1 planarFigure --> test return nullptr
CPPUNIT_ASSERT_NO_THROW(emptyStatistic = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(emptyStatistic.IsNull(), true);
}
void GetImageStatisticsWithImageConnected()
{
//create rules connection
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
mitk::PropertyRelations::RuleResultVectorType rules;
auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
rules.push_back(imageRule.GetPointer());
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
//rule: (image-->statistics), 1 connected image --> test return image statistics
m_manager->SetRules({ rules });
mitk::StatisticsContainer::ConstPointer statisticsWithImage;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImage->GetUID(), m_statisticsContainer->GetUID());
//new rule: (image-->statistics2 AND mask --> statistics2)
mitk::PropertyRelations::RuleResultVectorType rules2;
imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
auto imageMaskRule = mitk::CreateNodeRelationMask(m_statisticsContainer2.GetPointer(), m_mask.GetPointer());
rules2.push_back(imageRule.GetPointer());
rules2.push_back(imageMaskRule.GetPointer());
m_manager->SetRules({ rules2, rules });
auto statisticsNode2 = mitk::CreateImageStatisticsNode(m_statisticsContainer2, "testStatistics2");
standaloneDataStorage->Add(statisticsNode2);
//--> test return (still) image statistics (!= statistics2)
mitk::StatisticsContainer::ConstPointer statisticsWithImageAgain;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAgain = m_manager->GetImageStatistics(m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID(), m_statisticsContainer->GetUID());
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID()!= m_statisticsContainer2->GetUID(), true);
//new rule: (image-->statistics3 AND planarFigure --> statistics3)
mitk::PropertyRelations::RuleResultVectorType rules3;
imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer3.GetPointer(), m_image.GetPointer());
auto imagePlanarFigureRule = mitk::CreateNodeRelationMask(m_statisticsContainer3.GetPointer(), m_planarFigure.GetPointer());
rules3.push_back(imageRule.GetPointer());
rules3.push_back(imagePlanarFigureRule.GetPointer());
m_manager->SetRules({ rules3, rules2, rules });
auto statisticsNode3 = mitk::CreateImageStatisticsNode(m_statisticsContainer3, "testStatistics3");
standaloneDataStorage->Add(statisticsNode3);
//--> test return (still) image statistics (!= statistics3)
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAgain = m_manager->GetImageStatistics(m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID(), m_statisticsContainer->GetUID());
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAgain->GetUID() != m_statisticsContainer3->GetUID(), true);
}
void GetImageStatisticsWithImageNotConnected() {
//create rules connection
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
mitk::PropertyRelations::RuleResultVectorType rules;
auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
rules.push_back(imageRule.GetPointer());
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
m_manager->SetRules({ rules });
//rule: (image-->statistics), 1 unconnected image --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImage;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image2.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
//rule: (image-->statistics), 1 connected image + 1 unconnected mask --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMask;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMask = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMask.IsNull(), true);
//rule: (image-->statistics), 1 connected image + 1 unconnected planar figure --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigure;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigure = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigure.IsNull(), true);
}
void GetImageStatisticsWithImageAndMaskConnected()
{
//create rules connection + add statistics to dataStorage
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
mitk::PropertyRelations::RuleResultVectorType rules;
auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
auto maskRule = mitk::CreateNodeRelationMask(m_statisticsContainer.GetPointer(), m_mask.GetPointer());
rules.push_back(imageRule.GetPointer());
rules.push_back(maskRule.GetPointer());
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
m_manager->SetRules({ rules });
//rule: (image-->statistics, mask-->statistics), 1 connected image, 1 connected mask --> test return statistics
mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMask;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMask = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMask.IsNull(),false);
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMask->GetUID(), m_statisticsContainer->GetUID());
//new rule: (image-->statistics2)
mitk::PropertyRelations::RuleResultVectorType rules2;
imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
rules2.push_back(imageRule.GetPointer());
m_manager->SetRules({ rules2, rules });
auto statisticsNode2 = mitk::CreateImageStatisticsNode(m_statisticsContainer2, "testStatistics2");
standaloneDataStorage->Add(statisticsNode2);
mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMaskAgain;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskAgain = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskAgain->GetUID(), m_statisticsContainer->GetUID());
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskAgain->GetUID() != m_statisticsContainer2->GetUID(), true);
}
void GetImageStatisticsWithImageAndMaskNotConnected()
{
//create rules connection + add statistics to dataStorage
auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
mitk::PropertyRelations::RuleResultVectorType rules;
auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
auto maskRule = mitk::CreateNodeRelationMask(m_statisticsContainer.GetPointer(), m_mask.GetPointer());
rules.push_back(imageRule.GetPointer());
rules.push_back(maskRule.GetPointer());
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
standaloneDataStorage->Add(statisticsNode);
m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
//rule: (image-->statistics, mask-->statistics), 1 connected image --> test return nullptr
m_manager->SetRules({ rules });
mitk::StatisticsContainer::ConstPointer statisticsWithImage;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected mask --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndMaskNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageNotConnectedAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask2.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageNotConnectedAndMaskNotConnected.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 connected mask --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMaskNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskNotConnected.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected planarFigure --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
//rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected planarFigure --> test return nullptr
mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndPlanarFigureNotConnected;
CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_planarFigure.GetPointer()));
CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
}
- void GetImageStatisticsWithImageAndPlanarFigureConnected()
- {
- //create rules connection + add statistics to dataStorage
- auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
- mitk::PropertyRelations::RuleResultVectorType rules;
- auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
- auto planarFigureRule = mitk::CreateNodeRelationPlanarFigure(m_statisticsContainer.GetPointer(), m_planarFigure.GetPointer());
- rules.push_back(imageRule.GetPointer());
- rules.push_back(planarFigureRule.GetPointer());
- auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
- standaloneDataStorage->Add(statisticsNode);
- m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
- m_manager->SetRules({ rules });
-
- //rule: (image-->statistics, planarFigure-->statistics), 1 connected image, 1 connected planarFigure --> test return statistics
- mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigure;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigure = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigure.IsNull(), false);
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigure->GetUID(), m_statisticsContainer->GetUID());
-
- //new rule: (image-->statistics2)
- mitk::PropertyRelations::RuleResultVectorType rules2;
- imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer2.GetPointer(), m_image.GetPointer());
- rules2.push_back(imageRule.GetPointer());
- m_manager->SetRules({ rules2, rules });
-
- auto statisticsNode2 = mitk::CreateImageStatisticsNode(m_statisticsContainer2, "testStatistics2");
- standaloneDataStorage->Add(statisticsNode2);
-
- mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureAgain;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureAgain = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureAgain->GetUID(), m_statisticsContainer->GetUID());
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureAgain->GetUID() != m_statisticsContainer2->GetUID(), true);
- }
-
- void GetImageStatisticsWithImageAndPlanarFigureNotConnected()
- {
- //create rules connection + add statistics to dataStorage
- auto statisticsNode = mitk::CreateImageStatisticsNode(m_statisticsContainer, "testStatistics");
- mitk::PropertyRelations::RuleResultVectorType rules;
- auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
- auto planarFigureRule = mitk::CreateNodeRelationPlanarFigure(m_statisticsContainer.GetPointer(), m_planarFigure.GetPointer());
- rules.push_back(imageRule.GetPointer());
- rules.push_back(planarFigureRule.GetPointer());
- auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
- standaloneDataStorage->Add(statisticsNode);
- m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
-
- //rule: (image-->statistics, mask-->statistics), 1 connected image --> test return nullptr
- m_manager->SetRules({ rules });
- mitk::StatisticsContainer::ConstPointer statisticsWithImage;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImage = m_manager->GetImageStatistics(m_image.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImage.IsNull(), true);
-
- //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected mask --> test return nullptr
- mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndMaskNotConnected;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageNotConnectedAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask2.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageNotConnectedAndMaskNotConnected.IsNull(), true);
-
- //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 connected mask --> test return nullptr
- mitk::StatisticsContainer::ConstPointer statisticsWithImageAndMaskNotConnected;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndMaskNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_mask.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndMaskNotConnected.IsNull(), true);
-
- //rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected mask --> test return nullptr
- mitk::StatisticsContainer::ConstPointer statisticsWithImageConnectedAndMaskNotConnected;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageConnectedAndMaskNotConnected = m_manager->GetImageStatistics(m_image.GetPointer(), m_mask.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageConnectedAndMaskNotConnected.IsNull(), true);
-
- //rule: (image-->statistics, mask-->statistics), 1 connected image, 1 unconnected planarFigure --> test return nullptr
- mitk::StatisticsContainer::ConstPointer statisticsWithImageAndPlanarFigureNotConnected;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image.GetPointer(), m_planarFigure2.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
-
- //rule: (image-->statistics, mask-->statistics), 1 unconnected image, 1 unconnected planarFigure --> test return nullptr
- mitk::StatisticsContainer::ConstPointer statisticsWithImageNotConnectedAndPlanarFigureNotConnected;
- CPPUNIT_ASSERT_NO_THROW(statisticsWithImageAndPlanarFigureNotConnected = m_manager->GetImageStatistics(m_image2.GetPointer(), m_planarFigure2.GetPointer()));
- CPPUNIT_ASSERT_EQUAL(statisticsWithImageAndPlanarFigureNotConnected.IsNull(), true);
- }
-
void GetImageStatisticsInvalid()
{
mitk::PropertyRelations::RuleResultVectorType rules;
auto imageRule = mitk::CreateNodeRelationImage(m_statisticsContainer.GetPointer(), m_image.GetPointer());
rules.push_back(imageRule.GetPointer());
m_manager->SetRules({ rules });
CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(m_image.GetPointer()), mitk::Exception);
auto standaloneDataStorage = mitk::StandaloneDataStorage::New();
m_manager->SetDataStorage(standaloneDataStorage.GetPointer());
CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(nullptr), mitk::Exception);
CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(nullptr, m_mask.GetPointer()), mitk::Exception);
CPPUNIT_ASSERT_THROW(m_manager->GetImageStatistics(nullptr, m_planarFigure.GetPointer()), mitk::Exception);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkImageStatisticsContainerManager)
\ No newline at end of file
diff --git a/Modules/ImageStatistics/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<mitk::PropertyRelations::RuleResultVectorType>& rules)
{
m_ImageStatisticRules = rules;
}
-mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image) const
-{
- return GetImageStatistics(image, nullptr, nullptr);
-}
-
-mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask) const
-{
- return GetImageStatistics(image, mask, nullptr);
-}
-
-mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::ConstPointer planarFigure) const
-{
- return GetImageStatistics(image, nullptr, planarFigure);
-}
-
-mitk::StatisticsContainer::ConstPointer mitk::ImageStatisticsContainerManager::GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask, mitk::PlanarFigure::ConstPointer planarFigure) const
+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<mitk::StatisticsContainer*>(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<mitk::StatisticsContainer*>(nodes->front()->GetData());
}
- return dynamic_cast<mitk::StatisticsContainer*>(nodes->front()->GetData());
}
else {
return nullptr;
}
}
-mitk::NodePredicateBase::ConstPointer mitk::ImageStatisticsContainerManager::GetPredicateForSources(const mitk::PropertyRelations::RuleResultVectorType& rules, mitk::BaseData::ConstPointer image, mitk::BaseData::ConstPointer mask, mitk::BaseData::ConstPointer planarFigure) const
+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 <mitkDataStorage.h>
#include <mitkImageStatisticsContainer.h>
-#include <mitkImage.h>
-#include <mitkPlanarFigure.h>
+#include <mitkBaseData.h>
#include <mitkNodePredicateBase.h>
#include <mitkGenericIDRelationRule.h>
#include <mitkPropertyRelations.h>
/**
\brief Returns the image statistic to the given input
\details
*/
namespace mitk
{
class MITKIMAGESTATISTICS_EXPORT ImageStatisticsContainerManager : public itk::Object
{
public:
mitkClassMacroItkParent(ImageStatisticsContainerManager, itk::Object)
itkNewMacro(Self)
- //mitkGetObjectMacroConst(DataStorage, mitk::DataStorage)
- //itkGetConstMacro(ImageStatisticRules, std::vector<mitk::PropertyRelations::RuleResultVectorType>)
-
void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
void SetRules(const std::vector<mitk::PropertyRelations::RuleResultVectorType>& rules);
- mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image) const;
- mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image, mitk::Image::ConstPointer mask) const;
- mitk::StatisticsContainer::ConstPointer GetImageStatistics(mitk::Image::ConstPointer image, mitk::PlanarFigure::ConstPointer planarFigure) const;
+ 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<mitk::PropertyRelations::RuleResultVectorType> 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 <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;
}
- 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 <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);
- 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 <utility>
// berry includes
#include <berryWorkbenchPlugin.h>
#include <berryIQtStyleManager.h>
#include <QmitkChartWidget.h>
#include <mitkNodePredicateOr.h>
#include <mitkStatusBar.h>
#include <mitkIntensityProfile.h>
#include <mitkImageStatisticsPredicateHelper.h>
#include <mitkImageStatisticsContainerNodeHelper.h>
#include <mitkNodePredicateAnd.h>
#include <mitkSliceNavigationController.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarFigureInteractor.h>
const std::string QmitkImageStatisticsReloadedView::VIEW_ID = "org.mitk.views.imagestatisticsReloaded";
QmitkImageStatisticsReloadedView::QmitkImageStatisticsReloadedView(QObject* /*parent*/, const char* /*name*/)
{
this->m_CalculationThread = new QmitkImageStatisticsCalculationJob();
}
QmitkImageStatisticsReloadedView::~QmitkImageStatisticsReloadedView()
{
if (m_selectedPlanarFigure)
m_selectedPlanarFigure->RemoveObserver(m_PlanarFigureObserverTag);
}
void QmitkImageStatisticsReloadedView::CreateQtPartControl(QWidget *parent)
{
m_Controls.setupUi(parent);
m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
m_Controls.widget_intensityProfile->SetTheme(this->GetColorTheme());
m_Controls.groupBox_histogram->setVisible(true);
m_Controls.groupBox_intensityProfile->setVisible(false);
m_Controls.label_currentlyComputingStatistics->setVisible(false);
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<mitk::StatisticsContainer::ConstPointer>& statistics)
{
m_Controls.widget_statistics->Reset();
m_Controls.widget_statistics->SetStatistics(statistics);
m_Controls.widget_statistics->SetImageNodes({ m_selectedImageNode });
if (m_selectedMaskNode) {
m_Controls.widget_statistics->SetMaskNodes({ m_selectedMaskNode });
}
m_Controls.widget_statistics->setEnabled(true);
}
void QmitkImageStatisticsReloadedView::FillHistogramWidget(const std::vector<HistogramType::ConstPointer>& histogram, const std::vector<std::string>& dataLabels)
{
m_Controls.groupBox_histogram->setVisible(true);
m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
m_Controls.widget_histogram->Reset();
m_Controls.widget_histogram->SetHistogram(histogram.front(), dataLabels.front());
connect(m_Controls.widget_histogram, &QmitkHistogramVisualizationWidget::RequestHistogramUpdate, this, &QmitkImageStatisticsReloadedView::OnRequestHistogramUpdate);
}
QmitkChartWidget::ChartStyle QmitkImageStatisticsReloadedView::GetColorTheme() const
{
ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
if (styleManagerRef)
{
auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
if (styleManager->GetStyle().name == "Dark") {
return QmitkChartWidget::ChartStyle::darkstyle;
}
else {
return QmitkChartWidget::ChartStyle::lightstyle;
}
}
return QmitkChartWidget::ChartStyle::darkstyle;
}
void QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged()
{
if (this->m_selectedPlanarFigure)
{
this->m_selectedPlanarFigure->RemoveObserver(this->m_PlanarFigureObserverTag);
this->m_selectedPlanarFigure = nullptr;
}
m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
m_selectedMaskNode = m_Controls.maskImageSelector->GetSelectedNode();
m_Controls.groupBox_intensityProfile->setVisible(false);
//m_statisticContainerRules.clear();
if (m_selectedImageNode != nullptr) {
auto image = dynamic_cast<mitk::Image*>(m_selectedImageNode->GetData());
mitk::Image::Pointer mask = nullptr;
mitk::PlanarFigure::Pointer maskPlanarFigure = nullptr;
if (m_selectedMaskNode != nullptr) {
mask = dynamic_cast<mitk::Image*>(m_selectedMaskNode->GetData());
if (mask == nullptr) {
maskPlanarFigure = dynamic_cast<mitk::PlanarFigure*>(m_selectedMaskNode->GetData());
}
}
if (mask) {
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<mitk::DataNode::Pointer> &nodes )
{
Q_UNUSED(part);
Q_UNUSED(nodes);
}
void QmitkImageStatisticsReloadedView::PrepareDataStorageComboBoxes()
{
auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
auto isImagePredicate = mitk::GetImageStatisticsImagePredicate();
auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
m_Controls.imageSelector->SetDataStorage(GetDataStorage());
m_Controls.imageSelector->SetPredicate(isImagePredicate);
m_Controls.maskImageSelector->SetDataStorage(GetDataStorage());
m_Controls.maskImageSelector->SetPredicate(isMaskOrPlanarFigurePredicate);
m_Controls.maskImageSelector->SetZeroEntryText("<none>");
}
void QmitkImageStatisticsReloadedView::Activated()
{
}
void QmitkImageStatisticsReloadedView::Deactivated()
{
}
void QmitkImageStatisticsReloadedView::Visible()
{
connect(m_Controls.imageSelector, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
connect(m_Controls.maskImageSelector, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
if (m_selectedImageNode) {
OnImageOrMaskSelectorChanged();
}
else {
ResetGUI();
}
}
void QmitkImageStatisticsReloadedView::Hidden()
{
m_Controls.imageSelector->disconnect();
m_Controls.maskImageSelector->disconnect();
}
void QmitkImageStatisticsReloadedView::SetFocus()
{
}