diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
index 62bb93b4fd..762e8e5dee 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
@@ -1,1189 +1,1168 @@
/*============================================================================
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 "QmitkMultiLabelSegmentationView.h"
#include "mitkPluginActivator.h"
// blueberry
#include <berryIWorkbenchPage.h>
// mitk
#include <mitkApplicationCursor.h>
#include <mitkInteractionEventObserver.h>
#include <mitkImageTimeSelector.h>
#include <mitkLabelSetImage.h>
#include <mitkNodePredicateSubGeometry.h>
#include <mitkPlanePositionManager.h>
#include <mitkStatusBar.h>
#include <mitkToolManagerProvider.h>
// Qmitk
#include "QmitkCreateMultiLabelPresetAction.h"
#include "QmitkLoadMultiLabelPresetAction.h"
#include <QmitkNewSegmentationDialog.h>
#include <QmitkRenderWindow.h>
#include <QmitkSegmentationOrganNamesHandling.cpp>
#include <QmitkStyleManager.h>
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
// Qt
#include <QInputDialog>
#include <QMessageBox>
#include <QShortcut>
#include <itksys/SystemTools.hxx>
#include <regex>
const std::string QmitkMultiLabelSegmentationView::VIEW_ID = "org.mitk.views.multilabelsegmentation";
QmitkMultiLabelSegmentationView::QmitkMultiLabelSegmentationView()
: m_Parent(nullptr),
m_RenderWindowPart(nullptr),
m_ToolManager(nullptr),
m_ReferenceNode(nullptr),
m_WorkingNode(nullptr),
m_AutoSelectionEnabled(false),
m_MouseCursorSet(false)
{
auto isImage = mitk::TNodePredicateDataType<mitk::Image>::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");
auto 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<mitk::LabelSetImage>::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")));
}
QmitkMultiLabelSegmentationView::~QmitkMultiLabelSegmentationView()
{
OnLooseLabelSetConnection();
// 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);
m_ToolManager->SetReferenceData(nullptr);
m_ToolManager->SetWorkingData(nullptr);
}
/**********************************************************************/
/* private Q_SLOTS */
/**********************************************************************/
void QmitkMultiLabelSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
{
m_ToolManager->ActivateTool(-1);
if (nodes.empty())
{
m_Controls.m_WorkingNodeSelector->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.m_WorkingNodeSelector->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 QmitkMultiLabelSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> 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<mitk::Image *>(m_ReferenceNode->GetData());
if (referenceImage.IsNull())
{
this->UpdateGUI();
return;
}
if (m_WorkingNode.IsNotNull())
{
this->OnLooseLabelSetConnection();
}
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);
this->OnEstablishLabelSetConnection();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
auto command = itk::SimpleMemberCommand<QmitkMultiLabelSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkMultiLabelSegmentationView::ValidateSelectionInput);
m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode *, unsigned long>(m_WorkingNode,
m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
}
this->UpdateGUI();
}
void QmitkMultiLabelSegmentationView::OnVisibilityShortcutActivated()
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
bool isVisible = false;
workingNode->GetBoolProperty("visible", isVisible);
workingNode->SetVisibility(!isVisible);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkMultiLabelSegmentationView::OnLabelToggleShortcutActivated()
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
WaitCursorOn();
workingImage->GetActiveLabelSet()->SetNextActiveLabel();
workingImage->Modified();
WaitCursorOff();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkMultiLabelSegmentationView::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 QmitkMultiLabelSegmentationView::OnNewLabel()
{
m_ToolManager->ActivateTool(-1);
if (m_ReferenceNode.IsNull())
{
QMessageBox::information(
m_Parent, "New Segmentation", "Please load and select an image before starting some action.");
return;
}
mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image *>(m_ReferenceNode->GetData());
if (referenceImage.IsNull())
{
QMessageBox::information(
m_Parent, "New segmentation", "Reference data needs to be an image in order to create a new segmentation.");
return;
}
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
if (!workingNode)
{
QMessageBox::information(
m_Parent, "New segmentation", "Please load and select a multilabel segmentation before starting some action.");
return;
}
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (!workingImage)
{
QMessageBox::information(
m_Parent, "New segmentation", "Please load and select a multilabel segmentation before starting some action.");
return;
}
// 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->setWindowTitle("New Label");
int dialogReturnValue = dialog->exec();
if (dialogReturnValue == QDialog::Rejected)
{
return;
}
QString segName = dialog->GetSegmentationName();
if (segName.isEmpty())
{
segName = "Unnamed";
}
workingImage->GetActiveLabelSet()->AddLabel(segName.toStdString(), dialog->GetColor());
UpdateGUI();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnSavePreset()
{
QmitkAbstractNodeSelectionWidget::NodeList nodes;
nodes.append(m_WorkingNode);
QmitkCreateMultiLabelPresetAction action;
action.Run(nodes);
}
void QmitkMultiLabelSegmentationView::OnLoadPreset()
{
QmitkAbstractNodeSelectionWidget::NodeList nodes;
nodes.append(m_WorkingNode);
QmitkLoadMultiLabelPresetAction action;
action.Run(nodes);
}
void QmitkMultiLabelSegmentationView::OnShowLabelTable(bool value)
{
if (value)
m_Controls.m_LabelSetWidget->show();
else
m_Controls.m_LabelSetWidget->hide();
}
void QmitkMultiLabelSegmentationView::OnNewSegmentationSession()
{
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<mitk::Image *>(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;
}
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");
bool ok = false;
newName = QInputDialog::getText(m_Parent, "New segmentation", "New name:", QLineEdit::Normal, newName, &ok);
if (!ok)
{
return;
}
if (newName.isEmpty())
{
newName = "Unnamed";
}
this->WaitCursorOn();
mitk::LabelSetImage::Pointer workingImage = mitk::LabelSetImage::New();
try
{
workingImage->Initialize(segTemplateImage);
}
catch (mitk::Exception& e)
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(m_Parent, tr("New segmentation"), tr("Could not create a new segmentation.\n"));
return;
}
this->WaitCursorOff();
mitk::DataNode::Pointer workingNode = mitk::DataNode::New();
workingNode->SetData(workingImage);
workingNode->SetName(newName.toStdString());
workingImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(referenceNode->GetName().c_str()));
workingImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New(newName.toStdString().c_str()));
this->GetDataStorage()->Add(workingNode, referenceNode);
m_Controls.m_WorkingNodeSelector->SetCurrentSelectedNode(workingNode);
OnNewLabel();
}
void QmitkMultiLabelSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
{
if (m_RenderWindowPart)
m_RenderWindowPart->SetSelectedPosition(pos);
}
void QmitkMultiLabelSegmentationView::OnResetView()
{
if (m_RenderWindowPart)
m_RenderWindowPart->ForceImmediateUpdate();
}
void QmitkMultiLabelSegmentationView::OnAddLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
QString question = "Do you really want to add a layer to the current segmentation session?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
m_Controls.m_LabelSetWidget, "Add layer", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton != QMessageBox::Yes) return;
try
{
WaitCursorOn();
workingImage->AddLayer();
WaitCursorOff();
}
catch ( mitk::Exception& e )
{
WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(
m_Controls.m_LabelSetWidget, "Add Layer", "Could not add a new layer. See error log for details.\n");
return;
}
OnNewLabel();
}
void QmitkMultiLabelSegmentationView::OnDeleteLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
if (workingImage->GetNumberOfLayers() < 2)
return;
QString question = "Do you really want to delete the current layer?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
m_Controls.m_LabelSetWidget, "Delete layer", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton != QMessageBox::Yes)
{
return;
}
try
{
this->WaitCursorOn();
workingImage->RemoveLayer();
this->WaitCursorOff();
}
catch (mitk::Exception& e)
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(m_Controls.m_LabelSetWidget, "Delete Layer",
"Could not delete the currently active layer. See error log for details.\n");
return;
}
UpdateGUI();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnPreviousLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
OnChangeLayer(workingImage->GetActiveLayer() - 1);
}
void QmitkMultiLabelSegmentationView::OnNextLayer()
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
OnChangeLayer(workingImage->GetActiveLayer() + 1);
}
void QmitkMultiLabelSegmentationView::OnChangeLayer(int layer)
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
this->WaitCursorOn();
workingImage->SetActiveLayer(layer);
this->WaitCursorOff();
UpdateGUI();
m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
}
void QmitkMultiLabelSegmentationView::OnLockExteriorToggled(bool checked)
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
workingImage->GetLabel(0)->SetLocked(checked);
}
void QmitkMultiLabelSegmentationView::OnInterpolationSelectionChanged(int index)
{
if (index == 1)
{
m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);//OnToggleWidgetActivation(false);
m_Controls.m_swInterpolation->setCurrentIndex(0);
m_Controls.m_swInterpolation->show();
}
else if (index == 2)
{
m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
m_Controls.m_swInterpolation->setCurrentIndex(1);
m_Controls.m_swInterpolation->show();
}
else
{
m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
m_Controls.m_swInterpolation->setCurrentIndex(2);
m_Controls.m_swInterpolation->hide();
}
}
/**********************************************************************/
/* private */
/**********************************************************************/
void QmitkMultiLabelSegmentationView::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
m_Controls.setupUi(parent);
m_Controls.m_tbSavePreset->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg")));
m_Controls.m_tbLoadPreset->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg")));
// *------------------------
// * Shortcuts
// *------------------------
QShortcut* visibilityShortcut = new QShortcut(QKeySequence("CTRL+H"), parent);
connect(visibilityShortcut, &QShortcut::activated, this, &QmitkMultiLabelSegmentationView::OnVisibilityShortcutActivated);
QShortcut* labelToggleShortcut = new QShortcut(QKeySequence("CTRL+L"), parent);
connect(labelToggleShortcut, &QShortcut::activated, this, &QmitkMultiLabelSegmentationView::OnLabelToggleShortcutActivated);
// *------------------------
// * DATA SELECTION WIDGETS
// *------------------------
m_Controls.m_ReferenceNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.m_ReferenceNodeSelector->SetNodePredicate(m_ReferencePredicate);
m_Controls.m_ReferenceNodeSelector->SetInvalidInfo("Select an image");
m_Controls.m_ReferenceNodeSelector->SetPopUpTitel("Select an image");
m_Controls.m_ReferenceNodeSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
m_Controls.m_WorkingNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.m_WorkingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
m_Controls.m_WorkingNodeSelector->SetInvalidInfo("Select a segmentation");
m_Controls.m_WorkingNodeSelector->SetPopUpTitel("Select a segmentation");
m_Controls.m_WorkingNodeSelector->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.m_ReferenceNodeSelector,
&QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkMultiLabelSegmentationView::OnReferenceSelectionChanged);
connect(m_Controls.m_WorkingNodeSelector,
&QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkMultiLabelSegmentationView::OnSegmentationSelectionChanged);
// *------------------------
// * ToolManager
// *------------------------
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
m_ToolManager->InitializeTools();
m_Controls.m_ManualToolSelectionBox2D->SetToolManager(*m_ToolManager);
m_Controls.m_ManualToolSelectionBox3D->SetToolManager(*m_ToolManager);
// *------------------------
// * LabelSetWidget
// *------------------------
m_Controls.m_LabelSetWidget->SetDataStorage(this->GetDataStorage());
m_Controls.m_LabelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
m_Controls.m_LabelSetWidget->hide();
// *------------------------
// * Interpolation
// *------------------------
m_Controls.m_SurfaceBasedInterpolatorWidget->SetDataStorage(*(this->GetDataStorage()));
m_Controls.m_SliceBasedInterpolatorWidget->SetDataStorage(*(this->GetDataStorage()));
connect(m_Controls.m_cbInterpolation, QOverload<int>::of(&QComboBox::activated), this, &QmitkMultiLabelSegmentationView::OnInterpolationSelectionChanged);
m_Controls.m_cbInterpolation->setCurrentIndex(0);
m_Controls.m_swInterpolation->hide();
m_Controls.m_gbInterpolation->hide(); // See T27436
QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' 'Live Wire'");
QString segTools3D = tr("Threshold");
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()));
}
}
// *------------------------
// * ToolSelection 2D
// *------------------------
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, &QmitkMultiLabelSegmentationView::OnManualTool2DSelected);
// *------------------------
// * ToolSelection 3D
// *------------------------
m_Controls.m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
m_Controls.m_ManualToolSelectionBox3D->SetToolGUIArea(m_Controls.m_ManualToolGUIContainer3D);
m_Controls.m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString()); // todo add : FastMarching3D RegionGrowing Watershed
m_Controls.m_ManualToolSelectionBox3D->SetLayoutColumns(3);
m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode(
QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
// *------------------------*
// * Connect Buttons
// *------------------------*
connect(m_Controls.m_pbNewLabel, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnNewLabel);
connect(m_Controls.m_tbSavePreset, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnSavePreset);
connect(m_Controls.m_tbLoadPreset, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnLoadPreset);
connect(m_Controls.m_pbNewSegmentationSession, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnNewSegmentationSession);
connect(m_Controls.m_pbShowLabelTable, &QToolButton::toggled, this, &QmitkMultiLabelSegmentationView::OnShowLabelTable);
// *------------------------*
// * Connect LabelSetWidget
// *------------------------*
connect(m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::goToLabel,
this, &QmitkMultiLabelSegmentationView::OnGoToLabel);
connect(m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::resetView,
this, &QmitkMultiLabelSegmentationView::OnResetView);
// *------------------------*
// * DATA SLECTION WIDGET
// *------------------------*
connect(m_Controls.m_btAddLayer, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnAddLayer);
connect(m_Controls.m_btDeleteLayer, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnDeleteLayer);
connect(m_Controls.m_btPreviousLayer, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnPreviousLayer);
connect(m_Controls.m_btNextLayer, &QToolButton::clicked, this, &QmitkMultiLabelSegmentationView::OnNextLayer);
connect(m_Controls.m_btLockExterior, &QToolButton::toggled, this, &QmitkMultiLabelSegmentationView::OnLockExteriorToggled);
connect(m_Controls.m_cbActiveLayer, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &QmitkMultiLabelSegmentationView::OnChangeLayer);
- m_Controls.m_btAddLayer->setEnabled(false);
- m_Controls.m_btDeleteLayer->setEnabled(false);
- m_Controls.m_btNextLayer->setEnabled(false);
- m_Controls.m_btPreviousLayer->setEnabled(false);
- m_Controls.m_cbActiveLayer->setEnabled(false);
-
- m_Controls.m_pbNewLabel->setEnabled(false);
- m_Controls.m_btLockExterior->setEnabled(false);
- m_Controls.m_tbSavePreset->setEnabled(false);
- m_Controls.m_tbLoadPreset->setEnabled(false);
- m_Controls.m_pbShowLabelTable->setEnabled(false);
-
auto command = itk::SimpleMemberCommand<QmitkMultiLabelSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkMultiLabelSegmentationView::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.m_ReferenceNodeSelector->SetAutoSelectNewNodes(true);
m_Controls.m_WorkingNodeSelector->SetAutoSelectNewNodes(true);
this->UpdateGUI();
}
void QmitkMultiLabelSegmentationView::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
QList<mitk::SliceNavigationController *> controllers;
controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
}
void QmitkMultiLabelSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
m_RenderWindowPart = nullptr;
if (m_Parent)
{
m_Parent->setEnabled(false);
}
}
void QmitkMultiLabelSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
{
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 QmitkMultiLabelSegmentationView::NodeAdded(const mitk::DataNode* node)
{
if (m_SegmentationPredicate->CheckNode(node))
{
this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
}
}
void QmitkMultiLabelSegmentationView::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>();
mitk::PlanePositionManagerService *service = context->getService<mitk::PlanePositionManagerService>(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;
}
}
void QmitkMultiLabelSegmentationView::ApplyDisplayOptions()
{
if (!m_Parent)
{
return;
}
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 QmitkMultiLabelSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
{
if (nullptr == node)
{
return;
}
auto drawOutline = mitk::BoolProperty::New(GetPreferences()->GetBool("draw outline", true));
auto labelSetImage = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
if (nullptr != labelSetImage)
{
// node is a multi label segmentation
node->SetProperty("labelset.contour.active", drawOutline);
// force render window update to show outline
node->GetData()->Modified();
}
else if (nullptr != node->GetData())
{
// node is actually a 'single label' segmentation,
// but its outline property can be set in the 'multi label' segmentation preference page as well
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 QmitkMultiLabelSegmentationView::OnEstablishLabelSetConnection()
{
if (m_WorkingNode.IsNull())
{
return;
}
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
if (nullptr == workingImage)
{
// node is a "single label" / "binary" image --> no label set
return;
}
workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ActiveLabelEvent +=
mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
&QmitkLabelSetWidget::SelectLabelByPixelValue);
// Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
// workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
// this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
workingImage->AfterChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
this, &QmitkMultiLabelSegmentationView::UpdateGUI);
}
void QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection()
{
if (m_WorkingNode.IsNull())
{
return;
}
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
if (nullptr == workingImage)
{
// data (type) was changed in-place, e.g. LabelSetImage -> (binary) image
return;
}
// Reset LabelSetWidget Events
workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ActiveLabelEvent -=
mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
&QmitkLabelSetWidget::SelectLabelByPixelValue);
// Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
// workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
// this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
workingImage->AfterChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
this, &QmitkMultiLabelSegmentationView::UpdateGUI);
}
void QmitkMultiLabelSegmentationView::ResetMouseCursor()
{
if (m_MouseCursorSet)
{
mitk::ApplicationCursor::GetInstance()->PopCursor();
m_MouseCursorSet = false;
}
}
void QmitkMultiLabelSegmentationView::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 QmitkMultiLabelSegmentationView::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.m_pbNewSegmentationSession->setEnabled(false);
- m_Controls.m_pbNewLabel->setEnabled(false);
m_Controls.m_gbInterpolation->setEnabled(false);
m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(false);
m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(false);
- m_Controls.m_LabelSetWidget->setEnabled(false);
- m_Controls.m_btAddLayer->setEnabled(false);
m_Controls.m_btDeleteLayer->setEnabled(false);
m_Controls.m_cbActiveLayer->setEnabled(false);
m_Controls.m_btPreviousLayer->setEnabled(false);
m_Controls.m_btNextLayer->setEnabled(false);
m_Controls.m_btLockExterior->setChecked(false);
- m_Controls.m_btLockExterior->setEnabled(false);
- m_Controls.m_tbSavePreset->setEnabled(false);
- m_Controls.m_tbLoadPreset->setEnabled(false);
m_Controls.m_pbShowLabelTable->setChecked(false);
- m_Controls.m_pbShowLabelTable->setEnabled(false);
if (hasReferenceNode)
{
m_Controls.m_pbNewSegmentationSession->setEnabled(true);
}
if (hasWorkingNode)
{
- m_Controls.m_pbNewLabel->setEnabled(true);
- m_Controls.m_btLockExterior->setEnabled(true);
- m_Controls.m_tbSavePreset->setEnabled(true);
- m_Controls.m_tbLoadPreset->setEnabled(true);
- m_Controls.m_pbShowLabelTable->setEnabled(true);
- m_Controls.m_LabelSetWidget->setEnabled(true);
- m_Controls.m_btAddLayer->setEnabled(true);
-
m_Controls.m_cbActiveLayer->blockSignals(true);
m_Controls.m_cbActiveLayer->clear();
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr != workingImage)
{
int numberOfLayers = workingImage->GetNumberOfLayers();
for (unsigned int lidx = 0; lidx < workingImage->GetNumberOfLayers(); ++lidx)
{
m_Controls.m_cbActiveLayer->addItem(QString::number(lidx));
}
int activeLayer = workingImage->GetActiveLayer();
m_Controls.m_cbActiveLayer->setCurrentIndex(activeLayer);
m_Controls.m_cbActiveLayer->blockSignals(false);
- m_Controls.m_cbActiveLayer->setEnabled(numberOfLayers > 1);
m_Controls.m_btDeleteLayer->setEnabled(numberOfLayers > 1);
+ m_Controls.m_cbActiveLayer->setEnabled(numberOfLayers > 1);
m_Controls.m_btPreviousLayer->setEnabled(activeLayer > 0);
m_Controls.m_btNextLayer->setEnabled(activeLayer != numberOfLayers - 1);
m_Controls.m_btLockExterior->setChecked(workingImage->GetLabel(0, activeLayer)->GetLocked());
m_Controls.m_pbShowLabelTable->setChecked(workingImage->GetNumberOfLabels() > 1 /*1st is exterior*/);
}
}
if (hasWorkingNode && hasReferenceNode)
{
m_Controls.m_gbInterpolation->setEnabled(true);
m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(true);
m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(true);
int layer = -1;
referenceNode->GetIntProperty("layer", layer);
workingNode->SetIntProperty("layer", layer + 1);
}
this->ValidateSelectionInput();
}
void QmitkMultiLabelSegmentationView::ValidateSelectionInput()
{
this->UpdateWarningLabel("");
+ m_Controls.groupBox_Layer->setEnabled(false);
+ m_Controls.groupBox_Labels->setEnabled(false);
+ m_Controls.m_LabelSetWidget->setEnabled(false);
// 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.m_ReferenceNodeSelector->GetSelectedNode();
mitk::DataNode* workingNode = m_Controls.m_WorkingNodeSelector->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.groupBox_Layer->setEnabled(true);
+ m_Controls.groupBox_Labels->setEnabled(true);
+ m_Controls.m_LabelSetWidget->setEnabled(true);
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 QmitkMultiLabelSegmentationView::UpdateWarningLabel(QString text)
{
if (text.size() == 0)
{
m_Controls.lblSegmentationWarnings->hide();
}
else
{
m_Controls.lblSegmentationWarnings->show();
}
m_Controls.lblSegmentationWarnings->setText("<font color=\"red\">" + text + "</font>");
}