diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
index 435ff2869c..c4f963c8e0 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
@@ -1,155 +1,163 @@
-/*===================================================================
-
-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 "QmitkImageStatisticsTableModel.h"
-
-QmitkImageStatisticsTableModel::QmitkImageStatisticsTableModel(QObject *parent) :
-QAbstractTableModel(parent)
-{}
-
-int QmitkImageStatisticsTableModel::rowCount(const QModelIndex &parent) const
-{
- if (parent.isValid())
- {
- return 0;
- }
-
- if (!m_statistics.empty()){
- return static_cast<int>(m_statistics.front()->GetStatisticsAsOrderedVector().size());
- }
- else
- {
- return 0;
- }
-}
-
-int QmitkImageStatisticsTableModel::columnCount(const QModelIndex &parent) const
-{
- if (parent.isValid())
- return 0;
-
- return static_cast<int>(m_statistics.size());
-}
-
-QVariant QmitkImageStatisticsTableModel::data(const QModelIndex &index, int role) const
-{
- if (!index.isValid())
- return QVariant();
-
- QVariant result;
- if (m_viewMode == viewMode::imageXStatistic) {
- if (!m_statistics.empty() && index.row() < m_statistics.front()->GetStatisticsAsMap().size() && index.column() < m_statistics.size())
- {
- if (Qt::DisplayRole == role)
- {
- result = QVariant(m_statistics.at(index.column())->GetStatisticsAsOrderedVector().at(index.row()).second);
- }
- else if (Qt::UserRole == role)
- {
- result = QVariant(index.row());
- }
-
- }
- }
-
- return result;
-}
-
-Qt::ItemFlags QmitkImageStatisticsTableModel::flags(const QModelIndex &index) const
-{
- Qt::ItemFlags flags = QAbstractItemModel::flags(index);
-
- return flags;
-}
-
-QVariant QmitkImageStatisticsTableModel::headerData(int section, Qt::Orientation orientation, int role) const
-{
-
- if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
- {
- if (!m_imageNodes.empty()) {
- if (m_viewMode == viewMode::imageXStatistic) {
- std::string maskName;
- if (!m_maskNodes.empty() && m_maskNodes.size() == m_imageNodes.size()) {
- maskName = " / " + m_maskNodes.at(section)->GetName();
- }
- return QVariant((m_imageNodes.at(section)->GetName() + maskName).c_str());
- }
- }
- }
- else if ((Qt::DisplayRole == role) && (Qt::Vertical == orientation)){
- if (!m_statistics.empty()) {
- if (m_viewMode == viewMode::imageXStatistic) {
- return QVariant(m_statisticNames.at(section).c_str());
- }
- }
- }
- return QVariant();
-}
-
-void QmitkImageStatisticsTableModel::SetStatistics(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics)
-{
- emit beginResetModel();
- m_statistics = statistics;
-
- if (m_statisticNames.empty() && !statistics.empty()) {
- auto firstStatisticAsMap = statistics.front()->GetStatisticsAsOrderedVector();
- for (const auto& keyValue : firstStatisticAsMap) {
- m_statisticNames.push_back(keyValue.first);
- }
- }
- emit endResetModel();
- emit dataChanged(QModelIndex(), QModelIndex());
-}
-
-void QmitkImageStatisticsTableModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
-{
- m_imageNodes = nodes;
-}
-
-void QmitkImageStatisticsTableModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
-{
- m_maskNodes = nodes;
-}
-
-void QmitkImageStatisticsTableModel::SetViewMode(viewMode m)
-{
- m_viewMode = m;
-}
-
-void QmitkImageStatisticsTableModel::SetStatisticsToShow(const std::vector<std::string>& statisticNames)
-{
- m_statisticNamesToShow = statisticNames;
-}
-
-void QmitkImageStatisticsTableModel::SetStatisticsToIgnore(const std::vector<std::string>& statisticNames)
-{
- m_statisticNamesToIgnore = statisticNames;
-}
-
-void QmitkImageStatisticsTableModel::Clear()
-{
- emit beginResetModel();
- m_statistics.clear();
- m_imageNodes.clear();
- m_maskNodes.clear();
- m_statisticNamesToIgnore.clear();
- m_statisticNamesToShow.clear();
- m_statisticNames.clear();
- emit endResetModel();
- emit dataChanged(QModelIndex(), QModelIndex());
-}
-
+/*===================================================================
+
+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 "QmitkImageStatisticsTableModel.h"
+
+QmitkImageStatisticsTableModel::QmitkImageStatisticsTableModel(QObject *parent) :
+QAbstractTableModel(parent)
+{}
+
+int QmitkImageStatisticsTableModel::rowCount(const QModelIndex &parent) const
+{
+ if (parent.isValid())
+ {
+ return 0;
+ }
+
+ if (!m_statistics.empty()){
+ return static_cast<int>(m_statistics.front()->GetStatisticsAsOrderedVector().size());
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+int QmitkImageStatisticsTableModel::columnCount(const QModelIndex &parent) const
+{
+ if (parent.isValid())
+ return 0;
+
+ return static_cast<int>(m_statistics.size());
+}
+
+QVariant QmitkImageStatisticsTableModel::data(const QModelIndex &index, int role) const
+{
+ if (!index.isValid())
+ return QVariant();
+
+ QVariant result;
+ if (m_viewMode == viewMode::imageXStatistic) {
+ if (!m_statistics.empty() && index.row() < m_statistics.front()->GetStatisticsAsMap().size() && index.column() < m_statistics.size())
+ {
+ if (Qt::DisplayRole == role)
+ {
+ result = QVariant(m_statistics.at(index.column())->GetStatisticsAsOrderedVector().at(index.row()).second);
+ }
+ else if (Qt::UserRole == role)
+ {
+ result = QVariant(index.row());
+ }
+
+ }
+ }
+
+ return result;
+}
+
+Qt::ItemFlags QmitkImageStatisticsTableModel::flags(const QModelIndex &index) const
+{
+ Qt::ItemFlags flags = QAbstractItemModel::flags(index);
+
+ return flags;
+}
+
+QVariant QmitkImageStatisticsTableModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+ if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
+ {
+ if (!m_imageNodes.empty()) {
+ if (m_viewMode == viewMode::imageXStatistic) {
+ std::string maskName;
+ if (!m_maskNodes.empty() && m_maskNodes.size() == m_imageNodes.size()) {
+ maskName = " / " + m_maskNodes.at(section)->GetName();
+ }
+ return QVariant((m_imageNodes.at(section)->GetName() + maskName + std::to_string(section)).c_str());
+ }
+ }
+ }
+ else if ((Qt::DisplayRole == role) && (Qt::Vertical == orientation)){
+ if (!m_statistics.empty()) {
+ if (m_viewMode == viewMode::imageXStatistic) {
+ return QVariant(m_statisticNames.at(section).c_str());
+ }
+ }
+ }
+ return QVariant();
+}
+
+void QmitkImageStatisticsTableModel::SetStatistics(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics)
+{
+ emit beginResetModel();
+ m_statistics = statistics;
+
+ if (m_statisticNames.empty() && !statistics.empty()) {
+ auto firstStatisticAsMap = statistics.front()->GetStatisticsAsOrderedVector();
+ for (const auto& keyValue : firstStatisticAsMap) {
+ m_statisticNames.push_back(keyValue.first);
+ }
+ }
+ emit endResetModel();
+ emit dataChanged(QModelIndex(), QModelIndex());
+}
+
+void QmitkImageStatisticsTableModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
+{
+ std::vector<mitk::DataNode::ConstPointer> tempNodes;
+ for (int i = 0; i < nodes.size(); i++)
+ {
+ int timeSteps = nodes.at(i)->GetData()->GetTimeSteps();
+ for (int j = 0; j < timeSteps; j++)
+ {
+ tempNodes.push_back(nodes.at(i));
+ }
+ }
+ m_imageNodes = tempNodes;
+}
+
+void QmitkImageStatisticsTableModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
+{
+ m_maskNodes = nodes;
+}
+
+void QmitkImageStatisticsTableModel::SetViewMode(viewMode m)
+{
+ m_viewMode = m;
+}
+
+void QmitkImageStatisticsTableModel::SetStatisticsToShow(const std::vector<std::string>& statisticNames)
+{
+ m_statisticNamesToShow = statisticNames;
+}
+
+void QmitkImageStatisticsTableModel::SetStatisticsToIgnore(const std::vector<std::string>& statisticNames)
+{
+ m_statisticNamesToIgnore = statisticNames;
+}
+
+void QmitkImageStatisticsTableModel::Clear()
+{
+ emit beginResetModel();
+ m_statistics.clear();
+ m_imageNodes.clear();
+ m_maskNodes.clear();
+ m_statisticNamesToIgnore.clear();
+ m_statisticNamesToShow.clear();
+ m_statisticNames.clear();
+ emit endResetModel();
+ emit dataChanged(QModelIndex(), QModelIndex());
+}
+
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 195de154e2..70230b0008 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
@@ -1,301 +1,300 @@
/*===================================================================
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"
// berry includes
#include <berryWorkbenchPlugin.h>
#include <berryIQtStyleManager.h>
#include <QmitkChartWidget.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateNot.h>
#include <mitkStatusBar.h>
#include <mitkIntensityProfile.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);
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);
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) {
//compute statistics with given mask
CalculateStatistics(image, mask);
}
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());
}
//for all planar figures: compute statistics with planarFigure as mask
CalculateStatistics(image, maskPlanarFigure);
}
else {
//compute statistics with image only
CalculateStatistics(image);
}
}
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()) {
this->FillStatisticsWidget(m_CalculationThread->GetStatisticsData());
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);
}
}
void QmitkImageStatisticsReloadedView::OnRequestHistogramUpdate(unsigned int nBins)
{
m_CalculationThread->SetHistogramNBins(nBins);
m_CalculationThread->start();
}
void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::Image::Pointer mask)
{
CalculateStatisticsInternal(image, mask);
}
void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::PlanarFigure::Pointer mask) {
CalculateStatisticsInternal(image, nullptr, mask);
}
void QmitkImageStatisticsReloadedView::CalculateStatisticsInternal(mitk::Image::Pointer image, mitk::Image::Pointer mask, mitk::PlanarFigure::Pointer maskPlanarFigure)
{
this->m_StatisticsUpdatePending = true;
this->m_CalculationThread->Initialize(image, mask, maskPlanarFigure);
- this->m_CalculationThread->SetTimeStep(0);
try
{
// Compute statistics
this->m_CalculationThread->start();
}
catch (const mitk::Exception& e)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(e.GetDescription());
this->m_StatisticsUpdatePending = false;
}
catch (const std::runtime_error &e)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
this->m_StatisticsUpdatePending = false;
}
catch (const std::exception &e)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
this->m_StatisticsUpdatePending = false;
}
}
void QmitkImageStatisticsReloadedView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
const QList<mitk::DataNode::Pointer> &nodes )
{
}
void QmitkImageStatisticsReloadedView::PrepareDataStorageComboBoxes()
{
auto isImage = mitk::NodePredicateDataType::New("Image");
auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
auto isNoBinary = mitk::NodePredicateNot::New(isBinary);
auto isBinaryImage = mitk::NodePredicateAnd::New(isImage, isBinary);
auto isNoBinaryImage = mitk::NodePredicateAnd::New(isImage, isNoBinary);
auto isPlanarFigure = GetPlanarFigurePredicate();
auto isBinaryImageOrPlanarFigure = mitk::NodePredicateOr::New(isBinaryImage, isPlanarFigure);
m_Controls.imageSelector->SetDataStorage(GetDataStorage());
m_Controls.imageSelector->SetPredicate(isNoBinaryImage);
m_Controls.maskImageSelector->SetDataStorage(GetDataStorage());
m_Controls.maskImageSelector->SetPredicate(isBinaryImageOrPlanarFigure);
m_Controls.maskImageSelector->SetZeroEntryText("<none>");
}
mitk::NodePredicateBase::Pointer QmitkImageStatisticsReloadedView::GetPlanarFigurePredicate() const
{
auto isPlanarCircle = mitk::NodePredicateDataType::New("PlanarCircle");
auto isPlanarRectangle = mitk::NodePredicateDataType::New("PlanarRectangle");
auto isPlanarEllipse = mitk::NodePredicateDataType::New("PlanarEllipse");
auto isPlanarDoubleEllipse = mitk::NodePredicateDataType::New("PlanarDoubleEllipse");
auto isPlanarPolygon = mitk::NodePredicateDataType::New("PlanarPolygon");
auto isPlanarSubdivisionPolygon = mitk::NodePredicateDataType::New("PlanarSubdivisionPolygon");
auto isPlanarBezierCurve = mitk::NodePredicateDataType::New("PlanarBezierCurve");
auto isPlanarLine = mitk::NodePredicateDataType::New("PlanarLine");
auto isPlanarFigure = mitk::NodePredicateOr::New(isPlanarCircle, isPlanarEllipse);
isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarRectangle);
isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarDoubleEllipse);
isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarPolygon);
isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarSubdivisionPolygon);
isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarBezierCurve);
isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarLine);
return isPlanarFigure.GetPointer();
}
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()
{
}