diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
index b5d13b3c8a..c712e44695 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
@@ -1,502 +1,528 @@
QmitknnUNetToolGUIControls
0
0
192
352
0
0
100
0
100000
100000
QmitknnUNetToolWidget
0
0
0
0
-
-
-
+
+
-
+
+
+
+ 0
+ 0
+
+
+
+ true
+
+
+ Qt::AutoText
+
+
+
+Welcome to the nnUNet in MITK.
+Please note that this is only an interface to the nnUNet. MITK doesn't ship nnUNet with it. Make sure have a working Python environment with nnUNetset up beforehand. Choose that environment in the Python Path before inferencing.
+Refer: https://github.com/MIC-DKFZ/nnUNet to know everything about the nnUNet.
+
+
+
+
+
+
+ -
0
0
nnUNet Results Folder:
- -
+
-
- -
+
-
Refresh Results Folder
- -
+
-
Configuration:
- -
+
-
- -
+
-
0
0
Task:
- -
+
-
- -
+
-
0
0
Trainer:
- -
+
-
- -
+
-
0
0
Plan:
- -
+
-
- -
+
-
Fold:
- -
+
-
- -
+
-
Stop
- -
+
-
0
0
Multi-Modal:
- -
+
-
- -
+
-
0
0
No. of Extra Modalities:
- -
+
-
- -
+
-
0
0
Reference Image Position
- -
+
-
-
0
0
5
Advanced
true
true
Qt::AlignRight
-
6
0
-
0
0
No Pip
-
-
0
0
Mixed Precision
-
true
-
0
0
GPU Id:
-
-
0
0
Enable Mirroring
-
true
-
0
0
Python Path:
-
-
0
0
nnUNet Path:
-
-
0
0
Use Postprocessing JSON
-
true
-
0
0
Enable Caching
-
true
-
Clear Cache
-
0
0
Cached Items: 0
-
0
0
100000
16777215
Preview
-
0
0
ctkDirectoryButton
QWidget
1
ctkComboBox
QComboBox
1
ctkCheckableComboBox
QComboBox
1
ctkCheckBox
QCheckBox
1
ctkCollapsibleGroupBox
QGroupBox
1
\ No newline at end of file
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
index 869b47198a..d9bc390e39 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
@@ -1,447 +1,447 @@
#include "QmitknnUNetToolGUI.h"
#include
#include
#include
#include
#include
void QmitknnUNetToolGUI::EnableWidgets(bool enabled)
{
Superclass::EnableWidgets(enabled);
}
void QmitknnUNetToolGUI::ClearAllComboBoxes()
{
m_Controls.modelBox->clear();
m_Controls.taskBox->clear();
m_Controls.foldBox->clear();
m_Controls.trainerBox->clear();
for (std::unique_ptr &layout : m_EnsembleParams)
{
layout->modelBox->clear();
layout->trainerBox->clear();
layout->plannerBox->clear();
layout->foldBox->clear();
}
}
void QmitknnUNetToolGUI::OnRefreshPresssed()
{
const QString resultsFolder = m_Controls.modeldirectoryBox->directory();
OnDirectoryChanged(resultsFolder);
}
void QmitknnUNetToolGUI::OnDirectoryChanged(const QString &resultsFolder)
{
m_Controls.previewButton->setEnabled(false);
this->ClearAllComboBoxes();
m_ParentFolder = std::make_shared(resultsFolder);
auto models = m_ParentFolder->getModelNames();
std::for_each(models.begin(),
models.end(),
[this](QString model)
{
if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
m_Controls.modelBox->addItem(model);
});
}
void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
{
if (model.isEmpty())
{
return;
}
ctkComboBox *box = qobject_cast(sender());
if (box == m_Controls.modelBox)
{
m_Controls.taskBox->clear();
auto tasks = m_ParentFolder->getTasksForModel(model);
std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
}
else if (!m_EnsembleParams.empty())
{
for (std::unique_ptr &layout : m_EnsembleParams)
{
if (box == layout->modelBox)
{
layout->trainerBox->clear();
layout->plannerBox->clear();
QStringList trainerPlanners =
m_ParentFolder->getTrainerPlannersForTask(m_Controls.taskBox->currentText(), model);
QStringList trainers, planners;
std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
std::for_each(
trainers.begin(), trainers.end(), [&layout](QString trainer) { layout->trainerBox->addItem(trainer); });
std::for_each(
planners.begin(), planners.end(), [&layout](QString planner) { layout->plannerBox->addItem(planner); });
break;
}
}
}
}
void QmitknnUNetToolGUI::OnTaskChanged(const QString &task)
{
if (task.isEmpty())
{
return;
}
m_Controls.trainerBox->clear();
m_Controls.plannerBox->clear();
if (m_Controls.modelBox->currentText() == m_VALID_MODELS.last())
{
m_Controls.trainerBox->setVisible(false);
m_Controls.trainerLabel->setVisible(false);
m_Controls.plannerBox->setVisible(false);
m_Controls.plannerLabel->setVisible(false);
m_Controls.foldBox->setVisible(false);
m_Controls.foldLabel->setVisible(false);
ShowEnsembleLayout(true);
QStringList models = m_ParentFolder->getModelsForTask(m_Controls.taskBox->currentText());
models.removeDuplicates();
models.removeOne(m_VALID_MODELS.last());
for (std::unique_ptr &layout : m_EnsembleParams)
{
layout->modelBox->clear();
layout->trainerBox->clear();
layout->plannerBox->clear();
std::for_each(models.begin(),
models.end(),
[&layout, this](QString model)
{
if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
layout->modelBox->addItem(model);
});
}
m_Controls.previewButton->setEnabled(true);
}
else
{
m_Controls.trainerBox->setVisible(true);
m_Controls.trainerLabel->setVisible(true);
m_Controls.plannerBox->setVisible(true);
m_Controls.plannerLabel->setVisible(true);
m_Controls.foldBox->setVisible(true);
m_Controls.foldLabel->setVisible(true);
m_Controls.previewButton->setEnabled(false);
ShowEnsembleLayout(false);
QStringList trainerPlanners =
m_ParentFolder->getTrainerPlannersForTask(task, m_Controls.modelBox->currentText());
QStringList trainers, planners;
std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
std::for_each(
trainers.begin(), trainers.end(), [this](QString trainer) { m_Controls.trainerBox->addItem(trainer); });
std::for_each(
planners.begin(), planners.end(), [this](QString planner) { m_Controls.plannerBox->addItem(planner); });
}
}
void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
{
if (plannerSelected.isEmpty())
{
return;
}
ctkComboBox *box = qobject_cast(sender());
if (box == m_Controls.plannerBox)
{
m_Controls.foldBox->clear();
auto selectedTrainer = m_Controls.trainerBox->currentText();
auto selectedTask = m_Controls.taskBox->currentText();
auto selectedModel = m_Controls.modelBox->currentText();
auto folds = m_ParentFolder->getFoldsForTrainerPlanner(
selectedTrainer, plannerSelected, selectedTask, selectedModel);
std::for_each(folds.begin(),
folds.end(),
[this](QString fold)
{
if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
m_Controls.foldBox->addItem(fold);
});
if (m_Controls.foldBox->count() != 0)
{
CheckAllInCheckableComboBox(m_Controls.foldBox);
m_Controls.previewButton->setEnabled(true);
}
}
else if (!m_EnsembleParams.empty())
{
for (std::unique_ptr &layout : m_EnsembleParams)
{
if (box == layout->plannerBox)
{
layout->foldBox->clear();
auto selectedTrainer = layout->trainerBox->currentText();
auto selectedTask = m_Controls.taskBox->currentText();
auto selectedModel = layout->modelBox->currentText();
auto folds = m_ParentFolder->getFoldsForTrainerPlanner(
selectedTrainer, plannerSelected, selectedTask, selectedModel);
std::for_each(folds.begin(),
folds.end(),
[&layout](QString fold)
{
if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
layout->foldBox->addItem(fold);
});
if (layout->foldBox->count() != 0)
{
CheckAllInCheckableComboBox(layout->foldBox);
m_Controls.previewButton->setEnabled(true);
}
break;
}
}
}
}
void QmitknnUNetToolGUI::OnPythonPathChanged(const QString &pyEnv)
{
if (pyEnv == QString("Select"))
{
QString path =
QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
if (!path.isEmpty())
{
m_Controls.pythonEnvComboBox->insertItem(0, path);
m_Controls.pythonEnvComboBox->setCurrentIndex(0);
}
}
else if (!IsNNUNetInstalled(pyEnv))
{
std::string warning =
"WARNING: nnUNet is not detected on the Python environment you selected. Please select another "
"environment or create one. For more info refer https://github.com/MIC-DKFZ/nnUNet";
ShowErrorMessage(warning);
}
}
void QmitknnUNetToolGUI::OnCheckBoxChanged(int state)
{
bool visibility = false;
if (state == Qt::Checked)
{
visibility = true;
}
ctkCheckBox *box = qobject_cast(sender());
if (box != nullptr)
{
if (box->objectName() == QString("nopipBox"))
{
m_Controls.codedirectoryBox->setVisible(visibility);
m_Controls.nnUnetdirLabel->setVisible(visibility);
}
else if (box->objectName() == QString("multiModalBox"))
{
m_Controls.multiModalSpinLabel->setVisible(visibility);
m_Controls.multiModalSpinBox->setVisible(visibility);
m_Controls.posSpinBoxLabel->setVisible(visibility);
m_Controls.posSpinBox->setVisible(visibility);
if (visibility)
{
QmitkDataStorageComboBox *defaultImage = new QmitkDataStorageComboBox(this, true);
defaultImage->setObjectName(QString("multiModal_" + QString::number(0)));
defaultImage->SetPredicate(this->m_MultiModalPredicate);
defaultImage->setDisabled(true);
mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs();
if (tool != nullptr)
{
defaultImage->SetDataStorage(tool->GetDataStorage());
defaultImage->SetSelectedNode(tool->GetRefNode());
}
m_Controls.advancedSettingsLayout->addWidget(defaultImage, this->m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
m_Modalities.push_back(defaultImage);
m_Controls.posSpinBox->setMaximum(this->m_Modalities.size() - 1);
m_UI_ROWS++;
}
else
{
OnModalitiesNumberChanged(0);
m_Controls.multiModalSpinBox->setValue(0);
m_Controls.posSpinBox->setMaximum(0);
delete this->m_Modalities[0];
m_Modalities.pop_back();
}
}
}
}
void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
{
while (num > static_cast(this->m_Modalities.size() - 1))
{
QmitkDataStorageComboBox *multiModalBox = new QmitkDataStorageComboBox(this, true);
mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs();
multiModalBox->SetDataStorage(tool->GetDataStorage());
multiModalBox->SetPredicate(this->m_MultiModalPredicate);
multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
m_Controls.advancedSettingsLayout->addWidget(multiModalBox, this->m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
m_Modalities.push_back(multiModalBox);
}
while (num < static_cast(this->m_Modalities.size() - 1) && !m_Modalities.empty())
{
QmitkDataStorageComboBox *child = m_Modalities.back();
if (child->objectName() == "multiModal_0")
{
std::iter_swap(this->m_Modalities.end() - 2, this->m_Modalities.end() - 1);
child = m_Modalities.back();
}
delete child; // delete the layout item
m_Modalities.pop_back();
}
m_Controls.posSpinBox->setMaximum(this->m_Modalities.size() - 1);
m_Controls.advancedSettingsLayout->update();
}
void QmitknnUNetToolGUI::OnModalPositionChanged(int posIdx)
{
if (posIdx < static_cast(m_Modalities.size()))
{
int currPos = 0;
bool stopCheck = false;
// for-loop clears all widgets from the QGridLayout and also, finds the position of loaded-image widget.
for (QmitkDataStorageComboBox *multiModalBox : m_Modalities)
{
m_Controls.advancedSettingsLayout->removeWidget(multiModalBox);
multiModalBox->setParent(nullptr);
if (multiModalBox->objectName() != "multiModal_0" && !stopCheck)
{
currPos++;
}
else
{
stopCheck = true;
}
}
// moving the loaded-image widget to the required position
std::iter_swap(this->m_Modalities.begin() + currPos, m_Modalities.begin() + posIdx);
// re-adding all widgets in the order
for (int i = 0; i < static_cast(m_Modalities.size()); ++i)
{
QmitkDataStorageComboBox *multiModalBox = m_Modalities[i];
m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + i + 1, 1, 1, 3);
}
m_Controls.advancedSettingsLayout->update();
}
}
void QmitknnUNetToolGUI::AutoParsePythonPaths()
{
QString homeDir = QDir::homePath();
std::vector searchDirs;
#ifdef _WIN32
searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
QString("anaconda3"));
#else
// Add search locations for possible standard python paths here
searchDirs.push_back(homeDir + QDir::separator() + "environments");
searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
#endif
for (QString searchDir : searchDirs)
{
if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
{
if (QDir(searchDir).exists())
{
m_Controls.pythonEnvComboBox->insertItem(0, "(base): " + searchDir);
searchDir.append((QDir::separator() + QString("envs")));
}
}
for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
{
subIt.next();
QString envName = subIt.fileName();
if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
{
m_Controls.pythonEnvComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
}
}
}
m_Controls.pythonEnvComboBox->setCurrentIndex(-1);
}
mitk::ModelParams QmitknnUNetToolGUI::MapToRequest(const QString &modelName,
const QString &taskName,
const QString &trainer,
const QString &planId,
const std::vector &folds)
{
mitk::ModelParams requestObject;
requestObject.model = modelName.toStdString();
requestObject.trainer = trainer.toStdString();
requestObject.planId = planId.toStdString();
requestObject.task = taskName.toStdString();
requestObject.folds = folds;
mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs();
requestObject.inputName = tool->GetRefNode()->GetName();
requestObject.timeStamp = std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
return requestObject;
}
void QmitknnUNetToolGUI::SegmentationProcessFailed()
{
ShowStatusMessage(
"STATUS: Error in the segmentation process.
No resulting segmentation can be loaded.");
this->setCursor(Qt::ArrowCursor);
std::stringstream stream;
stream << "Error in the segmentation process. No resulting segmentation can be loaded.";
ShowErrorMessage(stream.str());
m_Controls.stopButton->setEnabled(false);
}
void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool)
{
tool->RenderOutputBuffer();
this->SetLabelSetPreview(tool->GetMLPreview());
//this->ClearOutputBuffer();
ShowStatusMessage("STATUS: Segmentation task finished successfully.
Please Confirm the "
"segmentation else, could result in data loss");
m_Controls.stopButton->setEnabled(false);
}
void QmitknnUNetToolGUI::ShowEnsembleLayout(bool visible)
{
if (m_EnsembleParams.empty())
{
ctkCollapsibleGroupBox *groupBoxModel1 = new ctkCollapsibleGroupBox(this);
auto lay1 = std::make_unique(groupBoxModel1);
groupBoxModel1->setObjectName(QString::fromUtf8("model_1_Box"));
groupBoxModel1->setTitle(QString::fromUtf8("Model 1"));
groupBoxModel1->setMinimumSize(QSize(0, 0));
groupBoxModel1->setCollapsedHeight(5);
groupBoxModel1->setCollapsed(false);
groupBoxModel1->setFlat(true);
groupBoxModel1->setAlignment(Qt::AlignRight);
- m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 3, 0, 1, 2);
+ m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 4, 0, 1, 2);
connect(lay1->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
connect(
lay1->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
m_EnsembleParams.push_back(std::move(lay1));
ctkCollapsibleGroupBox *groupBoxModel2 = new ctkCollapsibleGroupBox(this);
auto lay2 = std::make_unique(groupBoxModel2);
groupBoxModel2->setObjectName(QString::fromUtf8("model_2_Box"));
groupBoxModel2->setTitle(QString::fromUtf8("Model 2"));
groupBoxModel2->setMinimumSize(QSize(0, 0));
groupBoxModel2->setCollapsedHeight(5);
groupBoxModel2->setCollapsed(false);
groupBoxModel2->setFlat(true);
groupBoxModel2->setAlignment(Qt::AlignLeft);
- m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 3, 2, 1, 2);
+ m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 4, 2, 1, 2);
connect(lay2->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
connect(
lay2->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
m_EnsembleParams.push_back(std::move(lay2));
}
for (std::unique_ptr &layout : m_EnsembleParams)
{
layout->setVisible(visible);
}
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index 7fdb70c043..b26097ebce 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,809 +1,809 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkSegmentationView.h"
#include "mitkPluginActivator.h"
// blueberry
#include
// mitk
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// Qmitk
#include
#include
#include
// us
#include
#include
// Qt
#include
#include
const std::string QmitkSegmentationView::VIEW_ID = "org.mitk.views.segmentation";
QmitkSegmentationView::QmitkSegmentationView()
: m_Parent(nullptr)
, m_Controls(nullptr)
, m_RenderWindowPart(nullptr)
, m_ToolManager(nullptr)
, m_ReferenceNode(nullptr)
, m_WorkingNode(nullptr)
, m_AutoSelectionEnabled(false)
, m_MouseCursorSet(false)
{
mitk::TNodePredicateDataType::Pointer isImage = mitk::TNodePredicateDataType::New();
auto isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
auto isDti = mitk::NodePredicateDataType::New("TensorImage");
auto isOdf = mitk::NodePredicateDataType::New("OdfImage");
auto isSegment = mitk::NodePredicateDataType::New("Segment");
mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
validImages->AddPredicate(isDwi);
validImages->AddPredicate(isDti);
validImages->AddPredicate(isOdf);
auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
auto isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
auto validSegmentations = mitk::NodePredicateOr::New();
validSegmentations->AddPredicate(mitk::TNodePredicateDataType::New());
validSegmentations->AddPredicate(isMask);
m_SegmentationPredicate = mitk::NodePredicateAnd::New();
m_SegmentationPredicate->AddPredicate(validSegmentations);
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
m_ReferencePredicate = mitk::NodePredicateAnd::New();
m_ReferencePredicate->AddPredicate(validImages);
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
}
QmitkSegmentationView::~QmitkSegmentationView()
{
if (m_Controls)
{
// deactivate all tools
m_ToolManager->ActivateTool(-1);
// removing all observers
for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
{
(*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
}
m_WorkingDataObserverTags.clear();
mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference();
mitk::PlanePositionManagerService* service = context->getService(ppmRef);
service->RemoveAllPlanePositions();
context->ungetService(ppmRef);
m_ToolManager->SetReferenceData(nullptr);
m_ToolManager->SetWorkingData(nullptr);
}
delete m_Controls;
}
/**********************************************************************/
/* private Q_SLOTS */
/**********************************************************************/
void QmitkSegmentationView::OnReferenceSelectionChanged(QList nodes)
{
m_ToolManager->ActivateTool(-1);
if (nodes.empty())
{
m_Controls->segImageSelector->SetNodePredicate(m_SegmentationPredicate);
m_ReferenceNode = nullptr;
m_ToolManager->SetReferenceData(m_ReferenceNode);
this->UpdateGUI();
return;
}
m_ReferenceNode = nodes.first();
m_ToolManager->SetReferenceData(m_ReferenceNode);
if (m_ReferenceNode.IsNotNull())
{
// set a predicate such that a segmentation fits the selected reference image geometry
auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(),
mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()));
m_Controls->segImageSelector->SetNodePredicate(segPredicate);
if (m_AutoSelectionEnabled)
{
// hide all image nodes to later show only the automatically selected ones
mitk::DataStorage::SetOfObjects::ConstPointer imageNodes =
this->GetDataStorage()->GetSubset(m_ReferencePredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = imageNodes->begin(); iter != imageNodes->end(); ++iter)
{
(*iter)->SetVisibility(false);
}
}
m_ReferenceNode->SetVisibility(true);
}
this->UpdateGUI();
}
void QmitkSegmentationView::OnSegmentationSelectionChanged(QList nodes)
{
m_ToolManager->ActivateTool(-1);
// Remove observer if one was registered
auto finding = m_WorkingDataObserverTags.find(m_WorkingNode);
if (finding != m_WorkingDataObserverTags.end())
{
m_WorkingNode->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[m_WorkingNode]);
m_WorkingDataObserverTags.erase(m_WorkingNode);
}
if (nodes.empty())
{
m_WorkingNode = nullptr;
m_ToolManager->SetWorkingData(m_WorkingNode);
this->UpdateGUI();
return;
}
if (m_ReferenceNode.IsNull())
{
this->UpdateGUI();
return;
}
mitk::Image::ConstPointer referenceImage = dynamic_cast(m_ReferenceNode->GetData());
if (referenceImage.IsNull())
{
this->UpdateGUI();
return;
}
m_WorkingNode = nodes.first();
m_ToolManager->SetWorkingData(m_WorkingNode);
if (m_WorkingNode.IsNotNull())
{
if (m_AutoSelectionEnabled)
{
// hide all segmentation nodes to later show only the automatically selected ones
mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes =
this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
{
(*iter)->SetVisibility(false);
}
}
m_WorkingNode->SetVisibility(true);
auto command = itk::SimpleMemberCommand::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
m_WorkingDataObserverTags.insert(std::pair(m_WorkingNode,
m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
}
this->UpdateGUI();
}
void QmitkSegmentationView::CreateNewSegmentation()
{
mitk::DataNode::Pointer referenceNode = m_ToolManager->GetReferenceData(0);
if (referenceNode.IsNull())
{
MITK_ERROR << "'Create new segmentation' button should never be clickable unless a reference image is selected.";
return;
}
mitk::Image::ConstPointer referenceImage = dynamic_cast(referenceNode->GetData());
if (referenceImage.IsNull())
{
QMessageBox::information(
m_Parent, "New segmentation", "Please load and select an image before starting some action.");
return;
}
if (referenceImage->GetDimension() <= 1)
{
QMessageBox::information(m_Parent, "New segmentation", "Segmentation is currently not supported for 2D images");
return;
}
m_ToolManager->ActivateTool(-1);
const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
unsigned int imageTimeStep = 0;
if (referenceImage->GetTimeGeometry()->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = referenceImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
}
auto segTemplateImage = referenceImage;
if (referenceImage->GetDimension() > 3)
{
auto result = QMessageBox::question(m_Parent,
tr("Create a static or dynamic segmentation?"),
tr("The selected image has multiple time steps.\n\nDo you want to create a static "
"segmentation that is identical for all time steps or do you want to create a "
"dynamic segmentation to segment individual time steps?"),
tr("Create static segmentation"), tr("Create dynamic segmentation"),
QString(), 0, 0);
if (result == 0)
{
auto selector = mitk::ImageTimeSelector::New();
selector->SetInput(referenceImage);
selector->SetTimeNr(0);
selector->Update();
const auto refTimeGeometry = referenceImage->GetTimeGeometry();
auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
mitk::Image::Pointer newImage = selector->GetOutput();
newTimeGeometry->SetTimeStepGeometry(referenceImage->GetGeometry(imageTimeStep), 0);
newImage->SetTimeGeometry(newTimeGeometry);
segTemplateImage = newImage;
}
}
QString newName = QString::fromStdString(referenceNode->GetName());
newName.append("-labels");
// ask about the name and organ type of the new segmentation
auto dialog = new QmitkNewSegmentationDialog(m_Parent);
QStringList organColors = mitk::OrganNamesHandling::GetDefaultOrganColorString();
dialog->SetSuggestionList(organColors);
dialog->SetSegmentationName(newName);
int dialogReturnValue = dialog->exec();
if (dialogReturnValue == QDialog::Rejected)
{
return;
}
std::string newNodeName = dialog->GetSegmentationName().toStdString();
if (newNodeName.empty())
{
newNodeName = "Unnamed";
}
// create a new image of the same dimensions and smallest possible pixel type
auto firstTool = m_ToolManager->GetToolById(0);
if (nullptr == firstTool)
{
return;
}
mitk::DataNode::Pointer emptySegmentation = nullptr;
try
{
emptySegmentation = firstTool->CreateEmptySegmentationNode(segTemplateImage, newNodeName, dialog->GetColor());
}
catch (const std::bad_alloc &)
{
QMessageBox::warning(m_Parent, tr("New segmentation"), tr("Could not allocate memory for new segmentation"));
}
if (nullptr == emptySegmentation)
{
return; // could have been aborted by user
}
// initialize "showVolume"-property to false to prevent recalculating the volume while working on the segmentation
emptySegmentation->SetProperty("showVolume", mitk::BoolProperty::New(false));
mitk::OrganNamesHandling::UpdateOrganList(organColors, dialog->GetSegmentationName(), dialog->GetColor());
// escape ';' here (replace by '\;')
QString stringForStorage = organColors.replaceInStrings(";", "\\;").join(";");
MITK_DEBUG << "Will store: " << stringForStorage;
this->GetPreferences()->Put("Organ-Color-List", stringForStorage);
this->GetPreferences()->Flush();
this->GetDataStorage()->Add(emptySegmentation, referenceNode);
if (m_ToolManager->GetWorkingData(0))
{
m_ToolManager->GetWorkingData(0)->SetSelected(false);
}
emptySegmentation->SetSelected(true);
m_Controls->segImageSelector->SetCurrentSelectedNode(emptySegmentation);
}
void QmitkSegmentationView::OnManualTool2DSelected(int id)
{
this->ResetMouseCursor();
mitk::StatusBar::GetInstance()->DisplayText("");
if (id >= 0)
{
std::string text = "Active Tool: \"";
text += m_ToolManager->GetToolById(id)->GetName();
text += "\"";
mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
this->SetMouseCursor(resource, 0, 0);
}
}
void QmitkSegmentationView::OnShowMarkerNodes(bool state)
{
mitk::SegTool2D::Pointer manualSegmentationTool;
unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
for (unsigned int i = 0; i < numberOfExistingTools; i++)
{
manualSegmentationTool = dynamic_cast(m_ToolManager->GetToolById(i));
if (manualSegmentationTool)
{
if (state == true)
{
manualSegmentationTool->SetShowMarkerNodes(true);
}
else
{
manualSegmentationTool->SetShowMarkerNodes(false);
}
}
}
}
/**********************************************************************/
/* private */
/**********************************************************************/
void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
{
m_Parent = parent;
m_Controls = new Ui::QmitkSegmentationControls;
m_Controls->setupUi(parent);
m_Controls->patImageSelector->SetDataStorage(GetDataStorage());
m_Controls->patImageSelector->SetNodePredicate(m_ReferencePredicate);
m_Controls->patImageSelector->SetInvalidInfo("Select an image");
m_Controls->patImageSelector->SetPopUpTitel("Select an image");
m_Controls->patImageSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
m_Controls->segImageSelector->SetDataStorage(GetDataStorage());
m_Controls->segImageSelector->SetNodePredicate(m_SegmentationPredicate);
m_Controls->segImageSelector->SetInvalidInfo("Select a segmentation");
m_Controls->segImageSelector->SetPopUpTitel("Select a segmentation");
m_Controls->segImageSelector->SetPopUpHint("Select a segmentation that should be modified. Only segmentation with the same geometry and within the bounds of the reference image are selected.");
connect(m_Controls->patImageSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkSegmentationView::OnReferenceSelectionChanged);
connect(m_Controls->segImageSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkSegmentationView::OnSegmentationSelectionChanged);
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
m_ToolManager->InitializeTools();
QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' 'Live Wire' '2D Fast Marching'");
QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Fast Marching 3D' 'Region Growing 3D' Watershed Picking");
-//#ifdef __linux__
+#ifdef __linux__
segTools3D.append(" nnUNet"); // plugin not enabled for MacOS / Windows
-//#endif
+#endif
std::regex extSegTool2DRegEx("SegTool2D$");
std::regex extSegTool3DRegEx("SegTool3D$");
auto tools = m_ToolManager->GetTools();
for (const auto &tool : tools)
{
if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
{
segTools2D.append(QString(" '%1'").arg(tool->GetName()));
}
else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
{
segTools3D.append(QString(" '%1'").arg(tool->GetName()));
}
}
// all part of open source MITK
m_Controls->m_ManualToolSelectionBox2D->SetToolManager(*m_ToolManager);
m_Controls->m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
m_Controls->m_ManualToolSelectionBox2D->SetToolGUIArea(m_Controls->m_ManualToolGUIContainer2D);
m_Controls->m_ManualToolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
m_Controls->m_ManualToolSelectionBox2D->SetLayoutColumns(3);
m_Controls->m_ManualToolSelectionBox2D->SetEnabledMode(
QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
connect(m_Controls->m_ManualToolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected,
this, &QmitkSegmentationView::OnManualTool2DSelected);
//setup 3D Tools
m_Controls->m_ManualToolSelectionBox3D->SetToolManager(*m_ToolManager);
m_Controls->m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
m_Controls->m_ManualToolSelectionBox3D->SetToolGUIArea(m_Controls->m_ManualToolGUIContainer3D);
m_Controls->m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
m_Controls->m_ManualToolSelectionBox3D->SetLayoutColumns(3);
m_Controls->m_ManualToolSelectionBox3D->SetEnabledMode(
QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
// create signal/slot connections
connect(m_Controls->btnNewSegmentation, &QToolButton::clicked, this, &QmitkSegmentationView::CreateNewSegmentation);
connect(m_Controls->m_SlicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
auto command = itk::SimpleMemberCommand::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
m_RenderingManagerObserverTag =
mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
m_RenderWindowPart = this->GetRenderWindowPart();
if (nullptr != m_RenderWindowPart)
{
this->RenderWindowPartActivated(m_RenderWindowPart);
}
// Make sure the GUI notices if appropriate data is already present on creation.
// Should be done last, if everything else is configured because it triggers the autoselection of data.
m_Controls->patImageSelector->SetAutoSelectNewNodes(true);
m_Controls->segImageSelector->SetAutoSelectNewNodes(true);
this->UpdateGUI();
}
void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
if (m_RenderWindowPart != renderWindowPart)
{
m_RenderWindowPart = renderWindowPart;
}
if (m_Parent)
{
m_Parent->setEnabled(true);
}
// tell the interpolation about tool manager, data storage and render window part
if (m_Controls)
{
m_Controls->m_SlicesInterpolator->SetDataStorage(this->GetDataStorage());
QList controllers;
controllers.push_back(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
controllers.push_back(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
controllers.push_back(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
m_Controls->m_SlicesInterpolator->Initialize(m_ToolManager, controllers);
}
}
void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
m_RenderWindowPart = nullptr;
if (m_Parent)
{
m_Parent->setEnabled(false);
}
}
void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
{
if (m_Controls != nullptr)
{
bool slimView = prefs->GetBool("slim view", false);
m_Controls->m_ManualToolSelectionBox2D->SetShowNames(!slimView);
m_Controls->m_ManualToolSelectionBox3D->SetShowNames(!slimView);
}
m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
this->ApplyDisplayOptions();
}
void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
{
if (m_SegmentationPredicate->CheckNode(node))
{
this->ApplyDisplayOptions(const_cast(node));
}
}
void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
{
if (m_SegmentationPredicate->CheckNode(node))
{
// remove all possible contour markers of the segmentation
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(
node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference();
mitk::PlanePositionManagerService* service = context->getService(ppmRef);
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
{
std::string nodeName = node->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
service->RemovePlanePosition(id);
this->GetDataStorage()->Remove(it->Value());
}
context->ungetService(ppmRef);
service = nullptr;
mitk::Image* image = dynamic_cast(node->GetData());
mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
}
}
void QmitkSegmentationView::ApplyDisplayOptions()
{
if (!m_Parent)
{
return;
}
if (!m_Controls)
{
return; // might happen on initialization (preferences loaded)
}
mitk::DataNode::Pointer workingData = m_ToolManager->GetWorkingData(0);
mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
{
this->ApplyDisplayOptions(*iter);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
{
if (nullptr == node)
{
return;
}
auto drawOutline = mitk::BoolProperty::New(GetPreferences()->GetBool("draw outline", true));
auto labelSetImage = dynamic_cast(node->GetData());
if (nullptr != labelSetImage)
{
// node is actually a multi label segmentation,
// but its outline property can be set in the 'single label' segmentation preference page as well
node->SetProperty("labelset.contour.active", drawOutline);
// force render window update to show outline
node->GetData()->Modified();
}
else
{
// node is a 'single label' segmentation
bool isBinary = false;
node->GetBoolProperty("binary", isBinary);
if (isBinary)
{
node->SetProperty("outline binary", drawOutline);
node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
// force render window update to show outline
node->GetData()->Modified();
}
}
}
void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode* node)
{
QmitkRenderWindow* selectedRenderWindow = nullptr;
auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
auto* axialRenderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
auto* sagittalRenderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
auto* coronalRenderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
auto* _3DRenderWindow = renderWindowPart->GetQmitkRenderWindow("3d");
bool PlanarFigureInitializedWindow = false;
// find initialized renderwindow
if (node->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
{
selectedRenderWindow = axialRenderWindow;
}
if (!selectedRenderWindow && node->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
sagittalRenderWindow->GetRenderer()))
{
selectedRenderWindow = sagittalRenderWindow;
}
if (!selectedRenderWindow && node->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
coronalRenderWindow->GetRenderer()))
{
selectedRenderWindow = coronalRenderWindow;
}
if (!selectedRenderWindow && node->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
_3DRenderWindow->GetRenderer()))
{
selectedRenderWindow = _3DRenderWindow;
}
// make node visible
if (selectedRenderWindow)
{
std::string nodeName = node->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
{
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference();
mitk::PlanePositionManagerService* service = context->getService(ppmRef);
selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
context->ungetService(ppmRef);
}
selectedRenderWindow->GetRenderer()->GetCameraController()->Fit();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList& nodes)
{
if (nodes.size() != 0)
{
std::string markerName = "Position";
unsigned int numberOfNodes = nodes.size();
std::string nodeName = nodes.at(0)->GetName();
if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
{
this->OnContourMarkerSelected(nodes.at(0));
return;
}
}
}
void QmitkSegmentationView::ResetMouseCursor()
{
if (m_MouseCursorSet)
{
mitk::ApplicationCursor::GetInstance()->PopCursor();
m_MouseCursorSet = false;
}
}
void QmitkSegmentationView::SetMouseCursor(const us::ModuleResource& resource, int hotspotX, int hotspotY)
{
// Remove previously set mouse cursor
if (m_MouseCursorSet)
this->ResetMouseCursor();
if (resource)
{
us::ModuleResourceStream cursor(resource, std::ios::binary);
mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
m_MouseCursorSet = true;
}
}
void QmitkSegmentationView::UpdateGUI()
{
mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
bool hasReferenceNode = referenceNode != nullptr;
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
bool hasWorkingNode = workingNode != nullptr;
m_Controls->btnNewSegmentation->setEnabled(false);
m_Controls->m_SlicesInterpolator->setEnabled(false);
if (hasReferenceNode)
{
m_Controls->btnNewSegmentation->setEnabled(true);
}
if (hasWorkingNode && hasReferenceNode)
{
m_Controls->m_SlicesInterpolator->setEnabled(true);
int layer = -1;
referenceNode->GetIntProperty("layer", layer);
workingNode->SetIntProperty("layer", layer + 1);
}
this->ValidateSelectionInput();
}
void QmitkSegmentationView::ValidateSelectionInput()
{
this->UpdateWarningLabel("");
// the argument is actually not used
// enable status depends on the tool manager selection
m_Controls->m_ManualToolSelectionBox2D->setEnabled(false);
m_Controls->m_ManualToolSelectionBox3D->setEnabled(false);
mitk::DataNode* referenceNode = m_Controls->patImageSelector->GetSelectedNode();
mitk::DataNode* workingNode = m_Controls->segImageSelector->GetSelectedNode();
if (nullptr == referenceNode)
{
return;
}
if (nullptr == workingNode)
{
return;
}
mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
auto workingNodeIsVisible = renderWindowPart &&
workingNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
if (!workingNodeIsVisible)
{
this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
return;
}
/*
* Here we check whether the geometry of the selected segmentation image is aligned with the worldgeometry.
* At the moment it is not supported to use a geometry different from the selected image for reslicing.
* For further information see Bug 16063
*/
const mitk::BaseGeometry *workingNodeGeo = workingNode->GetData()->GetGeometry();
const mitk::BaseGeometry *worldGeo =
renderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
if (nullptr != workingNodeGeo && nullptr != worldGeo)
{
if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
{
m_ToolManager->SetReferenceData(referenceNode);
m_ToolManager->SetWorkingData(workingNode);
m_Controls->m_ManualToolSelectionBox2D->setEnabled(true);
m_Controls->m_ManualToolSelectionBox3D->setEnabled(true);
return;
}
}
m_ToolManager->SetReferenceData(referenceNode);
m_ToolManager->SetWorkingData(nullptr);
this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
}
void QmitkSegmentationView::UpdateWarningLabel(QString text)
{
if (text.size() == 0)
{
m_Controls->lblSegmentationWarnings->hide();
}
else
{
m_Controls->lblSegmentationWarnings->show();
}
m_Controls->lblSegmentationWarnings->setText("" + text + "");
}