diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp
index f20cfe0426..88a901cc40 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.cpp
@@ -1,1416 +1,1422 @@
/*============================================================================
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 <QmitkMultiLabelInspector.h>
// mitk
#include <mitkRenderingManager.h>
#include <mitkLabelSetImageHelper.h>
#include <mitkDICOMSegmentationPropertyHelper.h>
#include <mitkVectorProperty.h>
// Qmitk
#include <QmitkMultiLabelTreeModel.h>
#include <QmitkLabelColorItemDelegate.h>
#include <QmitkLabelToggleItemDelegate.h>
#include <QmitkStyleManager.h>
// Qt
#include <QMenu>
#include <QLabel>
#include <QWidgetAction>
#include <QMessageBox>
#include <ui_QmitkMultiLabelInspectorControls.h>
namespace
{
void ActivateLabelHighlights(mitk::DataNode* node, const mitk::LabelSetImage::LabelValueVectorType highlightedValues)
{
const std::string propertyName = "org.mitk.multilabel.labels.highlighted";
mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
if (nullptr == prop)
{
prop = mitk::IntVectorProperty::New();
node->SetProperty(propertyName, prop);
}
mitk::IntVectorProperty::VectorType intValues(highlightedValues.begin(), highlightedValues.end());
prop->SetValue(intValues);
prop->Modified(); //see T30386; needed because VectorProperty::SetValue does currently trigger no modified
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void DeactivateLabelHighlights(mitk::DataNode* node)
{
std::string propertyName = "org.mitk.multilabel.labels.highlighted";
mitk::IntVectorProperty::Pointer prop = dynamic_cast<mitk::IntVectorProperty*>(node->GetNonConstProperty(propertyName));
if (nullptr != prop)
{
prop->SetValue({});
prop->Modified(); //see T30386; needed because VectorProperty::SetValue does currently trigger no modified
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
QmitkMultiLabelInspector::QmitkMultiLabelInspector(QWidget* parent/* = nullptr*/)
: QWidget(parent), m_Controls(new Ui::QmitkMultiLabelInspector), m_SegmentationNodeDataMTime(0)
{
m_Controls->setupUi(this);
m_Model = new QmitkMultiLabelTreeModel(this);
m_Controls->view->setModel(m_Model);
m_ColorItemDelegate = new QmitkLabelColorItemDelegate(this);
auto visibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg"));
auto invisibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg"));
m_VisibilityItemDelegate = new QmitkLabelToggleItemDelegate(visibleIcon, invisibleIcon, this);
auto lockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
auto unlockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
m_LockItemDelegate = new QmitkLabelToggleItemDelegate(lockIcon, unlockIcon, this);
auto* view = this->m_Controls->view;
view->setItemDelegateForColumn(1, m_LockItemDelegate);
view->setItemDelegateForColumn(2, m_ColorItemDelegate);
view->setItemDelegateForColumn(3, m_VisibilityItemDelegate);
auto* header = view->header();
header->setSectionResizeMode(0,QHeaderView::Stretch);
header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
header->setSectionResizeMode(2, QHeaderView::ResizeToContents);
header->setSectionResizeMode(3, QHeaderView::ResizeToContents);
view->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_Model, &QAbstractItemModel::modelReset, this, &QmitkMultiLabelInspector::OnModelReset);
connect(m_Model, &QAbstractItemModel::dataChanged, this, &QmitkMultiLabelInspector::OnDataChanged);
connect(view->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), SLOT(OnChangeModelSelection(const QItemSelection&, const QItemSelection&)));
connect(view, &QAbstractItemView::customContextMenuRequested, this, &QmitkMultiLabelInspector::OnContextMenuRequested);
connect(view, &QAbstractItemView::doubleClicked, this, &QmitkMultiLabelInspector::OnItemDoubleClicked);
connect(view, &QAbstractItemView::entered, this, &QmitkMultiLabelInspector::OnEntered);
connect(view, &QmitkMultiLabelTreeView::MouseLeave, this, &QmitkMultiLabelInspector::OnMouseLeave);
}
QmitkMultiLabelInspector::~QmitkMultiLabelInspector()
{
delete m_Controls;
}
void QmitkMultiLabelInspector::Initialize()
{
m_LastValidSelectedLabels = {};
m_ModelManipulationOngoing = false;
m_Model->SetSegmentation(m_Segmentation);
m_Controls->view->expandAll();
m_LastValidSelectedLabels = {};
//in singel selection mode, if at least one label exist select the first label of the mode.
if (m_Segmentation.IsNotNull() && !this->GetMultiSelectionMode() && m_Segmentation->GetTotalNumberOfLabels() > 0)
{
auto firstIndex = m_Model->FirstLabelInstanceIndex(QModelIndex());
auto labelVariant = firstIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
if (labelVariant.isValid())
{
this->SetSelectedLabel(labelVariant.value<LabelValueType>());
m_Controls->view->selectionModel()->setCurrentIndex(firstIndex, QItemSelectionModel::NoUpdate);
}
}
}
void QmitkMultiLabelInspector::SetMultiSelectionMode(bool multiMode)
{
m_Controls->view->setSelectionMode(multiMode
? QAbstractItemView::SelectionMode::MultiSelection
: QAbstractItemView::SelectionMode::SingleSelection);
}
bool QmitkMultiLabelInspector::GetMultiSelectionMode() const
{
return QAbstractItemView::SelectionMode::MultiSelection == m_Controls->view->selectionMode();
}
void QmitkMultiLabelInspector::SetAllowVisibilityModification(bool visibilityMod)
{
m_AllowVisibilityModification = visibilityMod;
this->m_Model->SetAllowVisibilityModification(visibilityMod);
}
void QmitkMultiLabelInspector::SetAllowLabelModification(bool labelMod)
{
m_AllowLabelModification = labelMod;
}
bool QmitkMultiLabelInspector::GetAllowVisibilityModification() const
{
return m_AllowVisibilityModification;
}
void QmitkMultiLabelInspector::SetAllowLockModification(bool lockMod)
{
m_AllowLockModification = lockMod;
this->m_Model->SetAllowLockModification(lockMod);
}
bool QmitkMultiLabelInspector::GetAllowLockModification() const
{
return m_AllowLockModification;
}
bool QmitkMultiLabelInspector::GetAllowLabelModification() const
{
return m_AllowLabelModification;
}
void QmitkMultiLabelInspector::SetDefaultLabelNaming(bool defaultLabelNaming)
{
m_DefaultLabelNaming = defaultLabelNaming;
}
void QmitkMultiLabelInspector::SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation)
{
if (segmentation != m_Segmentation)
{
m_Segmentation = segmentation;
this->Initialize();
emit SegmentationChanged();
}
}
mitk::LabelSetImage* QmitkMultiLabelInspector::GetMultiLabelSegmentation() const
{
return m_Segmentation;
}
void QmitkMultiLabelInspector::SetMultiLabelNode(mitk::DataNode* node)
{
if (node != this->m_SegmentationNode.GetPointer())
{
m_SegmentationObserver.Reset();
m_SegmentationNode = node;
m_SegmentationNodeDataMTime = 0;
if (m_SegmentationNode.IsNotNull())
{
auto& widget = *this;
auto checkAndSetSeg = [&widget, node](const itk::EventObject&)
{
if (widget.m_SegmentationNodeDataMTime < node->GetDataReferenceChangedTime())
{
auto newSeg = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
if (nullptr == newSeg) mitkThrow() << "Invalid usage. Node set does not contain a segmentation.";
widget.m_SegmentationNodeDataMTime = node->GetDataReferenceChangedTime();
widget.SetMultiLabelSegmentation(newSeg);
}
};
m_SegmentationObserver.Reset(node, itk::ModifiedEvent(), checkAndSetSeg);
checkAndSetSeg(itk::ModifiedEvent());
}
else
{
this->SetMultiLabelSegmentation(nullptr);
}
}
}
mitk::DataNode* QmitkMultiLabelInspector::GetMultiLabelNode() const
{
return m_SegmentationNode;
}
bool QmitkMultiLabelInspector::GetModelManipulationOngoing() const
{
return m_ModelManipulationOngoing;
}
void QmitkMultiLabelInspector::OnModelReset()
{
m_LastValidSelectedLabels = {};
m_ModelManipulationOngoing = false;
}
void QmitkMultiLabelInspector::OnDataChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/,
const QList<int>& /*roles*/)
{
if (!m_ModelManipulationOngoing && topLeft.isValid())
m_Controls->view->expand(topLeft);
}
bool EqualLabelSelections(const QmitkMultiLabelInspector::LabelValueVectorType& selection1, const QmitkMultiLabelInspector::LabelValueVectorType& selection2)
{
if (selection1.size() == selection2.size())
{
// lambda to compare node pointer inside both lists
return std::is_permutation(selection1.begin(), selection1.end(), selection2.begin());
}
return false;
}
void QmitkMultiLabelInspector::SetSelectedLabels(const LabelValueVectorType& selectedLabels)
{
if (EqualLabelSelections(this->GetSelectedLabels(), selectedLabels))
{
return;
}
this->UpdateSelectionModel(selectedLabels);
m_LastValidSelectedLabels = selectedLabels;
}
void QmitkMultiLabelInspector::UpdateSelectionModel(const LabelValueVectorType& selectedLabels)
{
// create new selection by retrieving the corresponding indexes of the labels
QItemSelection newCurrentSelection;
for (const auto& labelID : selectedLabels)
{
QModelIndexList matched = m_Model->match(m_Model->index(0, 0), QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole, QVariant(labelID), 1, Qt::MatchRecursive);
if (!matched.empty())
{
newCurrentSelection.select(matched.front(), matched.front());
}
}
m_Controls->view->selectionModel()->select(newCurrentSelection, QItemSelectionModel::ClearAndSelect|QItemSelectionModel::Current);
}
void QmitkMultiLabelInspector::SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel)
{
this->SetSelectedLabels({ selectedLabel });
}
QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetSelectedLabelsFromSelectionModel() const
{
LabelValueVectorType result;
QModelIndexList selectedIndexes = m_Controls->view->selectionModel()->selectedIndexes();
for (const auto& index : std::as_const(selectedIndexes))
{
QVariant qvariantDataNode = m_Model->data(index, QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
if (qvariantDataNode.canConvert<mitk::LabelSetImage::LabelValueType>())
{
result.push_back(qvariantDataNode.value<mitk::LabelSetImage::LabelValueType>());
}
}
return result;
}
QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetSelectedLabels() const
{
return m_LastValidSelectedLabels;
}
mitk::Label* QmitkMultiLabelInspector::GetFirstSelectedLabelObject() const
{
if (m_LastValidSelectedLabels.empty() || m_Segmentation.IsNull())
return nullptr;
return m_Segmentation->GetLabel(m_LastValidSelectedLabels.front());
}
void QmitkMultiLabelInspector::OnChangeModelSelection(const QItemSelection& /*selected*/, const QItemSelection& /*deselected*/)
{
if (!m_ModelManipulationOngoing)
{
auto internalSelection = GetSelectedLabelsFromSelectionModel();
if (internalSelection.empty())
{
//empty selections are not allowed by UI interactions, there should always be at least on label selected.
//but selections are e.g. also cleared if the model is updated (e.g. due to addition of labels)
UpdateSelectionModel(m_LastValidSelectedLabels);
}
else
{
m_LastValidSelectedLabels = internalSelection;
emit CurrentSelectionChanged(GetSelectedLabels());
}
}
}
void QmitkMultiLabelInspector::WaitCursorOn() const
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
}
void QmitkMultiLabelInspector::WaitCursorOff() const
{
this->RestoreOverrideCursor();
}
void QmitkMultiLabelInspector::RestoreOverrideCursor() const
{
QApplication::restoreOverrideCursor();
}
mitk::Label* QmitkMultiLabelInspector::GetCurrentLabel() const
{
auto currentIndex = this->m_Controls->view->currentIndex();
auto labelVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelDataRole);
mitk::Label::Pointer currentIndexLabel = nullptr;
if (labelVariant.isValid())
{
auto uncastedLabel = labelVariant.value<void*>();
currentIndexLabel = static_cast<mitk::Label*>(uncastedLabel);
}
return currentIndexLabel;
}
QmitkMultiLabelInspector::IndexLevelType QmitkMultiLabelInspector::GetCurrentLevelType() const
{
auto currentIndex = this->m_Controls->view->currentIndex();
auto labelInstanceVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceDataRole);
auto labelVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelDataRole);
if (labelInstanceVariant.isValid() )
{
return IndexLevelType::LabelInstance;
}
else if (labelVariant.isValid())
{
return IndexLevelType::LabelClass;
}
return IndexLevelType::Group;
}
QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetCurrentlyAffactedLabelInstances() const
{
auto currentIndex = m_Controls->view->currentIndex();
return m_Model->GetLabelsInSubTree(currentIndex);
}
QmitkMultiLabelInspector::LabelValueVectorType QmitkMultiLabelInspector::GetLabelInstancesOfSelectedFirstLabel() const
{
if (m_Segmentation.IsNull())
return {};
if (this->GetSelectedLabels().empty())
return {};
const auto index = m_Model->indexOfLabel(this->GetSelectedLabels().front());
return m_Model->GetLabelInstancesOfSameLabelClass(index);
}
mitk::Label* QmitkMultiLabelInspector::AddNewLabelInstanceInternal(mitk::Label* templateLabel)
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of AddNewLabelInstance.";
if (nullptr == templateLabel)
mitkThrow() << "QmitkMultiLabelInspector is in an invalid state. AddNewLabelInstanceInternal was called with a non existing label as template";
auto groupID = m_Segmentation->GetGroupIndexOfLabel(templateLabel->GetValue());
m_ModelManipulationOngoing = true;
auto newLabel = m_Segmentation->AddLabel(templateLabel, groupID, true);
m_ModelManipulationOngoing = false;
this->SetSelectedLabel(newLabel->GetValue());
auto index = m_Model->indexOfLabel(newLabel->GetValue());
if (index.isValid())
{
m_Controls->view->expand(index.parent());
}
else
{
mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the model after adding it to the segmentation. Label value: " << newLabel->GetValue();
}
emit ModelUpdated();
return newLabel;
}
mitk::Label* QmitkMultiLabelInspector::AddNewLabelInstance()
{
auto currentLabel = this->GetFirstSelectedLabelObject();
if (nullptr == currentLabel)
return nullptr;
auto result = this->AddNewLabelInstanceInternal(currentLabel);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
return result;
}
mitk::Label* QmitkMultiLabelInspector::AddNewLabelInternal(const mitk::LabelSetImage::GroupIndexType& containingGroup)
{
auto newLabel = mitk::LabelSetImageHelper::CreateNewLabel(m_Segmentation);
+ bool canceled = false;
if (!m_DefaultLabelNaming)
- emit LabelRenameRequested(newLabel, false);
+ emit LabelRenameRequested(newLabel, false, canceled);
+
+ if (canceled) return nullptr;
m_ModelManipulationOngoing = true;
m_Segmentation->AddLabel(newLabel, containingGroup, false);
m_ModelManipulationOngoing = false;
this->SetSelectedLabel(newLabel->GetValue());
auto index = m_Model->indexOfLabel(newLabel->GetValue());
if (!index.isValid())
mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the "
"model after adding it to the segmentation. Label value: " << newLabel->GetValue();
m_Controls->view->expand(index.parent());
emit ModelUpdated();
return newLabel;
}
mitk::Label* QmitkMultiLabelInspector::AddNewLabel()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of AddNewLabel.";
if (m_Segmentation.IsNull())
{
return nullptr;
}
auto currentLabel = this->GetFirstSelectedLabelObject();
mitk::LabelSetImage::GroupIndexType groupID = nullptr != currentLabel
? m_Segmentation->GetGroupIndexOfLabel(currentLabel->GetValue())
: 0;
auto result = AddNewLabelInternal(groupID);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
return result;
}
void QmitkMultiLabelInspector::DeleteLabelInstance()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of DeleteLabelInstance.";
if (m_Segmentation.IsNull())
return;
auto label = this->GetFirstSelectedLabelObject();
if (nullptr == label)
return;
auto index = m_Model->indexOfLabel(label->GetValue());
auto instanceName = index.data(Qt::DisplayRole);
auto question = "Do you really want to delete label instance \"" + instanceName.toString() + "\"?";
auto answer = QMessageBox::question(this, QString("Delete label instances"), question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answer == QMessageBox::Yes)
{
this->DeleteLabelInternal({ label->GetValue() });
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::DeleteLabel()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of DeleteLabel.";
if (m_Segmentation.IsNull())
return;
const auto label = this->GetFirstSelectedLabelObject();
if (nullptr == label)
return;
const auto relevantLabels = this->GetLabelInstancesOfSelectedFirstLabel();
if (relevantLabels.empty())
return;
auto question = "Do you really want to delete label \"" + QString::fromStdString(label->GetName());
question = relevantLabels.size()==1 ? question + "\"?" : question + "\" with all "+QString::number(relevantLabels.size()) +" instances?";
auto answer = QMessageBox::question(this, QString("Delete label"), question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answer == QMessageBox::Yes)
{
this->DeleteLabelInternal(relevantLabels);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::DeleteLabelInternal(const LabelValueVectorType& labelValues)
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of DeleteLabelInternal.";
if (m_Segmentation.IsNull())
{
return;
}
QVariant nextLabelVariant;
this->WaitCursorOn();
m_ModelManipulationOngoing = true;
for (auto labelValue : labelValues)
{
if (labelValue == labelValues.back())
{
auto currentIndex = m_Model->indexOfLabel(labelValue);
auto nextIndex = m_Model->ClosestLabelInstanceIndex(currentIndex);
nextLabelVariant = nextIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
}
m_Segmentation->RemoveLabel(labelValue);
}
m_ModelManipulationOngoing = false;
this->WaitCursorOff();
if (nextLabelVariant.isValid())
{
auto newLabelValue = nextLabelVariant.value<LabelValueType>();
this->SetSelectedLabel(newLabelValue);
auto index = m_Model->indexOfLabel(newLabelValue); //we have to get index again, because it could have changed due to remove operation.
if (index.isValid())
{
m_Controls->view->expand(index.parent());
}
else
{
mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the model after adding it to the segmentation. Label value: " << newLabelValue;
}
}
else
{
this->SetSelectedLabels({});
}
emit ModelUpdated();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
mitk::Label* QmitkMultiLabelInspector::AddNewGroup()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of AddNewLabel.";
if (m_Segmentation.IsNull())
{
return nullptr;
}
mitk::LabelSetImage::GroupIndexType groupID = 0;
mitk::Label* newLabel = nullptr;
m_ModelManipulationOngoing = true;
try
{
this->WaitCursorOn();
groupID = m_Segmentation->AddLayer();
m_Segmentation->SetActiveLayer(groupID);
this->WaitCursorOff();
newLabel = this->AddNewLabelInternal(groupID);
}
catch (mitk::Exception& e)
{
this->WaitCursorOff();
m_ModelManipulationOngoing = false;
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this, "Add group", "Could not add a new group. See error log for details.");
}
m_ModelManipulationOngoing = false;
emit ModelUpdated();
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
return newLabel;
}
void QmitkMultiLabelInspector::RemoveGroupInternal(const mitk::LabelSetImage::GroupIndexType& groupID)
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
if (m_Segmentation.IsNull())
return;
if (m_Segmentation->GetNumberOfLayers() < 2)
return;
auto currentIndex = m_Model->indexOfGroup(groupID);
auto nextIndex = m_Model->ClosestLabelInstanceIndex(currentIndex);
auto labelVariant = nextIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
try
{
this->WaitCursorOn();
m_ModelManipulationOngoing = true;
m_Segmentation->RemoveGroup(groupID);
m_ModelManipulationOngoing = false;
this->WaitCursorOff();
}
catch (mitk::Exception& e)
{
m_ModelManipulationOngoing = false;
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this, "Delete group", "Could not delete the currently active group. See error log for details.");
return;
}
if (labelVariant.isValid())
{
auto newLabelValue = labelVariant.value<LabelValueType>();
this->SetSelectedLabel(newLabelValue);
auto index = m_Model->indexOfLabel(newLabelValue); //we have to get index again, because it could have changed due to remove operation.
if (index.isValid())
{
m_Controls->view->expand(index.parent());
}
else
{
mitkThrow() << "Segmentation or QmitkMultiLabelTreeModel is in an invalid state. Label is not present in the model after adding it to the segmentation. Label value: " << newLabelValue;
}
}
else
{
this->SetSelectedLabels({});
}
emit ModelUpdated();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkMultiLabelInspector::RemoveGroup()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
if (m_Segmentation.IsNull())
return;
if (m_Segmentation->GetNumberOfLayers() < 2)
{
QMessageBox::information(this, "Delete group", "Cannot delete last remaining group. A segmentation must contain at least a single group.");
return;
}
const auto* selectedLabel = this->GetFirstSelectedLabelObject();
if (selectedLabel == nullptr)
return;
const auto groupID = m_Segmentation->GetGroupIndexOfLabel(selectedLabel->GetValue());
auto groupName = QString::fromStdString(mitk::LabelSetImageHelper::CreateDisplayGroupName(m_Segmentation, groupID));
auto question = QStringLiteral("Do you really want to delete group \"%1\" including all of its labels?").arg(groupName);
auto answer = QMessageBox::question(this, QString("Delete group \"%1\"").arg(groupName), question, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if (answer != QMessageBox::Yes)
return;
this->RemoveGroupInternal(groupID);
}
void QmitkMultiLabelInspector::OnDeleteGroup()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
if (m_Segmentation.IsNull())
return;
auto currentIndex = this->m_Controls->view->currentIndex();
auto groupIDVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::GroupIDRole);
if (groupIDVariant.isValid())
{
auto groupID = groupIDVariant.value<mitk::LabelSetImage::GroupIndexType>();
auto groupName = QString::fromStdString(mitk::LabelSetImageHelper::CreateDisplayGroupName(m_Segmentation, groupID));
auto question = QStringLiteral("Do you really want to delete group \"%1\" including all of its labels?").arg(groupName);
auto answer = QMessageBox::question(this, QString("Delete group \"%1\"").arg(groupName), question, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if (answer != QMessageBox::Yes)
return;
this->RemoveGroupInternal(groupID);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
};
void QmitkMultiLabelInspector::OnContextMenuRequested(const QPoint& /*pos*/)
{
if (m_Segmentation.IsNull() || !this->isEnabled())
return;
const auto indexLevel = this->GetCurrentLevelType();
auto currentIndex = this->m_Controls->view->currentIndex();
//this ensures correct highlighting is the context menu is triggered while
//another context menu is already open.
if (currentIndex.isValid() && this->m_AboutToShowContextMenu) this->OnEntered(this->m_Controls->view->currentIndex());
QMenu* menu = new QMenu(this);
if (IndexLevelType::Group == indexLevel)
{
if (m_AllowLabelModification)
{
QAction* addInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add.svg")), "&Add label", this);
QObject::connect(addInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnAddLabel);
menu->addAction(addInstanceAction);
if (m_Segmentation->GetNumberOfLayers() > 1)
{
QAction* removeAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_group_delete.svg")), "Delete group", this);
QObject::connect(removeAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnDeleteGroup);
menu->addAction(removeAction);
}
}
if (m_AllowLockModification)
{
menu->addSeparator();
QAction* lockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg")), "Lock group", this);
QObject::connect(lockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnLockAffectedLabels);
menu->addAction(lockAllAction);
QAction* unlockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg")), "Unlock group", this);
QObject::connect(unlockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnUnlockAffectedLabels);
menu->addAction(unlockAllAction);
}
if (m_AllowVisibilityModification)
{
menu->addSeparator();
QAction* viewAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Show group", this);
QObject::connect(viewAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsVisible);
menu->addAction(viewAllAction);
QAction* hideAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg")), "Hide group", this);
QObject::connect(hideAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsInvisible);
menu->addAction(hideAllAction);
menu->addSeparator();
auto opacityAction = this->CreateOpacityAction();
if (nullptr != opacityAction)
menu->addAction(opacityAction);
}
}
else if (IndexLevelType::LabelClass == indexLevel)
{
if (m_AllowLabelModification)
{
QAction* addInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add_instance.svg")), "Add label instance", this);
QObject::connect(addInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnAddLabelInstance);
menu->addAction(addInstanceAction);
QAction* renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "&Rename label", this);
QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
menu->addAction(renameAction);
QAction* removeAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete.svg")), "&Delete label", this);
QObject::connect(removeAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnDeleteAffectedLabel);
menu->addAction(removeAction);
}
if (m_AllowLockModification)
{
menu->addSeparator();
QAction* lockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg")), "Lock label instances", this);
QObject::connect(lockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnLockAffectedLabels);
menu->addAction(lockAllAction);
QAction* unlockAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg")), "Unlock label instances", this);
QObject::connect(unlockAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnUnlockAffectedLabels);
menu->addAction(unlockAllAction);
}
if (m_AllowVisibilityModification)
{
menu->addSeparator();
QAction* viewAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Show label instances", this);
QObject::connect(viewAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsVisible);
menu->addAction(viewAllAction);
QAction* hideAllAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg")), "Hide label instances", this);
QObject::connect(hideAllAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnSetAffectedLabelsInvisible);
menu->addAction(hideAllAction);
menu->addSeparator();
auto opacityAction = this->CreateOpacityAction();
if (nullptr!=opacityAction)
menu->addAction(opacityAction);
}
}
else
{
auto selectedLabelValues = this->GetSelectedLabels();
if (selectedLabelValues.empty())
return;
if (this->GetMultiSelectionMode() && selectedLabelValues.size() > 1)
{
if (m_AllowLabelModification)
{
QAction* mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge selection on current label", this);
QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabels(bool)));
menu->addAction(mergeAction);
QAction* removeLabelsAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete_instance.svg")), "&Delete selected labels", this);
QObject::connect(removeLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnDeleteLabels(bool)));
menu->addAction(removeLabelsAction);
QAction* clearLabelsAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "&Clear selected labels", this);
QObject::connect(clearLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnClearLabels(bool)));
menu->addAction(clearLabelsAction);
}
if (m_AllowVisibilityModification)
{
if (m_AllowLabelModification) menu->addSeparator();
QAction* viewOnlyAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Hide everything but this", this);
QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
menu->addAction(viewOnlyAction);
menu->addSeparator();
auto opacityAction = this->CreateOpacityAction();
if (nullptr != opacityAction)
menu->addAction(opacityAction);
}
}
else
{
if (m_AllowLabelModification)
{
QAction* addInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add_instance.svg")), "&Add label instance", this);
QObject::connect(addInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::OnAddLabelInstance);
menu->addAction(addInstanceAction);
const auto selectedLabelIndex = m_Model->indexOfLabel(selectedLabelValues.front());
if (m_Model->GetLabelInstancesOfSameLabelClass(selectedLabelIndex).size() > 1) // Only labels that actually appear as instance (having additional instances)
{
QAction* renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "&Rename label instance", this);
QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
menu->addAction(renameAction);
QAction* removeInstanceAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete_instance.svg")), "&Delete label instance", this);
QObject::connect(removeInstanceAction, &QAction::triggered, this, &QmitkMultiLabelInspector::DeleteLabelInstance);
menu->addAction(removeInstanceAction);
}
else
{
QAction* renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "&Rename label", this);
QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
menu->addAction(renameAction);
}
QAction* removeLabelAction = new QAction(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete.svg")), "Delete &label", this);
QObject::connect(removeLabelAction, &QAction::triggered, this, &QmitkMultiLabelInspector::DeleteLabel);
menu->addAction(removeLabelAction);
QAction* clearAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "&Clear content", this);
QObject::connect(clearAction, SIGNAL(triggered(bool)), this, SLOT(OnClearLabel(bool)));
menu->addAction(clearAction);
}
if (m_AllowVisibilityModification)
{
if (m_AllowLabelModification) menu->addSeparator();
QAction* viewOnlyAction = new QAction(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg")), "Hide everything but this", this);
QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
menu->addAction(viewOnlyAction);
menu->addSeparator();
auto opacityAction = this->CreateOpacityAction();
if (nullptr != opacityAction)
menu->addAction(opacityAction);
}
}
}
QObject::connect(menu, &QMenu::aboutToHide, this, &QmitkMultiLabelInspector::OnMouseLeave);
m_AboutToShowContextMenu = true;
menu->popup(QCursor::pos());
}
QWidgetAction* QmitkMultiLabelInspector::CreateOpacityAction()
{
auto selectedLabelValues = this->GetSelectedLabels();
auto relevantLabelValues = !this->GetMultiSelectionMode() || selectedLabelValues.size() <= 1
? this->GetCurrentlyAffactedLabelInstances()
: selectedLabelValues;
std::vector<mitk::Label*> relevantLabels;
if (!relevantLabelValues.empty())
{
for (auto value : relevantLabelValues)
{
auto label = this->m_Segmentation->GetLabel(value);
if (nullptr == label)
mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
relevantLabels.emplace_back(label);
}
auto* opacitySlider = new QSlider;
opacitySlider->setMinimum(0);
opacitySlider->setMaximum(100);
opacitySlider->setOrientation(Qt::Horizontal);
auto opacity = relevantLabels.front()->GetOpacity();
opacitySlider->setValue(static_cast<int>(opacity * 100));
auto segmentation = m_Segmentation;
auto node = m_SegmentationNode;
auto onChangeLambda = [segmentation, relevantLabels](const int value)
{
auto opacity = static_cast<float>(value) / 100.0f;
for (auto label : relevantLabels)
{
label->SetOpacity(opacity);
segmentation->UpdateLookupTable(label->GetValue());
}
segmentation->GetLookupTable()->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
};
QObject::connect(opacitySlider, &QSlider::valueChanged, this, onChangeLambda);
auto onPressedLambda = [node]()
{
DeactivateLabelHighlights(node);
};
QObject::connect(opacitySlider, &QSlider::sliderPressed, this, onPressedLambda);
auto onReleasedLambda = [node, relevantLabelValues]()
{
ActivateLabelHighlights(node, relevantLabelValues);
};
QObject::connect(opacitySlider, &QSlider::sliderReleased, this, onReleasedLambda);
QLabel* opacityLabel = new QLabel("Opacity: ");
QVBoxLayout* opacityWidgetLayout = new QVBoxLayout;
opacityWidgetLayout->setContentsMargins(4, 4, 4, 4);
opacityWidgetLayout->addWidget(opacityLabel);
opacityWidgetLayout->addWidget(opacitySlider);
QWidget* opacityWidget = new QWidget;
opacityWidget->setLayout(opacityWidgetLayout);
QWidgetAction* opacityAction = new QWidgetAction(this);
opacityAction->setDefaultWidget(opacityWidget);
return opacityAction;
}
return nullptr;
}
void QmitkMultiLabelInspector::OnClearLabels(bool /*value*/)
{
QString question = "Do you really want to clear the selected labels?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
this, "Clear selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->WaitCursorOn();
m_Segmentation->EraseLabels(this->GetSelectedLabels());
this->WaitCursorOff();
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::OnDeleteAffectedLabel()
{
if (!m_AllowLabelModification)
mitkThrow() << "QmitkMultiLabelInspector is configured incorrectly. Set AllowLabelModification to true to allow the usage of RemoveLabel.";
if (m_Segmentation.IsNull())
{
return;
}
auto affectedLabels = GetCurrentlyAffactedLabelInstances();
auto currentLabel = m_Segmentation->GetLabel(affectedLabels.front());
QString question = "Do you really want to delete all instances of label \"" + QString::fromStdString(currentLabel->GetName()) + "\"?";
QMessageBox::StandardButton answerButton =
QMessageBox::question(this, "Delete label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->DeleteLabelInternal(affectedLabels);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::OnDeleteLabels(bool /*value*/)
{
QString question = "Do you really want to remove the selected labels?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
this, "Remove selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->WaitCursorOn();
m_Segmentation->RemoveLabels(this->GetSelectedLabels());
this->WaitCursorOff();
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::OnMergeLabels(bool /*value*/)
{
auto currentLabel = GetCurrentLabel();
QString question = "Do you really want to merge selected labels into \"" + QString::fromStdString(currentLabel->GetName())+"\"?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
this, "Merge selected label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->WaitCursorOn();
m_Segmentation->MergeLabels(currentLabel->GetValue(), this->GetSelectedLabels());
this->WaitCursorOff();
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::OnAddLabel()
{
auto currentIndex = this->m_Controls->view->currentIndex();
auto groupIDVariant = currentIndex.data(QmitkMultiLabelTreeModel::ItemModelRole::GroupIDRole);
if (groupIDVariant.isValid())
{
auto groupID = groupIDVariant.value<mitk::LabelSetImage::GroupIndexType>();
this->AddNewLabelInternal(groupID);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::OnAddLabelInstance()
{
auto currentLabel = this->GetCurrentLabel();
if (nullptr == currentLabel)
return;
this->AddNewLabelInstanceInternal(currentLabel);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
void QmitkMultiLabelInspector::OnClearLabel(bool /*value*/)
{
auto currentLabel = GetFirstSelectedLabelObject();
QString question = "Do you really want to clear the contents of label \"" + QString::fromStdString(currentLabel->GetName())+"\"?";
QMessageBox::StandardButton answerButton =
QMessageBox::question(this, "Clear label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->WaitCursorOn();
m_Segmentation->EraseLabel(currentLabel->GetValue());
this->WaitCursorOff();
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
void QmitkMultiLabelInspector::OnRenameLabel(bool /*value*/)
{
auto relevantLabelValues = this->GetCurrentlyAffactedLabelInstances();
auto currentLabel = this->GetCurrentLabel();
- emit LabelRenameRequested(currentLabel, true);
+ bool canceled = false;
+ emit LabelRenameRequested(currentLabel, true, canceled);
+
+ if (canceled) return;
for (auto value : relevantLabelValues)
{
if (value != currentLabel->GetValue())
{
auto label = this->m_Segmentation->GetLabel(value);
if (nullptr == label)
mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
label->SetName(currentLabel->GetName());
label->SetColor(currentLabel->GetColor());
m_Segmentation->UpdateLookupTable(label->GetValue());
mitk::DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(label);
// this is needed as workaround for (T27307). It circumvents the fact that modifications
// of data (here the segmentation) does not directly trigger the modification of the
// owning node (see T27307). Therefore other code (like renderers or model views) that e.g.
// listens to the datastorage for modification would not get notified.
if (m_SegmentationNode.IsNotNull())
{
m_SegmentationNode->Modified();
}
}
}
emit ModelUpdated();
}
void QmitkMultiLabelInspector::SetLockOfAffectedLabels(bool locked) const
{
auto relevantLabelValues = this->GetCurrentlyAffactedLabelInstances();
if (!relevantLabelValues.empty())
{
for (auto value : relevantLabelValues)
{
auto label = this->m_Segmentation->GetLabel(value);
if (nullptr == label)
mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
label->SetLocked(locked);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkMultiLabelInspector::OnUnlockAffectedLabels()
{
this->SetLockOfAffectedLabels(false);
}
void QmitkMultiLabelInspector::OnLockAffectedLabels()
{
this->SetLockOfAffectedLabels(true);
}
void QmitkMultiLabelInspector::SetVisibilityOfAffectedLabels(bool visible) const
{
auto relevantLabelValues = this->GetCurrentlyAffactedLabelInstances();
if (!relevantLabelValues.empty())
{
for (auto value : relevantLabelValues)
{
auto label = this->m_Segmentation->GetLabel(value);
if (nullptr == label)
mitkThrow() << "Invalid state. Internal model returned a label value that does not exist in segmentation. Invalid value:" << value;
label->SetVisible(visible);
m_Segmentation->UpdateLookupTable(label->GetValue());
}
m_Segmentation->GetLookupTable()->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkMultiLabelInspector::OnSetAffectedLabelsVisible()
{
this->SetVisibilityOfAffectedLabels(true);
}
void QmitkMultiLabelInspector::OnSetAffectedLabelsInvisible()
{
this->SetVisibilityOfAffectedLabels(false);
}
void QmitkMultiLabelInspector::OnSetOnlyActiveLabelVisible(bool /*value*/)
{
auto selectedLabelValues = this->GetSelectedLabels();
if (selectedLabelValues.empty()) return;
m_Segmentation->SetAllLabelsVisible(false);
for (auto selectedValue : selectedLabelValues)
{
auto currentLabel = m_Segmentation->GetLabel(selectedValue);
currentLabel->SetVisible(true);
m_Segmentation->UpdateLookupTable(selectedValue);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->PrepareGoToLabel(selectedLabelValues.front());
}
void QmitkMultiLabelInspector::OnItemDoubleClicked(const QModelIndex& index)
{
if (!index.isValid()) return;
if (index.column() > 0) return;
auto labelVariant = index.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
if (!labelVariant.isValid()) return;
const auto labelID = labelVariant.value<mitk::Label::PixelType>();
if (QApplication::queryKeyboardModifiers().testFlag(Qt::AltModifier))
{
this->OnRenameLabel(false);
return;
}
this->PrepareGoToLabel(labelID);
}
void QmitkMultiLabelInspector::PrepareGoToLabel(mitk::Label::PixelType labelID) const
{
this->WaitCursorOn();
m_Segmentation->UpdateCenterOfMass(labelID);
const auto currentLabel = m_Segmentation->GetLabel(labelID);
const mitk::Point3D& pos = currentLabel->GetCenterOfMassCoordinates();
this->WaitCursorOff();
if (pos.GetVnlVector().max_value() > 0.0)
{
emit GoToLabel(currentLabel->GetValue(), pos);
}
}
void QmitkMultiLabelInspector::OnEntered(const QModelIndex& index)
{
if (m_SegmentationNode.IsNotNull())
{
auto labelVariant = index.data(QmitkMultiLabelTreeModel::ItemModelRole::LabelInstanceValueRole);
auto highlightedValues = m_Model->GetLabelsInSubTree(index);
ActivateLabelHighlights(m_SegmentationNode, highlightedValues);
}
m_AboutToShowContextMenu = false;
}
void QmitkMultiLabelInspector::OnMouseLeave()
{
if (m_SegmentationNode.IsNotNull() && !m_AboutToShowContextMenu)
{
DeactivateLabelHighlights(m_SegmentationNode);
}
else
{
m_AboutToShowContextMenu = false;
}
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h
index 9d660a34d4..af4154d03b 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspector.h
@@ -1,333 +1,334 @@
/*============================================================================
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.
============================================================================*/
#ifndef QmitkMultiLabelInspector_h
#define QmitkMultiLabelInspector_h
#include <MitkSegmentationUIExports.h>
#include <mitkWeakPointer.h>
#include <mitkLabelSetImage.h>
#include <mitkDataNode.h>
#include <QWidget>
#include <QItemSelectionModel>
class QmitkMultiLabelTreeModel;
class QStyledItemDelegate;
class QWidgetAction;
namespace Ui
{
class QmitkMultiLabelInspector;
}
/*
* @brief This is an inspector that offers a tree view on the labels and groups of a MultiLabelSegmentation instance.
* It also allows some manipulation operations an the labels/groups accordin to the UI/selection state.
*/
class MITKSEGMENTATIONUI_EXPORT QmitkMultiLabelInspector : public QWidget
{
Q_OBJECT
public:
QmitkMultiLabelInspector(QWidget* parent = nullptr);
~QmitkMultiLabelInspector();
bool GetMultiSelectionMode() const;
bool GetAllowVisibilityModification() const;
bool GetAllowLockModification() const;
bool GetAllowLabelModification() const;
/** Indicates if the inspector is currently modifiying the model/segmentation.
Thus as long as the manipulation is ongoing, one should assume the model to be in an invalid state.*/
bool GetModelManipulationOngoing() const;
using LabelValueType = mitk::LabelSetImage::LabelValueType;
using LabelValueVectorType = mitk::LabelSetImage::LabelValueVectorType;
/**
* @brief Retrieve the currently selected labels (equals the last CurrentSelectionChanged values).
*/
LabelValueVectorType GetSelectedLabels() const;
/** @brief Returns the label that currently has the focus in the tree view.
*
* The focus is indicated by QTreeView::currentIndex, thus the mouse is over it and it has a dashed border line.
*
* The current label must not equal the selected label(s). If the mouse is not hovering above a label
* (label class or instance item), the method will return nullptr.
*/
mitk::Label* GetCurrentLabel() const;
enum class IndexLevelType
{
Group,
LabelClass,
LabelInstance
};
/** @brief Returns the level of the index that currently has the focus in the tree view.
*
* The focus is indicated by QTreeView::currentIndex, thus the mouse is over it and it has a dashed border line.
*/
IndexLevelType GetCurrentLevelType() const;
/** @brief Returns all label values that are currently affected.
*
* Affected means that these labels (including the one returned by GetCurrentLabel) are in the subtree of the tree
* view element that currently has the focus (indicated by QTreeView::currentIndex, thus the mouse is over it and
* it has a dashed border line.
*/
LabelValueVectorType GetCurrentlyAffactedLabelInstances() const;
/** @brief Returns the values of all label instances that are of the same label (class) like the first selected label instance.
*
* If no label is selected an empty vector will be returned.
*/
LabelValueVectorType GetLabelInstancesOfSelectedFirstLabel() const;
Q_SIGNALS:
/**
* @brief A signal that will be emitted if the selected labels change.
*
* @param labels A list of label values that are now selected.
*/
void CurrentSelectionChanged(LabelValueVectorType labels) const;
/**
* @brief A signal that will be emitted if the user has requested to "go to" a certain label.
*
* Going to a label would be e.g. to focus the renderwindows on the centroid of the label.
* @param label The label that should be focused.
* @param point in World coordinate that should be focused.
*/
void GoToLabel(LabelValueType label, const mitk::Point3D& point) const;
/** @brief Signal that is emitted, if a label should be (re)named and default
* label naming is deactivated.
*
* The instance for which a new name is requested is passed with the signal.
* @param label Pointer to the instance that needs a (new) name.
* @param rename Indicates if it is a renaming or naming of a new label.
+ * @param [out] canceled Indicating if the request was canceled by the used.
*/
- void LabelRenameRequested(mitk::Label* label, bool rename) const;
+ void LabelRenameRequested(mitk::Label* label, bool rename, bool& canceled) const;
/** @brief Signal that is emitted, if the model was updated (e.g. by a delete or add operation).*/
void ModelUpdated() const;
/** @brief Signal is emitted, if the segmentation is changed that is observed by the inspector.*/
void SegmentationChanged() const;
public Q_SLOTS:
/**
* @brief Transform a list of label values into the new selection of the inspector.
* @param selectedLabels A list of selected label values.
* @remark Using this method to select labels will not trigger the CurrentSelectionChanged signal. Observers
* should regard that to avoid signal loops.
*/
void SetSelectedLabels(const LabelValueVectorType& selectedLabels);
/**
* @brief The passed label will be used as new selection in the widget
* @param selectedLabel Value of the selected label.
* @remark Using this method to select labels will not trigger the CurrentSelectionChanged signal. Observers
* should regard that to avoid signal loops.
*/
void SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel);
/** @brief Sets the segmentation that will be used and monitored by the widget.
* @param segmentation A pointer to the segmentation to set.
* @remark You cannot set the segmentation directly if a segmentation node is
* also set. Reset the node (nullptr) if you want to change to direct segmentation
* setting.
* @pre Segmentation node is nullptr.
*/
void SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation);
mitk::LabelSetImage* GetMultiLabelSegmentation() const;
/**
* @brief Sets the segmentation node that will be used /monitored by the widget.
*
* @param node A pointer to the segmentation node.
* @remark If not set some features (e.g. highlighting in render windows) of the inspectors
* are not active.
* @remark Currently it is also needed to circumvent the fact that
* modification of data does not directly trigger modification of the
* node (see T27307).
*/
void SetMultiLabelNode(mitk::DataNode* node);
mitk::DataNode* GetMultiLabelNode() const;
void SetMultiSelectionMode(bool multiMode);
void SetAllowVisibilityModification(bool visiblityMod);
void SetAllowLockModification(bool lockMod);
void SetAllowLabelModification(bool labelMod);
void SetDefaultLabelNaming(bool defaultLabelNaming);
/** @brief Adds an instance of the same label/class like the first label instance
* indicated by GetSelectedLabels() to the segmentation.
*
* This new label instance is returned by the function. If the inspector has no selected label,
* no new instance will be generated and nullptr will be returned.
*
* @remark The new label instance is a clone of the selected label instance.
* Therefore all properties but the LabelValue will be the same.
*
* @pre AllowLabeModification must be set to true.
*/
mitk::Label* AddNewLabelInstance();
/** @brief Adds a new label to the segmentation.
* Depending on the settings the name of
* the label will be either default generated or the rename delegate will be used. The label
* will be added to the same group as the first currently selected label.
*
* @pre AllowLabeModification must be set to true.*/
mitk::Label* AddNewLabel();
/** @brief Removes the first currently selected label instance of the segmentation.
* If no label is selected
* nothing will happen.
*
* @pre AllowLabeModification must be set to true.*/
void DeleteLabelInstance();
/** @brief Delete the first currently selected label and all its instances of the segmentation.
* If no label is selected
* nothing will happen.
*
* @pre AllowLabeModification must be set to true.*/
void DeleteLabel();
/** @brief Adds a new group with a new label to segmentation.
*
* @pre AllowLabeModification must be set to true.*/
mitk::Label* AddNewGroup();
/** @brief Removes the group of the first currently selected label of the segmentation.
*If no label is selected nothing will happen.
*
* @pre AllowLabeModification must be set to true.*/
void RemoveGroup();
void SetVisibilityOfAffectedLabels(bool visible) const;
void SetLockOfAffectedLabels(bool visible) const;
protected:
void Initialize();
void OnModelReset();
void OnDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight,
const QList<int>& roles = QList<int>());
QmitkMultiLabelTreeModel* m_Model;
mitk::LabelSetImage::Pointer m_Segmentation;
LabelValueVectorType m_LastValidSelectedLabels;
QStyledItemDelegate* m_LockItemDelegate;
QStyledItemDelegate* m_ColorItemDelegate;
QStyledItemDelegate* m_VisibilityItemDelegate;
Ui::QmitkMultiLabelInspector* m_Controls;
LabelValueVectorType GetSelectedLabelsFromSelectionModel() const;
void UpdateSelectionModel(const LabelValueVectorType& selectedLabels);
/** @brief Helper that returns the label object (if multiple labels are selected the first).
*/
mitk::Label* GetFirstSelectedLabelObject() const;
mitk::Label* AddNewLabelInternal(const mitk::LabelSetImage::GroupIndexType& containingGroup);
/**@brief Adds an instance of the same label/class like the passed label value
*/
mitk::Label* AddNewLabelInstanceInternal(mitk::Label* templateLabel);
void RemoveGroupInternal(const mitk::LabelSetImage::GroupIndexType& groupID);
void DeleteLabelInternal(const LabelValueVectorType& labelValues);
private Q_SLOTS:
/** @brief Transform a labels selection into a data node list and emit the 'CurrentSelectionChanged'-signal.
*
* The function adds the selected nodes from the original selection that could not be modified, if
* m_SelectOnlyVisibleNodes is false.
* This slot is internally connected to the 'selectionChanged'-signal of the selection model of the private member item view.
*
* @param selected The newly selected items.
* @param deselected The newly deselected items.
*/
void OnChangeModelSelection(const QItemSelection& selected, const QItemSelection& deselected);
void OnContextMenuRequested(const QPoint&);
void OnAddLabel();
void OnAddLabelInstance();
void OnDeleteGroup();
void OnDeleteAffectedLabel();
void OnDeleteLabels(bool);
void OnClearLabels(bool);
void OnMergeLabels(bool);
void OnRenameLabel(bool);
void OnClearLabel(bool);
void OnUnlockAffectedLabels();
void OnLockAffectedLabels();
void OnSetAffectedLabelsVisible();
void OnSetAffectedLabelsInvisible();
void OnSetOnlyActiveLabelVisible(bool);
void OnItemDoubleClicked(const QModelIndex& index);
void WaitCursorOn() const;
void WaitCursorOff() const;
void RestoreOverrideCursor() const;
void PrepareGoToLabel(LabelValueType labelID) const;
void OnEntered(const QModelIndex& index);
void OnMouseLeave();
QWidgetAction* CreateOpacityAction();
private:
bool m_ShowVisibility = true;
bool m_ShowLock = true;
bool m_ShowOther = false;
/** @brief Indicates if the context menu allows changes in visiblity.
*
* Visiblity includes also color
*/
bool m_AllowVisibilityModification = true;
/** @brief Indicates if the context menu allows changes in lock state.
*/
bool m_AllowLockModification = true;
/** @brief Indicates if the context menu allows label modifications (adding, removing, renaming ...)
*/
bool m_AllowLabelModification = false;
bool m_DefaultLabelNaming = true;
bool m_ModelManipulationOngoing = false;
bool m_AboutToShowContextMenu = false;
mitk::DataNode::Pointer m_SegmentationNode;
unsigned long m_SegmentationNodeDataMTime;
mitk::ITKEventObserverGuard m_SegmentationObserver;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
index e9d4f15e15..36eac12056 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
@@ -1,562 +1,563 @@
/*============================================================================
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 <QmitkMultiLabelManager.h>
// mitk
#include <mitkAutoCropImageFilter.h>
#include <mitkCoreObjectFactory.h>
#include <mitkIOUtil.h>
#include <mitkLabelSetImage.h>
#include <mitkLabelSetImageToSurfaceThreadedFilter.h>
#include <mitkLabelSetImageConverter.h>
#include <mitkRenderingManager.h>
#include <mitkShowSegmentationAsSurface.h>
#include <mitkStatusBar.h>
#include <mitkToolManagerProvider.h>
// Qmitk
#include <QmitkStyleManager.h>
#include <QmitkMultiLabelPresetHelper.h>
// Qt
#include <QLabel>
#include <QWidgetAction>
#include <QColorDialog>
#include <QCompleter>
#include <QDateTime>
#include <QFileDialog>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QShortcut>
#include <QStringListModel>
// itk
#include <itksys/SystemTools.hxx>
#include <ui_QmitkMultiLabelManagerControls.h>
QmitkMultiLabelManager::QmitkMultiLabelManager(QWidget *parent)
: QWidget(parent), m_Controls(new Ui::QmitkMultiLabelManagerControls), m_Completer(nullptr), m_ProcessingManualSelection(false), m_DataStorage(nullptr)
{
m_Controls->setupUi(this);
m_Controls->labelSearchBox->setAlwaysShowClearIcon(true);
m_Controls->labelSearchBox->setShowSearchIcon(true);
QStringList completionList;
completionList << "";
m_Completer = new QCompleter(completionList, this);
m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
m_Controls->labelSearchBox->setCompleter(m_Completer);
m_Controls->labelInspector->SetAllowLabelModification(true);
connect(m_Controls->labelSearchBox, SIGNAL(returnPressed()), this, SLOT(OnSearchLabel()));
QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
completeModel->setStringList(GetLabelStringList());
// See T29549
m_Controls->labelSearchBox->hide();
m_Controls->btnSavePreset->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg")));
m_Controls->btnLoadPreset->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg")));
m_Controls->btnAddLabel->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add.svg")));
m_Controls->btnAddInstance->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_add_instance.svg")));
m_Controls->btnAddGroup->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_group_add.svg")));
m_Controls->btnRemoveLabel->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete.svg")));
m_Controls->btnRemoveInstance->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_label_delete_instance.svg")));
m_Controls->btnRemoveGroup->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/icon_group_delete.svg")));
connect(m_Controls->btnAddLabel, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabel);
connect(m_Controls->btnRemoveLabel, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::DeleteLabel);
connect(m_Controls->btnAddInstance, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabelInstance);
connect(m_Controls->btnRemoveInstance, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::DeleteLabelInstance);
connect(m_Controls->btnAddGroup, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewGroup);
connect(m_Controls->btnRemoveGroup, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::RemoveGroup);
connect(m_Controls->btnSavePreset, &QToolButton::clicked, this, &QmitkMultiLabelManager::OnSavePreset);
connect(m_Controls->btnLoadPreset, &QToolButton::clicked, this, &QmitkMultiLabelManager::OnLoadPreset);
connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::GoToLabel, this, &QmitkMultiLabelManager::OnGoToLabel);
connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::LabelRenameRequested, this, &QmitkMultiLabelManager::OnLabelRenameRequested);
connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::CurrentSelectionChanged, this, &QmitkMultiLabelManager::OnSelectedLabelChanged);
connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::ModelUpdated, this, &QmitkMultiLabelManager::OnModelUpdated);
connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::SegmentationChanged, this, &QmitkMultiLabelManager::OnSegmentationChanged);
auto* renameLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_R), this);
connect(renameLabelShortcut, &QShortcut::activated, this, &QmitkMultiLabelManager::OnRenameLabelShortcutActivated);
auto* addLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_A), this);
connect(addLabelShortcut, &QShortcut::activated, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabel);
auto* addLabelInstanceShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_I), this);
connect(addLabelInstanceShortcut, &QShortcut::activated, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabelInstance);
auto* deleteLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_D), this);
connect(deleteLabelShortcut, &QShortcut::activated, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::DeleteLabelInstance);
this->UpdateControls();
}
QmitkMultiLabelManager::~QmitkMultiLabelManager()
{
this->SetMultiLabelSegmentation(nullptr);
delete m_Controls;
}
QmitkMultiLabelManager::LabelValueVectorType QmitkMultiLabelManager::GetSelectedLabels() const
{
return m_Controls->labelInspector->GetSelectedLabels();
}
void QmitkMultiLabelManager::OnRenameLabelShortcutActivated()
{
auto selectedLabels = this->GetSelectedLabels();
for (auto labelValue : selectedLabels)
{
auto currentLabel = this->GetMultiLabelSegmentation()->GetLabel(labelValue);
- emit LabelRenameRequested(currentLabel, true);
+ bool canceled = false;
+ emit LabelRenameRequested(currentLabel, true, canceled);
}
}
void QmitkMultiLabelManager::OnSelectedLabelChanged(const LabelValueVectorType& labels)
{
this->UpdateControls();
if (labels.empty() || labels.size() > 1) return;
emit CurrentSelectionChanged(labels);
}
QStringList &QmitkMultiLabelManager::GetLabelStringList()
{
return m_LabelStringList;
}
void QmitkMultiLabelManager::SetDefaultLabelNaming(bool defaultLabelNaming)
{
this->m_Controls->labelInspector->SetDefaultLabelNaming(defaultLabelNaming);
}
void QmitkMultiLabelManager::setEnabled(bool enabled)
{
QWidget::setEnabled(enabled);
UpdateControls();
}
void QmitkMultiLabelManager::SetSelectedLabels(const LabelValueVectorType& selectedLabels)
{
this->m_Controls->labelInspector->SetSelectedLabels(selectedLabels);
UpdateControls();
}
void QmitkMultiLabelManager::SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel)
{
this->m_Controls->labelInspector->SetSelectedLabel(selectedLabel);
UpdateControls();
}
void QmitkMultiLabelManager::SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation)
{
this->m_Controls->labelInspector->SetMultiLabelSegmentation(segmentation);
//Update of controls and observers is done in OnSegmentationChanged()
// which is triggered by the inspector when setting the segmentation or node
}
mitk::LabelSetImage* QmitkMultiLabelManager::GetMultiLabelSegmentation() const
{
return this->m_Controls->labelInspector->GetMultiLabelSegmentation();
}
void QmitkMultiLabelManager::SetMultiLabelNode(mitk::DataNode* node)
{
this->m_Controls->labelInspector->SetMultiLabelNode(node);
}
mitk::DataNode* QmitkMultiLabelManager::GetMultiLabelNode() const
{
return this->m_Controls->labelInspector->GetMultiLabelNode();
}
void QmitkMultiLabelManager::SetDataStorage(mitk::DataStorage *storage)
{
m_DataStorage = storage;
}
void QmitkMultiLabelManager::OnSearchLabel()
{
//std::string text = m_Controls->labelSearchBox->text().toStdString();
//int pixelValue = -1;
//int row = -1;
//for (int i = 0; i < m_Controls->m_LabelSetTableWidget->rowCount(); ++i)
//{
// if (m_Controls->m_LabelSetTableWidget->item(i, 0)->text().toStdString().compare(text) == 0)
// {
// pixelValue = m_Controls->m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt();
// row = i;
// break;
// }
//}
//if (pixelValue == -1)
//{
// return;
//}
//GetWorkingImage()->GetActiveLabelSet()->SetActiveLabel(pixelValue);
//QTableWidgetItem *nameItem = m_Controls->m_LabelSetTableWidget->item(row, NAME_COL);
//if (!nameItem)
//{
// return;
//}
//m_Controls->m_LabelSetTableWidget->clearSelection();
//m_Controls->m_LabelSetTableWidget->selectRow(row);
//m_Controls->m_LabelSetTableWidget->scrollToItem(nameItem);
//GetWorkingImage()->GetActiveLabelSet()->SetActiveLabel(pixelValue);
//this->WaitCursorOn();
//mitk::Point3D pos =
// GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetCenterOfMassCoordinates();
//m_ToolManager->WorkingDataChanged();
//if (pos.GetVnlVector().max_value() > 0.0)
//{
// emit goToLabel(pos);
//}
//else
//{
// GetWorkingImage()->UpdateCenterOfMass(pixelValue, GetWorkingImage()->GetActiveLayer());
// mitk::Point3D pos =
// GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetCenterOfMassCoordinates();
// emit goToLabel(pos);
//}
//this->WaitCursorOff();
}
void QmitkMultiLabelManager::UpdateControls()
{
bool hasWorkingData = this->GetMultiLabelSegmentation() != nullptr;
auto labels = this->m_Controls->labelInspector->GetSelectedLabels();
bool hasMultipleInstances = this->m_Controls->labelInspector->GetLabelInstancesOfSelectedFirstLabel().size() > 1;
m_Controls->labelSearchBox->setEnabled(hasWorkingData);
m_Controls->btnAddGroup->setEnabled(hasWorkingData);
m_Controls->btnAddInstance->setEnabled(hasWorkingData && labels.size()==1);
m_Controls->btnAddLabel->setEnabled(hasWorkingData);
m_Controls->btnLoadPreset->setEnabled(hasWorkingData);
m_Controls->btnRemoveGroup->setEnabled(hasWorkingData && !labels.empty() && this->GetMultiLabelSegmentation()->GetNumberOfLayers()>1);
m_Controls->btnRemoveLabel->setEnabled(hasWorkingData && !labels.empty());
m_Controls->btnRemoveInstance->setEnabled(hasWorkingData && !labels.empty() && hasMultipleInstances);
m_Controls->btnSavePreset->setEnabled(hasWorkingData);
if (!hasWorkingData)
return;
QStringListModel *completeModel = dynamic_cast<QStringListModel *>(m_Completer->model());
completeModel->setStringList(GetLabelStringList());
}
void QmitkMultiLabelManager::OnCreateCroppedMask(bool)
{
mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
mitk::Image::Pointer maskImage;
auto currentLabel = this->GetMultiLabelSegmentation()->GetLabel(this->GetSelectedLabels().front());
auto pixelValue = currentLabel->GetValue();
try
{
this->WaitCursorOn();
mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
cropFilter->SetInput(mitk::CreateLabelMask(this->GetMultiLabelSegmentation(),pixelValue));
cropFilter->SetBackgroundValue(0);
cropFilter->SetMarginFactor(1.15);
cropFilter->Update();
maskImage = cropFilter->GetOutput();
this->WaitCursorOff();
}
catch (mitk::Exception &e)
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
return;
}
if (maskImage.IsNull())
{
QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
return;
}
mitk::DataNode::Pointer maskNode = mitk::DataNode::New();
std::string name = currentLabel->GetName();
name += "-mask";
maskNode->SetName(name);
maskNode->SetData(maskImage);
maskNode->SetBoolProperty("binary", true);
maskNode->SetBoolProperty("outline binary", true);
maskNode->SetBoolProperty("outline binary shadow", true);
maskNode->SetFloatProperty("outline width", 2.0);
maskNode->SetColor(currentLabel->GetColor());
maskNode->SetOpacity(1.0);
m_DataStorage->Add(maskNode, this->GetMultiLabelNode());
}
void QmitkMultiLabelManager::OnCreateMask(bool /*triggered*/)
{
mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
auto currentLabel = this->GetMultiLabelSegmentation()->GetLabel(this->GetSelectedLabels().front());
auto pixelValue = currentLabel->GetValue();
mitk::Image::Pointer maskImage;
try
{
this->WaitCursorOn();
maskImage = mitk::CreateLabelMask(GetMultiLabelSegmentation(),pixelValue);
this->WaitCursorOff();
}
catch (mitk::Exception &e)
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
return;
}
if (maskImage.IsNull())
{
QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
return;
}
mitk::DataNode::Pointer maskNode = mitk::DataNode::New();
std::string name = currentLabel->GetName();
name += "-mask";
maskNode->SetName(name);
maskNode->SetData(maskImage);
maskNode->SetBoolProperty("binary", true);
maskNode->SetBoolProperty("outline binary", true);
maskNode->SetBoolProperty("outline binary shadow", true);
maskNode->SetFloatProperty("outline width", 2.0);
maskNode->SetColor(currentLabel->GetColor());
maskNode->SetOpacity(1.0);
m_DataStorage->Add(maskNode, this->GetMultiLabelNode());
}
void QmitkMultiLabelManager::OnCreateSmoothedSurface(bool /*triggered*/)
{
mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
auto currentLabel = this->GetMultiLabelSegmentation()->GetLabel(this->GetSelectedLabels().front());
auto pixelValue = currentLabel->GetValue();
mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer successCommand =
itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
successCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer errorCommand =
itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
errorCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
mitk::DataNode::Pointer groupNode = this->GetMultiLabelNode();
surfaceFilter->SetPointerParameter("Group node", groupNode);
surfaceFilter->SetPointerParameter("Input", this->GetMultiLabelSegmentation());
surfaceFilter->SetParameter("RequestedLabel", pixelValue);
surfaceFilter->SetParameter("Smooth", true);
surfaceFilter->SetDataStorage(*m_DataStorage);
mitk::StatusBar::GetInstance()->DisplayText("Surface creation is running in background...");
try
{
surfaceFilter->StartAlgorithm();
}
catch (mitk::Exception &e)
{
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this,
"Create Surface",
"Could not create a surface mesh out of the selected label. See error log for details.\n");
}
}
void QmitkMultiLabelManager::OnCreateDetailedSurface(bool /*triggered*/)
{
mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
auto currentLabel = this->GetMultiLabelSegmentation()->GetLabel(this->GetSelectedLabels().front());
auto pixelValue = currentLabel->GetValue();
mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer successCommand =
itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
successCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer errorCommand =
itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
errorCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
mitk::DataNode::Pointer groupNode = this->GetMultiLabelNode();
surfaceFilter->SetPointerParameter("Group node", groupNode);
surfaceFilter->SetPointerParameter("Input", this->GetMultiLabelSegmentation());
surfaceFilter->SetParameter("RequestedLabel", pixelValue);
surfaceFilter->SetParameter("Smooth", false);
surfaceFilter->SetDataStorage(*m_DataStorage);
mitk::StatusBar::GetInstance()->DisplayText("Surface creation is running in background...");
try
{
surfaceFilter->StartAlgorithm();
}
catch (mitk::Exception &e)
{
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this,
"Create Surface",
"Could not create a surface mesh out of the selected label. See error log for details.\n");
}
}
void QmitkMultiLabelManager::OnSavePreset()
{
QmitkSaveMultiLabelPreset(this->GetMultiLabelSegmentation());
}
void QmitkMultiLabelManager::OnLoadPreset()
{
QmitkLoadMultiLabelPreset({ this->GetMultiLabelSegmentation() });
}
void QmitkMultiLabelManager::OnGoToLabel(mitk::LabelSetImage::LabelValueType label, const mitk::Point3D& position) const
{
emit GoToLabel(label, position);
}
-void QmitkMultiLabelManager::OnLabelRenameRequested(mitk::Label* label, bool rename) const
+void QmitkMultiLabelManager::OnLabelRenameRequested(mitk::Label* label, bool rename, bool& canceled) const
{
- emit LabelRenameRequested(label, rename);
+ emit LabelRenameRequested(label, rename, canceled);
}
void QmitkMultiLabelManager::WaitCursorOn()
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
}
void QmitkMultiLabelManager::WaitCursorOff()
{
this->RestoreOverrideCursor();
}
void QmitkMultiLabelManager::RestoreOverrideCursor()
{
QApplication::restoreOverrideCursor();
}
void QmitkMultiLabelManager::OnThreadedCalculationDone()
{
mitk::StatusBar::GetInstance()->Clear();
}
void QmitkMultiLabelManager::AddSegmentationObserver()
{
if (this->GetMultiLabelSegmentation() != nullptr)
{
auto& widget = *this;
m_LabelAddedObserver.Reset(this->GetMultiLabelSegmentation(), mitk::LabelAddedEvent(), [&widget](const itk::EventObject& event)
{
auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&event);
widget.OnLabelEvent(labelEvent->GetLabelValue());
});
m_LabelModifiedObserver.Reset(this->GetMultiLabelSegmentation(), mitk::LabelModifiedEvent(), [&widget](const itk::EventObject& event)
{
auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&event);
widget.OnLabelEvent(labelEvent->GetLabelValue());
});
m_LabelRemovedObserver.Reset(this->GetMultiLabelSegmentation(), mitk::LabelRemovedEvent(), [&widget](const itk::EventObject& event)
{
auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&event);
widget.OnLabelEvent(labelEvent->GetLabelValue());
});
m_GroupAddedObserver.Reset(this->GetMultiLabelSegmentation(), mitk::GroupAddedEvent(), [&widget](const itk::EventObject& event)
{
auto groupEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&event);
widget.OnGroupEvent(groupEvent->GetGroupID());
});
m_GroupModifiedObserver.Reset(this->GetMultiLabelSegmentation(), mitk::GroupModifiedEvent(), [&widget](const itk::EventObject& event)
{
auto groupEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&event);
widget.OnGroupEvent(groupEvent->GetGroupID());
});
m_GroupRemovedObserver.Reset(this->GetMultiLabelSegmentation(), mitk::GroupRemovedEvent(), [&widget](const itk::EventObject& event)
{
auto groupEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&event);
widget.OnGroupEvent(groupEvent->GetGroupID());
});
}
}
void QmitkMultiLabelManager::RemoveSegmentationObserver()
{
m_LabelAddedObserver.Reset();
m_LabelModifiedObserver.Reset();
m_LabelRemovedObserver.Reset();
m_GroupAddedObserver.Reset();
m_GroupModifiedObserver.Reset();
m_GroupRemovedObserver.Reset();
}
void QmitkMultiLabelManager::OnLabelEvent(mitk::LabelSetImage::LabelValueType /*labelValue*/)
{
if (!m_Controls->labelInspector->GetModelManipulationOngoing())
this->UpdateControls();
}
void QmitkMultiLabelManager::OnGroupEvent(mitk::LabelSetImage::GroupIndexType /*groupIndex*/)
{
if (!m_Controls->labelInspector->GetModelManipulationOngoing())
this->UpdateControls();
}
void QmitkMultiLabelManager::OnModelUpdated()
{
this->UpdateControls();
}
void QmitkMultiLabelManager::OnSegmentationChanged()
{
this->RemoveSegmentationObserver();
this->AddSegmentationObserver();
UpdateControls();
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.h b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.h
index 13461c642d..d0764c1e4e 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.h
@@ -1,198 +1,198 @@
/*============================================================================
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.
============================================================================*/
#ifndef QmitkMultiLabelManager_h
#define QmitkMultiLabelManager_h
#include <MitkSegmentationUIExports.h>
#include <mitkLabelSetImage.h>
#include <mitkDataNode.h>
#include <mitkNumericTypes.h>
#include <mitkITKEventObserverGuard.h>
#include <QWidget>
class QmitkDataStorageComboBox;
class QCompleter;
namespace Ui
{
class QmitkMultiLabelManagerControls;
}
namespace mitk
{
class DataStorage;
}
class MITKSEGMENTATIONUI_EXPORT QmitkMultiLabelManager : public QWidget
{
Q_OBJECT
public:
explicit QmitkMultiLabelManager(QWidget *parent = nullptr);
~QmitkMultiLabelManager() override;
using LabelValueVectorType = mitk::LabelSetImage::LabelValueVectorType;
/**
* @brief Retrieve the currently selected labels (equals the last CurrentSelectionChanged values).
*/
LabelValueVectorType GetSelectedLabels() const;
mitk::LabelSetImage* GetMultiLabelSegmentation() const;
mitk::DataNode* GetMultiLabelNode() const;
Q_SIGNALS:
/**
* @brief A signal that will be emitted if the selected labels change.
*
* @param labels A list of label values that are now selected.
*/
void CurrentSelectionChanged(const LabelValueVectorType& labels);
/**
* @brief A signal that will be emitted if the user has requested to "go to" a certain label.
*
* Going to a label would be e.g. to focus the render windows on the centroid of the label.
* @param label The label that should be focused.
* @param point in World coordinate that should be focused.
*/
void GoToLabel(mitk::LabelSetImage::LabelValueType label, const mitk::Point3D& point) const;
/** @brief Signal that is emitted, if a label should be (re)named and default
* label naming is deactivated.
*
* The instance for which a new name is requested is passed with the signal.
* @param label Pointer to the instance that needs a (new) name.
- * @param rename Indicates if it is a renaming or naming of a new label.
- */
- void LabelRenameRequested(mitk::Label* label, bool rename) const;
+ * @param [out] canceled Indicating if the request was canceled by the used.
+ */
+ void LabelRenameRequested(mitk::Label* label, bool rename, bool& canceled) const;
public Q_SLOTS:
/**
* @brief Transform a list label values into a model selection and set this as a new selection of the view
*
* @param selectedLabels A list of data nodes that should be newly selected.
*/
void SetSelectedLabels(const LabelValueVectorType& selectedLabels);
/**
* @brief Selects the passed label instance and sets a new selection of the view
*
* @param selectedLabel Value of the label instance that should be selected.
*/
void SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel);
/**
* @brief Sets the segmentation that will be used /monitored by the widget.
*
* @param segmentation A pointer to the segmentation to set.
* @remark You cannot set the segmentation directly if a segmentation node is
* also set. Reset the node (nullptr) if you want to change to direct segmentation
* setting.
* @pre Segmentation node is nullptr.
*/
void SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation);
/**
* @brief Sets the segmentation node that will be used /monitored by the widget.
*
* @param node A pointer to the segmentation node.
* @remark If not set some features of the manager are not active
*/
void SetMultiLabelNode(mitk::DataNode* node);
void SetDataStorage(mitk::DataStorage *storage);
void UpdateControls();
virtual void setEnabled(bool enabled);
QStringList &GetLabelStringList();
void SetDefaultLabelNaming(bool defaultLabelNaming);
private Q_SLOTS:
// LabelSet dependent
void OnRenameLabelShortcutActivated();
// reaction to "returnPressed" signal from ...
void OnSearchLabel();
// reaction to the change of labels. If multiple labels are selected, it is ignored.
void OnSelectedLabelChanged(const LabelValueVectorType& labels);
// LabelSetImage Dependet
void OnCreateDetailedSurface(bool);
void OnCreateSmoothedSurface(bool);
// reaction to the signal "createMask" from QmitkLabelSetTableWidget
void OnCreateMask(bool);
// reaction to the signal "createCroppedMask" from QmitkLabelSetTableWidget
void OnCreateCroppedMask(bool);
void OnSavePreset();
void OnLoadPreset();
void OnGoToLabel(mitk::LabelSetImage::LabelValueType label, const mitk::Point3D& position) const;
- void OnLabelRenameRequested(mitk::Label* label, bool rename) const;
+ void OnLabelRenameRequested(mitk::Label* label, bool rename, bool& canceled) const;
void OnModelUpdated();
void OnSegmentationChanged();
private:
enum TableColumns
{
NAME_COL = 0,
LOCKED_COL,
COLOR_COL,
VISIBLE_COL
};
void WaitCursorOn();
void WaitCursorOff();
void RestoreOverrideCursor();
void OnThreadedCalculationDone();
void AddSegmentationObserver();
void RemoveSegmentationObserver();
void OnLabelEvent(mitk::LabelSetImage::LabelValueType labelValue);
void OnGroupEvent(mitk::LabelSetImage::GroupIndexType groupIndex);
Ui::QmitkMultiLabelManagerControls* m_Controls;
QCompleter *m_Completer;
QStringList m_OrganColors;
QStringList m_LabelStringList;
bool m_ProcessingManualSelection;
mitk::DataStorage* m_DataStorage;
mitk::ITKEventObserverGuard m_LabelAddedObserver;
mitk::ITKEventObserverGuard m_LabelModifiedObserver;
mitk::ITKEventObserverGuard m_LabelRemovedObserver;
mitk::ITKEventObserverGuard m_GroupAddedObserver;
mitk::ITKEventObserverGuard m_GroupModifiedObserver;
mitk::ITKEventObserverGuard m_GroupRemovedObserver;
};
#endif
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 f57666d0d8..ee8e53c007 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1088 +1,1088 @@
/*============================================================================
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 <berryIWorkbenchPage.h>
// mitk
#include <mitkApplicationCursor.h>
#include <mitkBaseApplication.h>
#include <mitkBaseRendererHelper.h>
#include <mitkCameraController.h>
#include <mitkLabelSetImage.h>
#include <mitkLabelSetImageHelper.h>
#include <mitkMultiLabelIOHelper.h>
#include <mitkManualPlacementAnnotationRenderer.h>
#include <mitkNodePredicateSubGeometry.h>
#include <mitkSegmentationObjectFactory.h>
#include <mitkSegTool2D.h>
#include <mitkStatusBar.h>
#include <mitkToolManagerProvider.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkWorkbenchUtil.h>
#include <mitkIPreferences.h>
#include <mitkMultiLabelPredicateHelper.h>
// Qmitk
#include <QmitkRenderWindow.h>
#include <QmitkStaticDynamicSegmentationDialog.h>
#include <QmitkNewSegmentationDialog.h>
#include <QmitkMultiLabelManager.h>
// us
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
// Qt
#include <QMessageBox>
#include <QShortcut>
#include <QDir>
// vtk
#include <vtkQImageToImageSource.h>
#include <regex>
namespace
{
QList<QmitkRenderWindow*> Get2DWindows(const QList<QmitkRenderWindow*> allWindows)
{
QList<QmitkRenderWindow*> all2DWindows;
for (auto* window : allWindows)
{
if (window->GetRenderer()->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
all2DWindows.append(window);
}
}
return all2DWindows;
}
}
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_DrawOutline(true)
, m_SelectionMode(false)
, m_MouseCursorSet(false)
, m_DefaultLabelNaming(true)
, m_SelectionChangeIsAlreadyBeingHandled(false)
{
m_SegmentationPredicate = mitk::GetMultiLabelSegmentationPredicate();
m_ReferencePredicate = mitk::GetSegmentationReferenceImagePredicate();
}
QmitkSegmentationView::~QmitkSegmentationView()
{
if (nullptr != m_Controls)
{
// deactivate all tools
m_ToolManager->ActivateTool(-1);
// removing all observers from working data
for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
{
(*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
}
m_WorkingDataObserverTags.clear();
this->RemoveObserversFromWorkingImage();
// removing all observers from reference data
for (NodeTagMapType::iterator dataIter = m_ReferenceDataObserverTags.begin(); dataIter != m_ReferenceDataObserverTags.end(); ++dataIter)
{
(*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
}
m_ReferenceDataObserverTags.clear();
mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
service->RemoveAllPlanePositions();
context->ungetService(ppmRef);
m_ToolManager->SetReferenceData(nullptr);
m_ToolManager->SetWorkingData(nullptr);
}
m_ToolManager->ActiveToolChanged -=
mitk::MessageDelegate<Self>(this, &Self::ActiveToolChanged);
delete m_Controls;
}
/**********************************************************************/
/* private Q_SLOTS */
/**********************************************************************/
void QmitkSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer>)
{
this->OnAnySelectionChanged();
}
void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer>)
{
this->OnAnySelectionChanged();
}
void QmitkSegmentationView::OnAnySelectionChanged()
{
// When only a segmentation has been selected and the method is then called by a reference image selection,
// the already selected segmentation may not match the geometry predicate of the new reference image anymore.
// This will trigger a recursive call of this method further below. While it would be resolved gracefully, we
// can spare the extra call with an early-out. The original call of this method will handle the segmentation
// selection change afterwards anyway.
if (m_SelectionChangeIsAlreadyBeingHandled)
return;
auto selectedReferenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
bool referenceNodeChanged = false;
m_ToolManager->ActivateTool(-1);
if (m_ReferenceNode != selectedReferenceNode)
{
referenceNodeChanged = true;
// Remove visibility observer for the current reference node
if (m_ReferenceDataObserverTags.find(m_ReferenceNode) != m_ReferenceDataObserverTags.end())
{
m_ReferenceNode->GetProperty("visible")->RemoveObserver(m_ReferenceDataObserverTags[m_ReferenceNode]);
m_ReferenceDataObserverTags.erase(m_ReferenceNode);
}
// Set new reference node
m_ReferenceNode = selectedReferenceNode;
m_ToolManager->SetReferenceData(m_ReferenceNode);
// Prepare for a potential recursive call when changing node predicates of the working node selector
m_SelectionChangeIsAlreadyBeingHandled = true;
if (m_ReferenceNode.IsNull())
{
// Without a reference image, allow all segmentations to be selected
m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
m_SelectionChangeIsAlreadyBeingHandled = false;
}
else
{
// With a reference image, only allow segmentations that fit the geometry of the reference image to be selected.
m_Controls->workingNodeSelector->SetNodePredicate(mitk::GetMultiLabelSegmentationPredicate(m_ReferenceNode->GetData()->GetGeometry()));
m_SelectionChangeIsAlreadyBeingHandled = false;
this->ApplySelectionModeOnReferenceNode();
// Add visibility observer for the new reference node
auto command = itk::SimpleMemberCommand<Self>::New();
command->SetCallbackFunction(this, &Self::ValidateSelectionInput);
m_ReferenceDataObserverTags[m_ReferenceNode] =
m_ReferenceNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command);
}
}
auto selectedWorkingNode = m_Controls->workingNodeSelector->GetSelectedNode();
bool workingNodeChanged = false;
if (m_WorkingNode != selectedWorkingNode)
{
workingNodeChanged = true;
this->RemoveObserversFromWorkingImage();
// Remove visibility observer for the current working node
if (m_WorkingDataObserverTags.find(m_WorkingNode) != m_WorkingDataObserverTags.end())
{
m_WorkingNode->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[m_WorkingNode]);
m_WorkingDataObserverTags.erase(m_WorkingNode);
}
// Set new working node
m_WorkingNode = selectedWorkingNode;
m_ToolManager->SetWorkingData(m_WorkingNode);
if (m_WorkingNode.IsNotNull())
{
this->ApplySelectionModeOnWorkingNode();
// Add visibility observer for the new segmentation node
auto command = itk::SimpleMemberCommand<Self>::New();
command->SetCallbackFunction(this, &Self::ValidateSelectionInput);
m_WorkingDataObserverTags[m_WorkingNode] =
m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command);
this->AddObserversToWorkingImage();
}
}
// Reset camera if any selection changed but only if both reference node and working node are set
if ((referenceNodeChanged || workingNodeChanged) && (m_ReferenceNode.IsNotNull() && m_WorkingNode.IsNotNull()))
{
if (nullptr != m_RenderWindowPart)
{
m_RenderWindowPart->InitializeViews(m_ReferenceNode->GetData()->GetTimeGeometry(), false);
}
}
this->UpdateGUI();
}
void QmitkSegmentationView::OnLabelAdded(mitk::LabelSetImage::LabelValueType)
{
this->ValidateSelectionInput();
}
void QmitkSegmentationView::OnLabelRemoved(mitk::LabelSetImage::LabelValueType)
{
this->ValidateSelectionInput();
}
void QmitkSegmentationView::OnGroupRemoved(mitk::LabelSetImage::GroupIndexType)
{
this->ValidateSelectionInput();
}
mitk::LabelSetImage* QmitkSegmentationView::GetWorkingImage()
{
if (m_WorkingNode.IsNull())
return nullptr;
return dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
}
void QmitkSegmentationView::AddObserversToWorkingImage()
{
auto* workingImage = this->GetWorkingImage();
if (workingImage != nullptr)
{
auto& widget = *this;
m_LabelAddedObserver.Reset(workingImage, mitk::LabelAddedEvent(), [&widget](const itk::EventObject& event)
{
auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&event);
widget.OnLabelAdded(labelEvent->GetLabelValue());
});
m_LabelRemovedObserver.Reset(workingImage, mitk::LabelRemovedEvent(), [&widget](const itk::EventObject& event)
{
auto labelEvent = dynamic_cast<const mitk::AnyLabelEvent*>(&event);
widget.OnLabelRemoved(labelEvent->GetLabelValue());
});
m_GroupRemovedObserver.Reset(workingImage, mitk::GroupRemovedEvent(), [&widget](const itk::EventObject& event)
{
auto groupEvent = dynamic_cast<const mitk::AnyGroupEvent*>(&event);
widget.OnGroupRemoved(groupEvent->GetGroupID());
});
}
}
void QmitkSegmentationView::RemoveObserversFromWorkingImage()
{
m_LabelAddedObserver.Reset();
m_LabelRemovedObserver.Reset();
m_GroupRemovedObserver.Reset();
}
void QmitkSegmentationView::OnVisibilityShortcutActivated()
{
if (m_WorkingNode.IsNull())
{
return;
}
bool isVisible = false;
m_WorkingNode->GetBoolProperty("visible", isVisible);
m_WorkingNode->SetVisibility(!isVisible);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSegmentationView::OnLabelToggleShortcutActivated()
{
if (m_WorkingNode.IsNull())
{
return;
}
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
if (nullptr == workingImage)
{
return;
}
this->WaitCursorOn();
auto labels = workingImage->GetLabelValuesByGroup(workingImage->GetActiveLayer());
auto it = std::find(labels.begin(), labels.end(), workingImage->GetActiveLabel()->GetValue());
if (it != labels.end())
++it;
if (it == labels.end())
{
it = labels.begin();
}
workingImage->SetActiveLabel(*it);
m_Controls->multiLabelWidget->SetSelectedLabel(*it);
this->WaitCursorOff();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSegmentationView::OnNewSegmentation()
{
m_ToolManager->ActivateTool(-1);
if (m_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*>(m_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;
}
auto segTemplateImage = referenceImage;
if (referenceImage->GetDimension() > 3)
{
QmitkStaticDynamicSegmentationDialog dialog(m_Parent);
dialog.SetReferenceImage(referenceImage.GetPointer());
dialog.exec();
segTemplateImage = dialog.GetSegmentationTemplate();
}
mitk::DataNode::Pointer newSegmentationNode;
try
{
this->WaitCursorOn();
newSegmentationNode = mitk::LabelSetImageHelper::CreateNewSegmentationNode(m_ReferenceNode, segTemplateImage);
this->WaitCursorOff();
}
catch (mitk::Exception& e)
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::warning(m_Parent, "New segmentation", "Could not create a new segmentation.");
return;
}
auto newLabelSetImage = dynamic_cast<mitk::LabelSetImage*>(newSegmentationNode->GetData());
if (nullptr == newLabelSetImage)
{
// something went wrong
return;
}
const auto labelSetPreset = this->GetDefaultLabelSetPreset();
if (labelSetPreset.empty() || !mitk::MultiLabelIOHelper::LoadLabelSetImagePreset(labelSetPreset, newLabelSetImage))
{
auto newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
if (!m_DefaultLabelNaming)
QmitkNewSegmentationDialog::DoRenameLabel(newLabel, nullptr, m_Parent);
newLabelSetImage->AddLabel(newLabel, newLabelSetImage->GetActiveLayer());
}
if (!this->GetDataStorage()->Exists(newSegmentationNode))
{
this->GetDataStorage()->Add(newSegmentationNode, m_ReferenceNode);
}
if (m_ToolManager->GetWorkingData(0))
{
m_ToolManager->GetWorkingData(0)->SetSelected(false);
}
newSegmentationNode->SetSelected(true);
m_Controls->workingNodeSelector->SetCurrentSelectedNode(newSegmentationNode);
}
std::string QmitkSegmentationView::GetDefaultLabelSetPreset() const
{
auto labelSetPreset = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABELSET_PRESET.toStdString(), "");
if (labelSetPreset.empty())
labelSetPreset = m_LabelSetPresetPreference.toStdString();
return labelSetPreset;
}
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<mitk::SegTool2D*>(m_ToolManager->GetToolById(i));
if (nullptr == manualSegmentationTool)
{
continue;
}
manualSegmentationTool->SetShowMarkerNodes(state);
}
}
void QmitkSegmentationView::OnCurrentLabelSelectionChanged(QmitkMultiLabelManager::LabelValueVectorType labels)
{
auto segmentation = this->GetCurrentSegmentation();
const auto labelValue = labels.front();
if (nullptr == segmentation->GetActiveLabel() || labelValue != segmentation->GetActiveLabel()->GetValue())
{
segmentation->SetActiveLabel(labelValue);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
m_Controls->slicesInterpolator->SetActiveLabelValue(labelValue);
}
void QmitkSegmentationView::OnGoToLabel(mitk::LabelSetImage::LabelValueType /*label*/, const mitk::Point3D& pos)
{
if (m_RenderWindowPart)
{
m_RenderWindowPart->SetSelectedPosition(pos);
}
}
-void QmitkSegmentationView::OnLabelRenameRequested(mitk::Label* label, bool rename) const
+void QmitkSegmentationView::OnLabelRenameRequested(mitk::Label* label, bool rename, bool& canceled) const
{
auto segmentation = this->GetCurrentSegmentation();
if (rename)
{
- QmitkNewSegmentationDialog::DoRenameLabel(label, segmentation, this->m_Parent, QmitkNewSegmentationDialog::Mode::RenameLabel);
+ canceled = !QmitkNewSegmentationDialog::DoRenameLabel(label, segmentation, this->m_Parent, QmitkNewSegmentationDialog::Mode::RenameLabel);
return;
}
- QmitkNewSegmentationDialog::DoRenameLabel(label, nullptr, this->m_Parent, QmitkNewSegmentationDialog::Mode::NewLabel);
+ canceled = !QmitkNewSegmentationDialog::DoRenameLabel(label, nullptr, this->m_Parent, QmitkNewSegmentationDialog::Mode::NewLabel);
}
mitk::LabelSetImage* QmitkSegmentationView::GetCurrentSegmentation() const
{
auto workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
if (workingNode.IsNull()) mitkThrow() << "Segmentation view is in an invalid state. Working node is null, but a label selection change has been triggered.";
auto segmentation = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == segmentation) mitkThrow() << "Segmentation view is in an invalid state. Working node contains no segmentation, but a label selection change has been triggered.";
return segmentation;
}
/**********************************************************************/
/* private */
/**********************************************************************/
void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
{
m_Parent = parent;
m_Controls = new Ui::QmitkSegmentationViewControls;
m_Controls->setupUi(parent);
// *------------------------
// * SHORTCUTS
// *------------------------
QShortcut* visibilityShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_H), parent);
connect(visibilityShortcut, &QShortcut::activated, this, &Self::OnVisibilityShortcutActivated);
QShortcut* labelToggleShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_N), parent);
connect(labelToggleShortcut, &QShortcut::activated, this, &Self::OnLabelToggleShortcutActivated);
// *------------------------
// * DATA SELECTION WIDGETS
// *------------------------
m_Controls->referenceNodeSelector->SetDataStorage(GetDataStorage());
m_Controls->referenceNodeSelector->SetNodePredicate(m_ReferencePredicate);
m_Controls->referenceNodeSelector->SetInvalidInfo("Select an image");
m_Controls->referenceNodeSelector->SetPopUpTitel("Select an image");
m_Controls->referenceNodeSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
m_Controls->workingNodeSelector->SetDataStorage(GetDataStorage());
m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
m_Controls->workingNodeSelector->SetInvalidInfo("Select a segmentation");
m_Controls->workingNodeSelector->SetPopUpTitel("Select a segmentation");
m_Controls->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->referenceNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &Self::OnReferenceSelectionChanged);
connect(m_Controls->workingNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &Self::OnSegmentationSelectionChanged);
// *------------------------
// * TOOLMANAGER
// *------------------------
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
m_ToolManager->InitializeTools();
QString segTools2D = tr("Add Subtract Lasso Fill Erase Close Paint Wipe 'Region Growing' 'Live Wire' 'Segment Anything', 'MedSAM'");
QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Region Growing 3D' Picking GrowCut TotalSegmentator");
#ifdef __linux__
segTools3D.append(" nnUNet"); // plugin not enabled for MacOS / Windows
#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()));
}
}
// setup 2D tools
m_Controls->toolSelectionBox2D->SetToolManager(*m_ToolManager);
m_Controls->toolSelectionBox2D->SetGenerateAccelerators(true);
m_Controls->toolSelectionBox2D->SetToolGUIArea(m_Controls->toolGUIArea2D);
m_Controls->toolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
connect(m_Controls->toolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected,
this, &Self::OnManualTool2DSelected);
// setup 3D Tools
m_Controls->toolSelectionBox3D->SetToolManager(*m_ToolManager);
m_Controls->toolSelectionBox3D->SetGenerateAccelerators(true);
m_Controls->toolSelectionBox3D->SetToolGUIArea(m_Controls->toolGUIArea3D);
m_Controls->toolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
m_Controls->slicesInterpolator->SetDataStorage(this->GetDataStorage());
// create general signal / slot connections
connect(m_Controls->newSegmentationButton, &QToolButton::clicked, this, &Self::OnNewSegmentation);
connect(m_Controls->slicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &Self::OnShowMarkerNodes);
connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::CurrentSelectionChanged, this, &Self::OnCurrentLabelSelectionChanged);
connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::GoToLabel, this, &Self::OnGoToLabel);
connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::LabelRenameRequested, this, &Self::OnLabelRenameRequested);
auto command = itk::SimpleMemberCommand<Self>::New();
command->SetCallbackFunction(this, &Self::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->referenceNodeSelector->SetAutoSelectNewNodes(true);
m_Controls->workingNodeSelector->SetAutoSelectNewNodes(true);
this->UpdateGUI();
}
void QmitkSegmentationView::ActiveToolChanged()
{
if (nullptr == m_RenderWindowPart)
{
return;
}
mitk::TimeGeometry* interactionReferenceGeometry = nullptr;
auto activeTool = m_ToolManager->GetActiveTool();
if (nullptr != activeTool && m_ReferenceNode.IsNotNull())
{
mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image *>(m_ReferenceNode->GetData());
if (referenceImage.IsNotNull())
{
// tool activated, reference image available: set reference geometry
interactionReferenceGeometry = m_ReferenceNode->GetData()->GetTimeGeometry();
}
}
// set the interaction reference geometry for the render window part (might be nullptr)
m_RenderWindowPart->SetInteractionReferenceGeometry(interactionReferenceGeometry);
}
void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
if (m_RenderWindowPart != renderWindowPart)
{
m_RenderWindowPart = renderWindowPart;
}
if (nullptr != m_Parent)
{
m_Parent->setEnabled(true);
}
if (nullptr == m_Controls)
{
return;
}
if (nullptr != m_RenderWindowPart)
{
auto all2DWindows = Get2DWindows(m_RenderWindowPart->GetQmitkRenderWindows().values());
m_Controls->slicesInterpolator->Initialize(m_ToolManager, all2DWindows);
if (!m_RenderWindowPart->HasCoupledRenderWindows())
{
// react if the active tool changed, only if a render window part with decoupled render windows is used
m_ToolManager->ActiveToolChanged +=
mitk::MessageDelegate<Self>(this, &Self::ActiveToolChanged);
}
}
}
void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
m_RenderWindowPart = nullptr;
if (nullptr != m_Parent)
{
m_Parent->setEnabled(false);
}
// remove message-connection to make sure no message is processed if no render window part is available
m_ToolManager->ActiveToolChanged -=
mitk::MessageDelegate<Self>(this, &Self::ActiveToolChanged);
m_Controls->slicesInterpolator->Uninitialize();
}
void QmitkSegmentationView::RenderWindowPartInputChanged(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
if (nullptr == m_RenderWindowPart)
{
return;
}
m_Controls->slicesInterpolator->Uninitialize();
auto all2DWindows = Get2DWindows(m_RenderWindowPart->GetQmitkRenderWindows().values());
m_Controls->slicesInterpolator->Initialize(m_ToolManager, all2DWindows);
}
void QmitkSegmentationView::OnPreferencesChanged(const mitk::IPreferences* prefs)
{
auto labelSuggestions = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), "");
m_DefaultLabelNaming = labelSuggestions.empty()
? prefs->GetBool("default label naming", true)
: false; // No default label naming when label suggestions are enforced via command-line argument
if (nullptr != m_Controls)
{
m_Controls->multiLabelWidget->SetDefaultLabelNaming(m_DefaultLabelNaming);
bool compactView = prefs->GetBool("compact view", false);
int numberOfColumns = compactView ? 6 : 4;
m_Controls->toolSelectionBox2D->SetLayoutColumns(numberOfColumns);
m_Controls->toolSelectionBox2D->SetShowNames(!compactView);
m_Controls->toolSelectionBox3D->SetLayoutColumns(numberOfColumns);
m_Controls->toolSelectionBox3D->SetShowNames(!compactView);
}
m_DrawOutline = prefs->GetBool("draw outline", true);
m_SelectionMode = prefs->GetBool("selection mode", false);
m_LabelSetPresetPreference = QString::fromStdString(prefs->Get("label set preset", ""));
this->ApplyDisplayOptions();
this->ApplySelectionMode();
}
void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
{
if (m_SegmentationPredicate->CheckNode(node))
this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
this->ApplySelectionMode();
}
void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
{
if (!m_SegmentationPredicate->CheckNode(node))
{
return;
}
// 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;
auto image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
}
void QmitkSegmentationView::ApplyDisplayOptions()
{
if (nullptr == m_Parent)
{
return;
}
if (nullptr == m_Controls)
{
return; // might happen on initialization (preferences loaded)
}
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 labelSetImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
if (nullptr == labelSetImage)
{
return;
}
// the outline property can be set in the segmentation preference page
node->SetProperty("labelset.contour.active", mitk::BoolProperty::New(m_DrawOutline));
// force render window update to show outline
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSegmentationView::ApplySelectionMode()
{
if (!m_SelectionMode)
return;
this->ApplySelectionModeOnReferenceNode();
this->ApplySelectionModeOnWorkingNode();
}
void QmitkSegmentationView::ApplySelectionModeOnReferenceNode()
{
this->ApplySelectionMode(m_ReferenceNode, m_ReferencePredicate);
}
void QmitkSegmentationView::ApplySelectionModeOnWorkingNode()
{
this->ApplySelectionMode(m_WorkingNode, m_SegmentationPredicate);
}
void QmitkSegmentationView::ApplySelectionMode(mitk::DataNode* node, mitk::NodePredicateBase* predicate)
{
if (!m_SelectionMode || node == nullptr || predicate == nullptr)
return;
auto nodes = this->GetDataStorage()->GetSubset(predicate);
for (auto iter = nodes->begin(); iter != nodes->end(); ++iter)
(*iter)->SetVisibility(*iter == node);
}
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* threeDRenderWindow = 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,
threeDRenderWindow->GetRenderer()))
{
selectedRenderWindow = threeDRenderWindow;
}
// make node visible
if (nullptr != 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>();
mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(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<mitk::DataNode::Pointer>& nodes)
{
if (0 == nodes.size())
{
return;
}
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->newSegmentationButton->setEnabled(false);
if (hasReferenceNode)
{
m_Controls->newSegmentationButton->setEnabled(true);
}
if (hasWorkingNode && hasReferenceNode)
{
int layer = -1;
referenceNode->GetIntProperty("layer", layer);
workingNode->SetIntProperty("layer", layer + 1);
}
this->ValidateSelectionInput();
}
void QmitkSegmentationView::ValidateSelectionInput()
{
auto referenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
auto workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
bool hasReferenceNode = referenceNode.IsNotNull();
bool hasWorkingNode = workingNode.IsNotNull();
bool hasBothNodes = hasReferenceNode && hasWorkingNode;
QString warning;
bool toolSelectionBoxesEnabled = hasReferenceNode && hasWorkingNode;
unsigned int numberOfLabels = 0;
m_Controls->multiLabelWidget->setEnabled(hasWorkingNode);
m_Controls->toolSelectionBox2D->setEnabled(hasBothNodes);
m_Controls->toolSelectionBox3D->setEnabled(hasBothNodes);
m_Controls->slicesInterpolator->setEnabled(false);
m_Controls->interpolatorWarningLabel->hide();
if (hasReferenceNode)
{
if (nullptr != m_RenderWindowPart && m_RenderWindowPart->HasCoupledRenderWindows() && !referenceNode->IsVisible(nullptr))
{
warning += tr("The selected reference image is currently not visible!");
toolSelectionBoxesEnabled = false;
}
}
if (hasWorkingNode)
{
if (nullptr != m_RenderWindowPart && m_RenderWindowPart->HasCoupledRenderWindows() && !workingNode->IsVisible(nullptr))
{
warning += (!warning.isEmpty() ? "<br>" : "") + tr("The selected segmentation is currently not visible!");
toolSelectionBoxesEnabled = false;
}
m_ToolManager->SetReferenceData(referenceNode);
m_ToolManager->SetWorkingData(workingNode);
m_Controls->multiLabelWidget->setEnabled(true);
m_Controls->toolSelectionBox2D->setEnabled(true);
m_Controls->toolSelectionBox3D->setEnabled(true);
auto labelSetImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
numberOfLabels = labelSetImage->GetTotalNumberOfLabels();
if (numberOfLabels > 0)
m_Controls->slicesInterpolator->setEnabled(true);
m_Controls->multiLabelWidget->SetMultiLabelNode(workingNode);
if (!m_Controls->multiLabelWidget->GetSelectedLabels().empty())
{
m_Controls->slicesInterpolator->SetActiveLabelValue(m_Controls->multiLabelWidget->GetSelectedLabels().front());
}
}
else
{
m_Controls->multiLabelWidget->SetMultiLabelNode(nullptr);
}
toolSelectionBoxesEnabled &= numberOfLabels > 0;
// Here we need to check whether the geometry of the selected segmentation image (working image geometry)
// is aligned with the geometry of the 3D render window.
// It is not allowed to use a geometry different from the working image geometry for segmenting.
// We only need to this if the tool selection box would be enabled without this check.
// Additionally this check only has to be performed for render window parts with coupled render windows.
// For different render window parts the user is given the option to reinitialize each render window individually
// (see QmitkRenderWindow::ShowOverlayMessage).
if (toolSelectionBoxesEnabled && nullptr != m_RenderWindowPart && m_RenderWindowPart->HasCoupledRenderWindows())
{
const mitk::BaseGeometry* workingNodeGeometry = workingNode->GetData()->GetGeometry();
const mitk::BaseGeometry* renderWindowGeometry =
m_RenderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
if (nullptr != workingNodeGeometry && nullptr != renderWindowGeometry)
{
if (!mitk::Equal(*workingNodeGeometry->GetBoundingBox(), *renderWindowGeometry->GetBoundingBox(), mitk::eps, true))
{
warning += (!warning.isEmpty() ? "<br>" : "") + tr("Please reinitialize the selected segmentation image!");
toolSelectionBoxesEnabled = false;
}
}
}
m_Controls->toolSelectionBox2D->setEnabled(toolSelectionBoxesEnabled);
m_Controls->toolSelectionBox3D->setEnabled(toolSelectionBoxesEnabled);
this->UpdateWarningLabel(warning);
m_ToolManager->SetReferenceData(referenceNode);
m_ToolManager->SetWorkingData(workingNode);
}
void QmitkSegmentationView::UpdateWarningLabel(QString text)
{
if (text.isEmpty())
{
m_Controls->selectionWarningLabel->hide();
}
else
{
m_Controls->selectionWarningLabel->setText("<font color=\"red\">" + text + "</font>");
m_Controls->selectionWarningLabel->show();
}
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
index 1144bf3f21..b0abd74aa1 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
@@ -1,180 +1,180 @@
/*============================================================================
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.
============================================================================*/
#ifndef QmitkSegmentationView_h
#define QmitkSegmentationView_h
#include "ui_QmitkSegmentationViewControls.h"
#include <QmitkAbstractView.h>
#include <mitkITKEventObserverGuard.h>
#include <mitkIRenderWindowPartListener.h>
/**
* @brief The segmentation view provides a set of tool to use different segmentation algorithms.
* It provides two selection widgets to load an image node and a segmentation node
* on which to perform the segmentation. Creating new segmentation nodes is also possible.
* The available segmentation tools are grouped into "2D"- and "3D"-tools.
*
* Most segmentation tools / algorithms need some kind of user interaction, where the
* user is asked to draw something in the image display or set some seed points / start values.
* The tools also often provide additional properties so that a user can modify the
* algorithm's behavior.
*
* This class additionally provides options to work with different layers (create new layers,
* switch between layers).
* Moreover, a multilabel widget displays all the existing labels of a multilabel segmentation
* for the currently active layer.
* The multilabel widget allows to control the labels by creating new ones, removing existing ones,
* showing / hiding single labels, merging labels, (re-)naming them etc.
*
* Additionally the view provides an option to create "2D"- and "3D"-interpolations between
* neighboring segmentation masks on unsegmented slices.
* Interpolation for multilabel segmentations is currently not implemented.
*/
class QmitkSegmentationView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
{
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkSegmentationView();
~QmitkSegmentationView() override;
private Q_SLOTS:
// reaction to the selection of a new reference image in the selection widget
void OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
// reaction to the selection of a new segmentation image in the selection widget
void OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
// reaction to the shortcut ("CTRL+H") for toggling the visibility of the working node
void OnVisibilityShortcutActivated();
// reaction to the shortcut ("CTRL+L") for iterating over all labels
void OnLabelToggleShortcutActivated();
// reaction to the button "New segmentation"
void OnNewSegmentation();
void OnManualTool2DSelected(int id);
void OnShowMarkerNodes(bool);
void OnCurrentLabelSelectionChanged(QmitkMultiLabelManager::LabelValueVectorType labels);
void OnGoToLabel(mitk::LabelSetImage::LabelValueType label, const mitk::Point3D&);
- void OnLabelRenameRequested(mitk::Label* label, bool rename) const;
+ void OnLabelRenameRequested(mitk::Label* label, bool rename, bool& canceled) const;
void OnLabelAdded(mitk::LabelSetImage::LabelValueType labelValue);
void OnLabelRemoved(mitk::LabelSetImage::LabelValueType labelValue);
void OnGroupRemoved(mitk::LabelSetImage::GroupIndexType groupIndex);
private:
using Self = QmitkSegmentationView;
mitk::LabelSetImage* GetWorkingImage();
void AddObserversToWorkingImage();
void RemoveObserversFromWorkingImage();
void CreateQtPartControl(QWidget* parent) override;
void SetFocus() override {}
/**
* @brief Enable or disable the SegmentationInteractor.
*
* The active tool is retrieved from the tool manager.
* If the active tool is valid, the SegmentationInteractor is enabled
* to listen to 'SegmentationInteractionEvent's.
*/
void ActiveToolChanged();
void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
void RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderWindowPart) override;
void OnPreferencesChanged(const mitk::IPreferences* prefs) override;
void NodeAdded(const mitk::DataNode* node) override;
void NodeRemoved(const mitk::DataNode* node) override;
void OnAnySelectionChanged();
// make sure all images / segmentations look according to the user preference settings
void ApplyDisplayOptions();
// decorates a DataNode according to the user preference settings
void ApplyDisplayOptions(mitk::DataNode* node);
void ApplySelectionMode();
void ApplySelectionModeOnReferenceNode();
void ApplySelectionModeOnWorkingNode();
void ApplySelectionMode(mitk::DataNode* node, mitk::NodePredicateBase* predicate);
// If a contourmarker is selected, the plane in the related widget will be reoriented according to the marker`s geometry
void OnContourMarkerSelected(const mitk::DataNode* node);
void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes) override;
void ResetMouseCursor();
void SetMouseCursor(const us::ModuleResource&, int hotspotX, int hotspotY);
void UpdateGUI();
void ValidateSelectionInput();
void UpdateWarningLabel(QString text);
std::string GetDefaultLabelSetPreset() const;
mitk::LabelSetImage* GetCurrentSegmentation() const;
QWidget* m_Parent;
Ui::QmitkSegmentationViewControls* m_Controls;
mitk::IRenderWindowPart* m_RenderWindowPart;
mitk::ToolManager* m_ToolManager;
mitk::DataNode::Pointer m_ReferenceNode;
mitk::DataNode::Pointer m_WorkingNode;
typedef std::map<mitk::DataNode*, unsigned long> NodeTagMapType;
NodeTagMapType m_WorkingDataObserverTags;
NodeTagMapType m_ReferenceDataObserverTags;
unsigned int m_RenderingManagerObserverTag;
mitk::NodePredicateBase::Pointer m_ReferencePredicate;
mitk::NodePredicateBase::Pointer m_SegmentationPredicate;
bool m_DrawOutline;
bool m_SelectionMode;
bool m_MouseCursorSet;
QString m_LabelSetPresetPreference;
bool m_DefaultLabelNaming;
bool m_SelectionChangeIsAlreadyBeingHandled;
mitk::ITKEventObserverGuard m_LabelAddedObserver;
mitk::ITKEventObserverGuard m_LabelRemovedObserver;
mitk::ITKEventObserverGuard m_GroupRemovedObserver;
};
#endif