diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
index 90493c7ea0..607a381607 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
@@ -1,457 +1,457 @@
/*============================================================================
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 <mitkRenderingManager.h>
#include <mitkShowSegmentationAsSurface.h>
#include <mitkStatusBar.h>
#include <mitkToolManagerProvider.h>
// Qmitk
#include <QmitkStyleManager.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_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->labelInspector, &QmitkMultiLabelInspector::CurrentSelectionChanged, this, &QmitkMultiLabelManager::UpdateControls);
connect(m_Controls->labelSearchBox, SIGNAL(returnPressed()), this, SLOT(OnSearchLabel()));
QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
completeModel->setStringList(GetLabelStringList());
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")));
connect(m_Controls->btnAddLabel, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabel);
connect(m_Controls->btnAddInstance, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabelInstance);
connect(m_Controls->btnRemoveLabel, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::RemoveLabel);
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->btnSavePreset, &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::CurrentSelectionChanged);
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* newLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_N), this);
connect(newLabelShortcut, &QShortcut::activated, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabel);
this->UpdateControls();
}
QmitkMultiLabelManager::~QmitkMultiLabelManager()
{
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->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
+ auto currentLabel = this->m_Segmentation->GetLabel(labelValue);
emit LabelRenameRequested(currentLabel, true);
}
}
void QmitkMultiLabelManager::OnSelectedLabelChanged(LabelValueVectorType labels)
{
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)
{
if (segmentation != this->m_Segmentation.GetPointer())
{
m_Segmentation = segmentation;
this->m_Controls->labelInspector->SetMultiLabelSegmentation(segmentation);
UpdateControls();
}
}
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 = m_Segmentation.IsNotNull();
auto labels = this->m_Controls->labelInspector->GetSelectedLabels();
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() && m_Segmentation->GetNumberOfLayers()>1);
m_Controls->btnRemoveLabel->setEnabled(hasWorkingData && !labels.empty());
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->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
auto pixelValue = currentLabel->GetValue();
try
{
this->WaitCursorOn();
mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
cropFilter->SetInput(this->m_Segmentation->CreateLabelMask(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->m_SegmentationNode);
}
void QmitkMultiLabelManager::OnCreateMask(bool /*triggered*/)
{
mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
auto currentLabel = this->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
auto pixelValue = currentLabel->GetValue();
mitk::Image::Pointer maskImage;
try
{
this->WaitCursorOn();
maskImage = m_Segmentation->CreateLabelMask(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, m_SegmentationNode);
}
void QmitkMultiLabelManager::OnCreateSmoothedSurface(bool /*triggered*/)
{
mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
auto currentLabel = this->m_Segmentation->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 = m_SegmentationNode;
surfaceFilter->SetPointerParameter("Group node", groupNode);
surfaceFilter->SetPointerParameter("Input", m_Segmentation);
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->m_Segmentation->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 = m_SegmentationNode;
surfaceFilter->SetPointerParameter("Group node", groupNode);
surfaceFilter->SetPointerParameter("Input", m_Segmentation);
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()
{
}
void QmitkMultiLabelManager::OnLoadPreset()
{
}
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
{
emit LabelRenameRequested(label, rename);
}
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();
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
index 97d0ab5822..936a58c8fd 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
@@ -1,924 +1,923 @@
/*============================================================================
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 "QmitkMultiLabelTreeModel.h"
#include "mitkRenderingManager.h"
#include "QmitkStyleManager.h"
class QmitkMultiLabelSegTreeItem
{
public:
enum class ItemType
{
Group,
Label,
Instance
};
QmitkMultiLabelSegTreeItem()
{
};
explicit QmitkMultiLabelSegTreeItem(ItemType type, QmitkMultiLabelSegTreeItem* parentItem,
- mitk::Label* label = nullptr, std::string className = ""): m_ItemType(type), m_Label(label), m_parentItem(parentItem), m_ClassName(className)
+ mitk::Label* label = nullptr, std::string className = ""): m_parentItem(parentItem), m_ItemType(type), m_Label(label), m_ClassName(className)
{
};
~QmitkMultiLabelSegTreeItem()
{
for (auto item : m_childItems)
{
delete item;
}
};
void AppendChild(QmitkMultiLabelSegTreeItem* child)
{
m_childItems.push_back(child);
};
void RemoveChild(std::size_t row)
{
if (row < m_childItems.size())
{
delete m_childItems[row];
m_childItems.erase(m_childItems.begin() + row);
}
};
int Row() const
{
if (m_parentItem)
{
auto finding = std::find(m_parentItem->m_childItems.begin(), m_parentItem->m_childItems.end(), this);
if (finding != m_parentItem->m_childItems.end())
{
return std::distance(m_parentItem->m_childItems.begin(), finding);
}
}
return 0;
};
QmitkMultiLabelSegTreeItem* ParentItem()
{
return m_parentItem;
};
const QmitkMultiLabelSegTreeItem* ParentItem() const
{
return m_parentItem;
};
const QmitkMultiLabelSegTreeItem* NextSibblingItem() const
{
if (m_parentItem)
{
- const auto row = this->Row()+1;
- if (row < m_parentItem->m_childItems.size())
+ const std::vector<QmitkMultiLabelSegTreeItem*>::size_type row = this->Row();
+ if (row + 1 < m_parentItem->m_childItems.size())
return m_parentItem->m_childItems[row];
}
return nullptr;
};
const QmitkMultiLabelSegTreeItem* PrevSibblingItem() const
{
if (m_parentItem)
{
- const auto row = this->Row();
+ const std::vector<QmitkMultiLabelSegTreeItem*>::size_type row = this->Row();
if (row > 0)
+
return m_parentItem->m_childItems[row-1];
}
return nullptr;
};
const QmitkMultiLabelSegTreeItem* RootItem() const
{
auto item = this;
while (item->m_parentItem != nullptr)
{
item = item->m_parentItem;
}
return item;
};
std::size_t GetGroupID() const
{
auto root = this->RootItem();
auto item = this;
if (root == this) return 0;
while (root != item->m_parentItem)
{
item = item->m_parentItem;
}
auto iter = std::find(root->m_childItems.begin(), root->m_childItems.end(), item);
if (root->m_childItems.end() == iter) mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Root does not have an currentItem as child that has root as parent.";
return std::distance(root->m_childItems.begin(), iter);
}
bool HandleAsInstance() const
{
return (ItemType::Instance == m_ItemType) || ((ItemType::Label == m_ItemType) && (m_childItems.size() == 1));
}
mitk::Label* GetLabel() const
{
if (ItemType::Instance == m_ItemType)
{
return m_Label;
}
if (ItemType::Label == m_ItemType)
{
if (m_childItems.empty()) mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Internal label currentItem has no instance currentItem.";
return m_childItems[0]->GetLabel();
}
return nullptr;
};
mitk::LabelSetImage::LabelValueType GetLabelValue() const
{
auto label = this->GetLabel();
if (nullptr == label)
{
mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Called GetLabelValue on an group currentItem.";
}
return label->GetValue();
};
- QmitkMultiLabelSegTreeItem* m_parentItem = nullptr;
std::vector<QmitkMultiLabelSegTreeItem*> m_childItems;
+ QmitkMultiLabelSegTreeItem* m_parentItem = nullptr;
ItemType m_ItemType = ItemType::Group;
mitk::Label::Pointer m_Label;
std::string m_ClassName;
};
QModelIndex GetIndexByItem(const QmitkMultiLabelSegTreeItem* start, const QmitkMultiLabelTreeModel* model)
{
QModelIndex parentIndex = QModelIndex();
if (nullptr != start->m_parentItem)
{
parentIndex = GetIndexByItem(start->m_parentItem, model);
}
else
{
return parentIndex;
}
return model->index(start->Row(), 0, parentIndex);
}
QmitkMultiLabelSegTreeItem* GetGroupItem(QmitkMultiLabelTreeModel::SpatialGroupIndexType groupIndex, QmitkMultiLabelSegTreeItem* root)
{
if (nullptr != root && groupIndex < root->m_childItems.size())
{
return root->m_childItems[groupIndex];
}
return nullptr;
}
QmitkMultiLabelSegTreeItem* GetInstanceItem(QmitkMultiLabelTreeModel::LabelValueType labelValue, QmitkMultiLabelSegTreeItem* root)
{
QmitkMultiLabelSegTreeItem* result = nullptr;
for (auto item : root->m_childItems)
{
result = GetInstanceItem(labelValue, item);
if (nullptr != result) return result;
}
if (root->m_ItemType == QmitkMultiLabelSegTreeItem::ItemType::Instance && root->GetLabelValue() == labelValue)
{
return root;
}
return nullptr;
}
const QmitkMultiLabelSegTreeItem* GetFirstInstanceLikeItem(const QmitkMultiLabelSegTreeItem* startItem)
{
const QmitkMultiLabelSegTreeItem* result = nullptr;
if (nullptr != startItem)
{
if (startItem->HandleAsInstance())
{
result = startItem;
}
else if (!startItem->m_childItems.empty())
{
result = GetFirstInstanceLikeItem(startItem->m_childItems.front());
}
}
return result;
}
QmitkMultiLabelSegTreeItem* GetLabelItemInGroup(const std::string& labelName, QmitkMultiLabelSegTreeItem* group)
{
if (nullptr != group)
{
auto predicate = [labelName](const QmitkMultiLabelSegTreeItem* item) { return labelName == item->m_ClassName; };
auto finding = std::find_if(group->m_childItems.begin(), group->m_childItems.end(), predicate);
if (group->m_childItems.end() != finding)
{
return *finding;
}
}
return nullptr;
}
QmitkMultiLabelTreeModel::QmitkMultiLabelTreeModel(QObject *parent) : QAbstractItemModel(parent)
, m_Observed(false)
{
m_RootItem = std::make_unique<QmitkMultiLabelSegTreeItem>();
}
QmitkMultiLabelTreeModel ::~QmitkMultiLabelTreeModel()
{
this->SetSegmentation(nullptr);
};
int QmitkMultiLabelTreeModel::columnCount(const QModelIndex& /*parent*/) const
{
return 4;
}
int QmitkMultiLabelTreeModel::rowCount(const QModelIndex &parent) const
{
if (parent.column() > 0)
return 0;
if (m_Segmentation.IsNull())
return 0;
QmitkMultiLabelSegTreeItem* parentItem = m_RootItem.get();
if (parent.isValid())
parentItem = static_cast<QmitkMultiLabelSegTreeItem *>(parent.internalPointer());
if (parentItem->HandleAsInstance())
{
return 0;
}
return parentItem->m_childItems.size();
}
QVariant QmitkMultiLabelTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
if (!item)
return QVariant();
if (role == Qt::DisplayRole||role == Qt::EditRole)
{
if (TableColumns::NAME_COL == index.column())
{
switch (item->m_ItemType)
{
case QmitkMultiLabelSegTreeItem::ItemType::Group:
return QVariant(QString("Group ")+QString::number(item->GetGroupID()));
case QmitkMultiLabelSegTreeItem::ItemType::Label:
{
auto label = item->GetLabel();
if (nullptr == label) mitkThrow() << "Invalid internal state. QmitkMultiLabelTreeModel currentItem is refering to a label that does not exist.";
return QVariant(QString::fromStdString(label->GetName()));
}
case QmitkMultiLabelSegTreeItem::ItemType::Instance:
return QVariant(QString("Instance #") + QString::number(item->GetLabelValue()));
}
}
else
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
if (TableColumns::LOCKED_COL == index.column())
{
return QVariant(label->GetLocked());
}
else if (TableColumns::COLOR_COL == index.column())
{
return QVariant(QColor(label->GetColor().GetRed() * 255, label->GetColor().GetGreen() * 255, label->GetColor().GetBlue() * 255));
}
else if (TableColumns::VISIBLE_COL == index.column())
{
return QVariant(label->GetVisible());
}
}
else
{
}
}
}
else if (role == ItemModelRole::LabelDataRole)
{
auto label = item->GetLabel();
if (nullptr!=label) return QVariant::fromValue<void*>(label);
}
else if (role == ItemModelRole::LabelValueRole)
{
auto label = item->GetLabel();
if (nullptr != label) return QVariant(label->GetValue());
}
else if (role == ItemModelRole::LabelInstanceDataRole)
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
return QVariant::fromValue<void*>(label);
}
}
else if (role == ItemModelRole::LabelInstanceValueRole)
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
return QVariant(label->GetValue());
}
}
return QVariant();
}
mitk::Color QtToMitk(const QColor& color)
{
mitk::Color mitkColor;
mitkColor.SetRed(color.red() / 255.0f);
mitkColor.SetGreen(color.green() / 255.0f);
mitkColor.SetBlue(color.blue() / 255.0f);
return mitkColor;
}
bool QmitkMultiLabelTreeModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (!index.isValid())
return false;
auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
if (!item)
return false;
if (role == Qt::EditRole)
{
if (TableColumns::NAME_COL != index.column())
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
if (TableColumns::LOCKED_COL == index.column())
{
label->SetLocked(value.toBool());
}
else if (TableColumns::COLOR_COL == index.column())
{
label->SetColor(QtToMitk(value.value<QColor>()));
}
else if (TableColumns::VISIBLE_COL == index.column())
{
label->SetVisible(value.toBool());
}
auto groupID = m_Segmentation->GetGroupIndexOfLabel(label->GetValue());
m_Segmentation->GetLabelSet(groupID)->UpdateLookupTable(label->GetValue());
m_Segmentation->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
}
return true;
}
}
return false;
}
QModelIndex QmitkMultiLabelTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent))
return QModelIndex();
auto parentItem = m_RootItem.get();
if (parent.isValid())
parentItem = static_cast<QmitkMultiLabelSegTreeItem *>(parent.internalPointer());
QmitkMultiLabelSegTreeItem *childItem = parentItem->m_childItems[row];
if (childItem)
return createIndex(row, column, childItem);
else
return QModelIndex();
}
QModelIndex QmitkMultiLabelTreeModel::indexOfLabel(mitk::Label::PixelType labelValue) const
{
if (labelValue == mitk::LabelSetImage::UnlabeledLabelValue) return QModelIndex();
auto relevantItem = GetInstanceItem(labelValue, this->m_RootItem.get());
if (nullptr == relevantItem) QModelIndex();
auto labelItem = relevantItem->ParentItem();
if (labelItem->m_childItems.size() == 1)
{ //was the only instance of the label, therefor return the label item instat.
relevantItem = labelItem;
}
return GetIndexByItem(relevantItem, this);
}
QModelIndex QmitkMultiLabelTreeModel::indexOfGroup(mitk::LabelSetImage::SpatialGroupIndexType groupIndex) const
{
auto relevantItem = GetGroupItem(groupIndex, this->m_RootItem.get());
if (nullptr == relevantItem) QModelIndex();
return GetIndexByItem(relevantItem, this);
}
QModelIndex QmitkMultiLabelTreeModel::parent(const QModelIndex &child) const
{
if (!child.isValid())
return QModelIndex();
QmitkMultiLabelSegTreeItem *childItem = static_cast<QmitkMultiLabelSegTreeItem *>(child.internalPointer());
QmitkMultiLabelSegTreeItem *parentItem = childItem->ParentItem();
if (parentItem == m_RootItem.get())
return QModelIndex();
return createIndex(parentItem->Row(), 0, parentItem);
}
QModelIndex QmitkMultiLabelTreeModel::ClosestLabelInstanceIndex(const QModelIndex& currentIndex) const
{
if (!currentIndex.isValid()) return QModelIndex();
auto currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
if (!currentItem) return QModelIndex();
if (currentItem->RootItem() != this->m_RootItem.get()) mitkThrow() << "Invalid call. Passed currentIndex does not seem to be a valid index of this model. It is either outdated or from another model.";
const QmitkMultiLabelSegTreeItem* resultItem = nullptr;
auto searchItem = currentItem;
const auto rootItem = currentItem->RootItem();
while (searchItem != rootItem)
{
resultItem = GetFirstInstanceLikeItem(searchItem->NextSibblingItem());
if (nullptr != resultItem) break;
//no next closest label instance on this level -> check for closest before
resultItem = GetFirstInstanceLikeItem(searchItem->PrevSibblingItem());
if (nullptr != resultItem) break;
//no closest label instance before current on this level -> moeve one level up
searchItem = searchItem->ParentItem();
}
if (nullptr == resultItem)
return QModelIndex();
return GetIndexByItem(resultItem, this);
}
QModelIndex QmitkMultiLabelTreeModel::FirstLabelInstanceIndex(const QModelIndex& currentIndex) const
{
const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
if (!currentIndex.isValid())
{
currentItem = this->m_RootItem.get();
}
else
{
currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
}
if (!currentItem) return QModelIndex();
if (currentItem->RootItem() != this->m_RootItem.get()) mitkThrow() << "Invalid call. Passed currentIndex does not seem to be a valid index of this model. It is either outdated or from another model.";
const QmitkMultiLabelSegTreeItem* resultItem = nullptr;
resultItem = GetFirstInstanceLikeItem(currentItem);
if (nullptr == resultItem)
return QModelIndex();
return GetIndexByItem(resultItem, this);
}
///** Returns the index to the next node in the tree that behaves like an instance (label node with only one instance
//or instance node). If current index is at the end, an invalid index is returned.*/
//QModelIndex QmitkMultiLabelTreeModel::PrevLabelInstanceIndex(const QModelIndex& currentIndex) const;
Qt::ItemFlags QmitkMultiLabelTreeModel::flags(const QModelIndex &index) const
{
if (!index.isValid())
return Qt::NoItemFlags;
if (!index.isValid())
return Qt::NoItemFlags;
auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
if (!item)
return Qt::NoItemFlags;
if (TableColumns::NAME_COL != index.column())
{
if (item->HandleAsInstance() &&
((TableColumns::VISIBLE_COL == index.column() && m_AllowVisibilityModification) ||
(TableColumns::COLOR_COL == index.column() && m_AllowVisibilityModification) || //m_AllowVisibilityModification controls visibility and color
(TableColumns::LOCKED_COL == index.column() && m_AllowLockModification)))
{
return Qt::ItemIsEnabled | Qt::ItemIsEditable;
}
else
{
return Qt::ItemIsEnabled;
}
- return true;
}
else
{
if (item->HandleAsInstance())
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
else
{
return Qt::ItemIsEnabled;
}
- return true;
}
return Qt::NoItemFlags;
}
QVariant QmitkMultiLabelTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
{
if (TableColumns::NAME_COL == section)
{
return "Name";
}
else if (TableColumns::LOCKED_COL == section)
{
return "Locked";
}
else if (TableColumns::COLOR_COL == section)
{
return "Color";
}
else if (TableColumns::VISIBLE_COL == section)
{
return "Visibility";
}
}
return QVariant();
}
const mitk::LabelSetImage* QmitkMultiLabelTreeModel::GetSegmentation() const
{
return m_Segmentation;
}
void QmitkMultiLabelTreeModel::SetSegmentation(mitk::LabelSetImage* segmentation)
{
if (m_Segmentation != segmentation)
{
this->RemoveObserver();
this->m_Segmentation = segmentation;
this->AddObserver();
this->UpdateInternalTree();
}
}
/**Helper function that adds a labek into the item tree. Passes back the new created instance iten*/
QmitkMultiLabelSegTreeItem* AddLabelToGroupTree(mitk::Label* label, QmitkMultiLabelSegTreeItem* groupItem, bool& newLabelItemCreated)
{
if (nullptr == groupItem) return nullptr;
if (nullptr == label) return nullptr;
newLabelItemCreated = false;
std::set<std::string> labelNames;
for (auto labelItem : groupItem->m_childItems)
{
labelNames.emplace(labelItem->GetLabel()->GetName());
}
QmitkMultiLabelSegTreeItem* labelItem = nullptr;
auto finding = labelNames.find(label->GetName());
if (finding != labelNames.end())
{ //other label with same name exists
labelItem = groupItem->m_childItems[std::distance(labelNames.begin(), finding)];
}
else
{
newLabelItemCreated = true;
labelItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Label, groupItem, nullptr, label->GetName());
auto predicate = [label](const std::string& name) { return name > label->GetName(); };
auto insertFinding = std::find_if(labelNames.begin(), labelNames.end(), predicate);
groupItem->m_childItems.insert(groupItem->m_childItems.begin() + std::distance(labelNames.begin(), insertFinding), labelItem);
}
auto instanceItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Instance, labelItem, label);
auto predicate = [label](const QmitkMultiLabelSegTreeItem* item) { return item->GetLabelValue() > label->GetValue(); };
auto insertFinding = std::find_if(labelItem->m_childItems.begin(), labelItem->m_childItems.end(), predicate);
labelItem->m_childItems.insert(labelItem->m_childItems.begin() + std::distance(labelItem->m_childItems.begin(), insertFinding), instanceItem);
return instanceItem;
}
void QmitkMultiLabelTreeModel::GenerateInternalGroupTree(unsigned int groupID, QmitkMultiLabelSegTreeItem* groupItem)
{
auto labelSet = m_Segmentation->GetLabelSet(groupID);
for (auto lIter = labelSet->IteratorConstBegin(); lIter != labelSet->IteratorConstEnd(); lIter++)
{
if (lIter->first== mitk::LabelSetImage::UnlabeledLabelValue || lIter->second == m_Segmentation->GetExteriorLabel()) continue;
bool newItemCreated = false;
AddLabelToGroupTree(lIter->second, groupItem, newItemCreated);
}
}
QmitkMultiLabelSegTreeItem* QmitkMultiLabelTreeModel::GenerateInternalTree()
{
auto rootItem = new QmitkMultiLabelSegTreeItem();
if (m_Segmentation.IsNotNull())
{
for (unsigned int groupID = 0; groupID < m_Segmentation->GetNumberOfLayers(); ++groupID)
{
auto groupItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Group, rootItem);
rootItem->AppendChild(groupItem);
GenerateInternalGroupTree(groupID, groupItem);
}
}
return rootItem;
}
void QmitkMultiLabelTreeModel::UpdateInternalTree()
{
emit beginResetModel();
auto newTree = this->GenerateInternalTree();
this->m_RootItem.reset(newTree);
emit endResetModel();
emit modelChanged();
}
void QmitkMultiLabelTreeModel::AddObserver()
{
if (this->m_Segmentation.IsNotNull())
{
if (m_Observed)
{
MITK_DEBUG << "Invalid observer state in QmitkMultiLabelTreeModel. There is already a registered observer. Internal logic is not correct. May be an old observer was not removed.";
}
this->m_Segmentation->AddLabelAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelAdded));
this->m_Segmentation->AddLabelModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelModified));
this->m_Segmentation->AddLabelRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelRemoved));
this->m_Segmentation->AddGroupAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, SpatialGroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupAdded));
this->m_Segmentation->AddGroupModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, SpatialGroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupModified));
this->m_Segmentation->AddGroupRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, SpatialGroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupRemoved));
m_Observed = true;
}
}
void QmitkMultiLabelTreeModel::RemoveObserver()
{
if (this->m_Segmentation.IsNotNull())
{
this->m_Segmentation->RemoveLabelAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelAdded));
this->m_Segmentation->RemoveLabelModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelModified));
this->m_Segmentation->RemoveLabelRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelRemoved));
this->m_Segmentation->RemoveGroupAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, SpatialGroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupAdded));
this->m_Segmentation->RemoveGroupModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, SpatialGroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupModified));
this->m_Segmentation->RemoveGroupRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, SpatialGroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupRemoved));
}
m_Observed = false;
}
void QmitkMultiLabelTreeModel::OnLabelAdded(LabelValueType labelValue)
{
SpatialGroupIndexType groupIndex = 0;
if (m_Segmentation->IsLabeInGroup(labelValue, groupIndex))
{
auto label = m_Segmentation->GetLabel(labelValue);
if (nullptr == label) mitkThrow() << "Invalid internal state. Segmentation signaled the addition of an label that does not exist in the segmentation. Invalid label value:" << labelValue;
if (label == m_Segmentation->GetExteriorLabel()) return;
auto groupItem = GetGroupItem(groupIndex, this->m_RootItem.get());
bool newLabelCreated = false;
auto instanceItem = AddLabelToGroupTree(label, groupItem, newLabelCreated);
if (newLabelCreated)
{
if (groupItem->m_childItems.size() == 1)
{ //first label added
auto groupIndex = GetIndexByItem(groupItem, this);
emit dataChanged(groupIndex, groupIndex);
}
else
{ //whole new label level added to group item
auto groupIndex = GetIndexByItem(groupItem, this);
this->beginInsertRows(groupIndex, instanceItem->ParentItem()->Row(), instanceItem->ParentItem()->Row());
this->endInsertRows();
}
}
else
{
if (instanceItem->ParentItem()->m_childItems.size() < 3)
{ //second instance item was added, so label item will now able to colapse
// -> the whole label node has to be updated.
auto labelIndex = GetIndexByItem(instanceItem->ParentItem(), this);
emit dataChanged(labelIndex, labelIndex);
this->beginInsertRows(labelIndex, 0, instanceItem->ParentItem()->m_childItems.size()-1);
this->endInsertRows();
}
else
{
// instance item was added to existing label item with multiple instances
//-> just notify the row insertion
auto labelIndex = GetIndexByItem(instanceItem->ParentItem(), this);
this->beginInsertRows(labelIndex, instanceItem->Row(), instanceItem->Row());
this->endInsertRows();
}
}
}
else
{
mitkThrow() << "Group less labels are not supported in the current implementation.";
}
}
void QmitkMultiLabelTreeModel::OnLabelModified(LabelValueType labelValue)
{
if (labelValue == m_Segmentation->GetExteriorLabel()->GetValue()) return;
auto instanceItem = GetInstanceItem(labelValue, this->m_RootItem.get());
if (nullptr == instanceItem)
{
mitkThrow() << "Internal invalid state. QmitkMultiLabelTreeModel recieved a LabelModified signal for a label that is not represented in the model. Invalid label: " << labelValue;
}
auto labelItem = instanceItem->ParentItem();
if (labelItem->m_ClassName == instanceItem->GetLabel()->GetName())
{ //only the state of the label changed, but not its position in the model tree.
auto index = GetIndexByItem(labelItem, this);
emit dataChanged(index, index);
}
else
{ //the name of the label changed and thus its place in the model tree, delete the current item and add a new one
this->OnLabelRemoved(labelValue);
this->OnLabelAdded(labelValue);
}
}
void QmitkMultiLabelTreeModel::OnLabelRemoved(LabelValueType labelValue)
{
if (labelValue == m_Segmentation->GetExteriorLabel()->GetValue()) return;
auto instanceItem = GetInstanceItem(labelValue, this->m_RootItem.get());
if (nullptr == instanceItem) mitkThrow() << "Internal invalid state. QmitkMultiLabelTreeModel recieved a LabelRemoved signal for a label that is not represented in the model. Invalid label: " << labelValue;
auto labelItem = instanceItem->ParentItem();
if (labelItem->m_childItems.size() > 2)
{
auto labelIndex = GetIndexByItem(labelItem, this);
this->beginRemoveRows(labelIndex, instanceItem->Row(), instanceItem->Row());
labelItem->RemoveChild(instanceItem->Row());
this->endRemoveRows();
}
else if (labelItem->m_childItems.size() == 2)
{ //After removal only one label is left -> the whole label node is about to be changed (no instances are shown any more).
auto labelIndex = GetIndexByItem(labelItem, this);
this->beginRemoveRows(labelIndex, instanceItem->Row(), instanceItem->Row());
labelItem->RemoveChild(instanceItem->Row());
this->endRemoveRows();
emit dataChanged(labelIndex, labelIndex);
}
else
{ //was the only instance of the label, therefor also remove the label node from the tree.
auto groupItem = labelItem->ParentItem();
auto groupIndex = GetIndexByItem(groupItem, this);
this->beginRemoveRows(groupIndex, labelItem->Row(), labelItem->Row());
groupItem->RemoveChild(labelItem->Row());
this->endRemoveRows();
}
}
void QmitkMultiLabelTreeModel::OnGroupAdded(SpatialGroupIndexType groupIndex)
{
if (m_ShowGroups)
{
this->beginInsertRows(QModelIndex(), groupIndex, groupIndex);
auto rootItem = m_RootItem.get();
auto groupItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Group, rootItem);
rootItem->AppendChild(groupItem);
this->GenerateInternalGroupTree(groupIndex, groupItem);
this->endInsertRows();
}
}
-void QmitkMultiLabelTreeModel::OnGroupModified(SpatialGroupIndexType groupIndex)
+void QmitkMultiLabelTreeModel::OnGroupModified(SpatialGroupIndexType /*groupIndex*/)
{
//currently not needed
}
void QmitkMultiLabelTreeModel::OnGroupRemoved(SpatialGroupIndexType groupIndex)
{
if (m_ShowGroups)
{
this->beginRemoveRows(QModelIndex(), groupIndex, groupIndex);
auto root = m_RootItem.get();
root->RemoveChild(groupIndex);
this->endRemoveRows();
}
}
void QmitkMultiLabelTreeModel::SetAllowVisibilityModification(bool vmod)
{
m_AllowVisibilityModification = vmod;
}
bool QmitkMultiLabelTreeModel::GetAllowVisibilityModification() const
{
return m_AllowVisibilityModification;
}
void QmitkMultiLabelTreeModel::SetAllowLockModification(bool lmod)
{
m_AllowLockModification = lmod;
}
bool QmitkMultiLabelTreeModel::GetAllowLockModification() const
{
return m_AllowLockModification;
}
diff --git a/Modules/SegmentationUI/test/QmitkMultiLabelTreeModelTest.cpp b/Modules/SegmentationUI/test/QmitkMultiLabelTreeModelTest.cpp
index f7527b2d1c..dfcc145ebc 100644
--- a/Modules/SegmentationUI/test/QmitkMultiLabelTreeModelTest.cpp
+++ b/Modules/SegmentationUI/test/QmitkMultiLabelTreeModelTest.cpp
@@ -1,543 +1,543 @@
/*============================================================================
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 <QApplication>
#include <QColor>
#include "QmitkMultiLabelTreeModel.h"
#include <mitkTestFixture.h>
#include <mitkTestingMacros.h>
class QmitkMultiLabelTreeModelTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(QmitkMultiLabelTreeModelTestSuite);
MITK_TEST(NullTest);
MITK_TEST(GetterSetterTest);
MITK_TEST(AddingLabelTest);
MITK_TEST(AddingLayerTest);
MITK_TEST(RemovingLabelTest);
MITK_TEST(RemovingLayerTest);
MITK_TEST(ModifyLabelNameTest);
MITK_TEST(ModifyLabelTest);
CPPUNIT_TEST_SUITE_END();
mitk::LabelSetImage::Pointer m_Segmentation;
QCoreApplication* m_TestApp;
public:
mitk::LabelSetImage::Pointer GenerateSegmentation()
{
// Create a new labelset image
auto seg = mitk::LabelSetImage::New();
mitk::Image::Pointer regularImage = mitk::Image::New();
unsigned int dimensions[3] = { 5, 5, 5 };
regularImage->Initialize(mitk::MakeScalarPixelType<char>(), 3, dimensions);
seg->Initialize(regularImage);
return seg;
}
QColor GetQColor(const mitk::Label* label)
{
return QColor(label->GetColor().GetRed() * 255, label->GetColor().GetGreen() * 255, label->GetColor().GetBlue() * 255);
}
mitk::Label::Pointer CreateLabel(const std::string& name, mitk::Label::PixelType value)
{
auto label = mitk::Label::New();
label->SetName(name);
label->SetValue(value);
label->SetColor(mitk::Color(value / 255.));
return label;
}
/** Populate a seg with a following setup (in brackets the order of addition).
* - Group 1 (1)
* - Label A
* - Instance 1 (1)
* - Instance 5 (2)
* - Instance 10 (8)
* - Label B
* - Instance 4 (3)
* - Label D
* - Instance 2 (7)
* - Group 2 (4)
* - Group 3 (5)
* - Label B
* - Instance 9 (6)
*/
void PopulateSegmentation(mitk::LabelSetImage* seg)
{
seg->SetActiveLayer(0);
seg->GetActiveLabelSet()->AddLabel(CreateLabel("A", 1));
seg->GetActiveLabelSet()->AddLabel(CreateLabel("A", 5));
seg->GetActiveLabelSet()->AddLabel(CreateLabel("B", 4));
seg->AddLayer();
seg->AddLayer();
seg->SetActiveLayer(2);
seg->GetActiveLabelSet()->AddLabel(CreateLabel("B", 9));
seg->SetActiveLayer(0);
seg->GetActiveLabelSet()->AddLabel(CreateLabel("D", 2));
seg->GetActiveLabelSet()->AddLabel(CreateLabel("A", 10));
}
void setUp() override
{
m_Segmentation = GenerateSegmentation();
PopulateSegmentation(m_Segmentation);
int argc = 0;
char** argv = nullptr;
m_TestApp = new QCoreApplication(argc, argv);
}
void tearDown() override
{
delete m_TestApp;
}
QModelIndex GetIndex(const QmitkMultiLabelTreeModel& model, const std::vector<int>& rows, int column = 0) const
{
QModelIndex testIndex;
int i = 0;
for (auto row : rows)
{
- if (i + 1 < rows.size())
+ if (static_cast<std::vector<int>::size_type>(i) + 1 < rows.size())
{
testIndex = model.index(row, 0, testIndex);
}
else
{
testIndex = model.index(row, column, testIndex);
}
i++;
}
return testIndex;
}
- bool CheckModelItem(const QmitkMultiLabelTreeModel& model, const std::vector<int>& rows, const QVariant& reference, int column = 0, const mitk::Label* label = nullptr) const
+ bool CheckModelItem(const QmitkMultiLabelTreeModel& model, const std::vector<int>& rows, const QVariant& reference, int column, const mitk::Label* /*label = nullptr*/) const
{
QModelIndex testIndex = GetIndex(model, rows, column);
auto value = model.data(testIndex);
bool test = value == reference;
if (!test) std::cerr << std::endl <<" Model item error. Expected: '" << reference.toString().toStdString() << "'; actual: '" << value.toString().toStdString() <<"'";
return test;
}
bool CheckModelRow(const QmitkMultiLabelTreeModel& model, const std::vector<int>& rows, const std::vector<QVariant> references) const
{
int column = 0;
bool test = true;
for (const auto& ref : references)
{
test = test & CheckModelItem(model, rows, ref, column, nullptr);
column++;
}
return test;
}
void CheckModelGroup0Default(const QmitkMultiLabelTreeModel& model)
{
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,0 }, { QString("Instance #1"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,1 }, { QString("Instance #5"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,2 }, { QString("Instance #10"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
}
void CheckModelGroup1Default(const QmitkMultiLabelTreeModel& model)
{
CPPUNIT_ASSERT(CheckModelRow(model, { 1 }, { QString("Group 1"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 1 })));
}
void CheckModelGroup2Default(const QmitkMultiLabelTreeModel& model)
{
CPPUNIT_ASSERT(CheckModelRow(model, { 2 }, { QString("Group 2"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 2,0 }, { QString("B"), QVariant(true), QVariant(QColor(9,9,9)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 2,0 })));
}
void CheckModelDefault(const QmitkMultiLabelTreeModel& model)
{
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
}
void NullTest()
{
QmitkMultiLabelTreeModel model(nullptr);
CPPUNIT_ASSERT(nullptr == model.GetSegmentation());
}
void GetterSetterTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
CheckModelDefault(model);
model.SetSegmentation(nullptr);
CPPUNIT_ASSERT(nullptr == model.GetSegmentation());
CPPUNIT_ASSERT(false == model.hasChildren(QModelIndex()));
}
void AddingLabelTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
//Add label instance (not visible) to labelwith multiple instances (at the end)
m_Segmentation->SetActiveLayer(0);
auto newLabel = CreateLabel("A", 100);
newLabel->SetVisible(false);
m_Segmentation->GetActiveLabelSet()->AddLabel(newLabel);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(4, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,0 }, { QString("Instance #1"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,1 }, { QString("Instance #5"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,2 }, { QString("Instance #10"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,3 }, { QString("Instance #100"), QVariant(true), QVariant(QColor(100,100,100)), QVariant(false) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//Add label instance (not locked) to label with multiple instances (in between)
m_Segmentation->SetActiveLayer(0);
newLabel = CreateLabel("A", 7);
newLabel->SetLocked(false);
m_Segmentation->GetActiveLabelSet()->AddLabel(newLabel);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(5, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,0 }, { QString("Instance #1"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,1 }, { QString("Instance #5"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,2 }, { QString("Instance #7"), QVariant(false), QVariant(QColor(7,7,7)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,3 }, { QString("Instance #10"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,4 }, { QString("Instance #100"), QVariant(true), QVariant(QColor(100,100,100)), QVariant(false) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//reset everything
m_Segmentation = GenerateSegmentation();
PopulateSegmentation(m_Segmentation);
model.SetSegmentation(m_Segmentation);
//Add label instance to an empty group
m_Segmentation->SetActiveLayer(1);
newLabel = CreateLabel("A", 3);
m_Segmentation->GetActiveLabelSet()->AddLabel(newLabel);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 1 }, { QString("Group 1"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 1,0 }, { QString("A"), QVariant(true), QVariant(QColor(3,3,3)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 1,0 })));
CheckModelGroup2Default(model);
}
void AddingLayerTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
m_Segmentation->AddLayer();
CPPUNIT_ASSERT_EQUAL(4, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 3 }, { QString("Group 3"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 3 })));
}
void RemovingLabelTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
//remove label instance from label with multiple instances (middel)
m_Segmentation->RemoveLabel(5);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,0 }, { QString("Instance #1"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,1 }, { QString("Instance #10"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//remove label instance from label with multiple instances (first)
m_Segmentation->RemoveLabel(1);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//reset everything
m_Segmentation = GenerateSegmentation();
PopulateSegmentation(m_Segmentation);
model.SetSegmentation(m_Segmentation);
//remove label instance from label with multiple instances (at the end)
m_Segmentation->RemoveLabel(10);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,0 }, { QString("Instance #1"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,1 }, { QString("Instance #5"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//reset everything
m_Segmentation = GenerateSegmentation();
PopulateSegmentation(m_Segmentation);
model.SetSegmentation(m_Segmentation);
//remove label instance from label with only one instance
m_Segmentation->RemoveLabel(9);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CheckModelGroup1Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 2 }, { QString("Group 2"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 2 })));
}
void RemovingLayerTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
//remove group in the middle
m_Segmentation->SetActiveLayer(1);
m_Segmentation->RemoveLayer();
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 1 }, { QString("Group 1"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 1,0 }, { QString("B"), QVariant(true), QVariant(QColor(9,9,9)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 1,0 })));
//remove groups in the end
m_Segmentation->SetActiveLayer(1);
m_Segmentation->RemoveLayer();
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
//remove all groups
m_Segmentation->SetActiveLayer(0);
m_Segmentation->RemoveLayer();
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(QModelIndex()));
//reset everything
m_Segmentation = GenerateSegmentation();
PopulateSegmentation(m_Segmentation);
model.SetSegmentation(m_Segmentation);
//remove first group
m_Segmentation->SetActiveLayer(0);
m_Segmentation->RemoveLayer();
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 1 }, { QString("Group 1"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 1,0 }, { QString("B"), QVariant(true), QVariant(QColor(9,9,9)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 1,0 })));
}
void ModifyLabelNameTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
//move from multiple instance to new label in the middle
auto label = m_Segmentation->GetLabel(5,0);
label->SetName("C");
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(4, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,0 }, { QString("Instance #1"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0,1 }, { QString("Instance #10"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("C"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,3 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,3 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//move from multiple instance to new label at the end
label = m_Segmentation->GetLabel(10, 0);
label->SetName("E");
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(5, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("C"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,3 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,3 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,4 }, { QString("E"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,4 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//move last instance to new label
label = m_Segmentation->GetLabel(10, 0);
label->SetName("F");
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(5, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("C"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,3 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,3 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,4 }, { QString("F"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,4 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
//move last instance to an existing label
label->SetName("B");
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CPPUNIT_ASSERT(CheckModelRow(model, { 0 }, { QString("Group 0"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(4, model.rowCount(GetIndex(model, { 0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,0 }, { QString("A"), QVariant(true), QVariant(QColor(1,1,1)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1 }, { QString("B"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(GetIndex(model, { 0,1 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1,0 }, { QString("Instance #4"), QVariant(true), QVariant(QColor(4,4,4)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,1,1 }, { QString("Instance #10"), QVariant(true), QVariant(QColor(10,10,10)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,2 }, { QString("C"), QVariant(true), QVariant(QColor(5,5,5)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 0,3 }, { QString("D"), QVariant(true), QVariant(QColor(2,2,2)), QVariant(true) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 0,3 })));
CheckModelGroup1Default(model);
CheckModelGroup2Default(model);
}
void ModifyLabelTest()
{
QmitkMultiLabelTreeModel model(nullptr);
model.SetSegmentation(m_Segmentation);
auto label = m_Segmentation->GetLabel(9, 2);
//check single instance modifications
label->SetVisible(false);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CheckModelGroup1Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 2 }, { QString("Group 2"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 2,0 }, { QString("B"), QVariant(true), QVariant(QColor(9,9,9)), QVariant(false) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 2,0 })));
label->SetLocked(false);
label->SetColor(mitk::Color(22 / 255.));
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CheckModelGroup1Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 2 }, { QString("Group 2"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 2,0 }, { QString("B"), QVariant(false), QVariant(QColor(22,22,22)), QVariant(false) }));
CPPUNIT_ASSERT_EQUAL(0, model.rowCount(GetIndex(model, { 2,0 })));
//check instance modifications with multi instance label
m_Segmentation->SetActiveLayer(2);
m_Segmentation->GetActiveLabelSet()->AddLabel(CreateLabel("B", 33));
label->SetVisible(true);
CPPUNIT_ASSERT_EQUAL(3, model.rowCount(QModelIndex()));
CheckModelGroup0Default(model);
CheckModelGroup1Default(model);
CPPUNIT_ASSERT(CheckModelRow(model, { 2 }, { QString("Group 2"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(1, model.rowCount(GetIndex(model, { 2 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 2,0 }, { QString("B"), QVariant(), QVariant(), QVariant() }));
CPPUNIT_ASSERT_EQUAL(2, model.rowCount(GetIndex(model, { 2,0 })));
CPPUNIT_ASSERT(CheckModelRow(model, { 2,0,0 }, { QString("Instance #9"), QVariant(false), QVariant(QColor(22,22,22)), QVariant(true) }));
CPPUNIT_ASSERT(CheckModelRow(model, { 2,0,1 }, { QString("Instance #33"), QVariant(true), QVariant(QColor(33,33,33)), QVariant(true) }));
}
};
MITK_TEST_SUITE_REGISTRATION(QmitkMultiLabelTreeModel)
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 233bbd0926..17e6c9bc16 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1040 +1,1040 @@
/*============================================================================
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 <mitkLabelSetIOHelper.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>
// 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)
{
auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
auto isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
auto isDti = mitk::NodePredicateDataType::New("TensorImage");
auto isOdf = mitk::NodePredicateDataType::New("OdfImage");
auto isSegment = mitk::NodePredicateDataType::New("Segment");
auto validImages = mitk::NodePredicateOr::New();
validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
validImages->AddPredicate(isDwi);
validImages->AddPredicate(isDti);
validImages->AddPredicate(isOdf);
m_SegmentationPredicate = mitk::NodePredicateAnd::New();
m_SegmentationPredicate->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
m_ReferencePredicate = mitk::NodePredicateAnd::New();
m_ReferencePredicate->AddPredicate(validImages);
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
}
QmitkSegmentationView::~QmitkSegmentationView()
{
if (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();
// 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<QmitkSegmentationView>(this, &QmitkSegmentationView::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::NodePredicateAnd::New(
mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()),
m_SegmentationPredicate.GetPointer()));
m_SelectionChangeIsAlreadyBeingHandled = false;
this->ApplySelectionModeOnReferenceNode();
// Add visibility observer for the new reference node
auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::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;
// 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<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
m_WorkingDataObserverTags[m_WorkingNode] =
m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command);
}
}
// 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::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();
workingImage->GetActiveLabelSet()->SetNextActiveLabel();
workingImage->Modified();
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::LabelSetIOHelper::LoadLabelSetImagePreset(labelSetPreset, newLabelSetImage))
{
auto newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
if (!m_DefaultLabelNaming)
{
QmitkNewSegmentationDialog::DoRenameLabel(newLabel,nullptr,m_Parent);
}
newLabelSetImage->GetActiveLabelSet()->AddLabel(newLabel);
}
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();
const auto groupID = segmentation->GetGroupIndexOfLabel(labelValue);
if (groupID != segmentation->GetActiveLayer()) segmentation->SetActiveLayer(groupID);
if (labelValue != segmentation->GetActiveLabelSet()->GetActiveLabel()->GetValue()) segmentation->GetActiveLabelSet()->SetActiveLabel(labelValue);
segmentation->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
-void QmitkSegmentationView::OnGoToLabel(mitk::LabelSetImage::LabelValueType label, const mitk::Point3D& pos)
+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
{
auto segmentation = this->GetCurrentSegmentation();
if (rename)
{
QmitkNewSegmentationDialog::DoRenameLabel(label, segmentation, this->m_Parent, QmitkNewSegmentationDialog::Mode::RenameLabel);
}
else
{
QmitkNewSegmentationDialog::DoRenameLabel(label, segmentation, 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;
}
void QmitkSegmentationView::OnLabelSetWidgetReset()
{
this->ValidateSelectionInput();
}
/**********************************************************************/
/* 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, &QmitkSegmentationView::OnVisibilityShortcutActivated);
QShortcut* labelToggleShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_I), parent);
connect(labelToggleShortcut, &QShortcut::activated, this, &QmitkSegmentationView::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, &QmitkSegmentationView::OnReferenceSelectionChanged);
connect(m_Controls->workingNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkSegmentationView::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'");
QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Region Growing 3D' Picking GrowCut");
#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());
m_Controls->toolSelectionBox2D->SetLayoutColumns(3);
connect(m_Controls->toolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected,
this, &QmitkSegmentationView::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->toolSelectionBox3D->SetLayoutColumns(3);
//TODO temporary interpolator deactivation
//m_Controls->slicesInterpolator->SetDataStorage(this->GetDataStorage());
//TODO END temporary interpolator deactivation
// create general signal / slot connections
connect(m_Controls->newSegmentationButton, &QToolButton::clicked, this, &QmitkSegmentationView::OnNewSegmentation);
//TODO temporary interpolator deactivation
// connect(m_Controls->slicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
//TODO END temporary interpolator deactivation
connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::CurrentSelectionChanged, this, &QmitkSegmentationView::OnCurrentLabelSelectionChanged);
connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::GoToLabel, this, &QmitkSegmentationView::OnGoToLabel);
connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::LabelRenameRequested, this, &QmitkSegmentationView::OnLabelRenameRequested);
auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
m_RenderingManagerObserverTag =
mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
m_RenderWindowPart = this->GetRenderWindowPart();
if (nullptr != m_RenderWindowPart)
{
this->RenderWindowPartActivated(m_RenderWindowPart);
}
// Make sure the GUI notices if appropriate data is already present on creation.
// Should be done last, if everything else is configured because it triggers the autoselection of data.
m_Controls->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<QmitkSegmentationView>(this, &QmitkSegmentationView::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<QmitkSegmentationView>(this, &QmitkSegmentationView::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 slimView = prefs->GetBool("slim view", false);
m_Controls->toolSelectionBox2D->SetShowNames(!slimView);
m_Controls->toolSelectionBox3D->SetShowNames(!slimView);
}
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;
//TODO temporary interpolator deactivation
//mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
//mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
//TODO END temporary interpolator deactivation
}
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());
auto activeLayer = labelSetImage->GetActiveLayer();
numberOfLabels = labelSetImage->GetNumberOfLabels(activeLayer);
//TODO temporary interpolator deactivation
//if (numberOfLabels > 1)
// m_Controls->slicesInterpolator->setEnabled(true);
//TODO END temporary interpolator deactivation
m_Controls->multiLabelWidget->SetMultiLabelSegmentation(dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData()));
}
toolSelectionBoxesEnabled &= numberOfLabels > 1;
// 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/QmitkSegmentationViewControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui
index 5e8b999201..54eae24ca6 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui
@@ -1,312 +1,312 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkSegmentationViewControls</class>
<widget class="QWidget" name="QmitkSegmentationViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>300</width>
<height>600</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QGroupBox" name="groupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Data selection</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QLabel" name="referenceNodeLabel">
<property name="text">
<string>Selected image</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QmitkSingleNodeSelectionWidget" name="referenceNodeSelector" native="true">
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="workingNodeLabel">
<property name="text">
<string>Selected segmentation</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QmitkSingleNodeSelectionWidget" name="workingNodeSelector" native="true">
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
</widget>
</item>
<item row="1" column="2">
<widget class="QToolButton" name="newSegmentationButton">
<property name="toolTip">
<string>Create a new segmentation</string>
</property>
<property name="text">
<string>...</string>
</property>
<property name="icon">
<iconset>
<normaloff>:/Qmitk/NewSegmentation_48x48.png</normaloff>:/Qmitk/NewSegmentation_48x48.png</iconset>
</property>
<property name="iconSize">
<size>
<width>28</width>
<height>28</height>
</size>
</property>
<property name="autoRaise">
<bool>true</bool>
</property>
</widget>
</item>
<item row="2" column="0" colspan="3">
<widget class="QLabel" name="selectionWarningLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QmitkMultiLabelManager" name="multiLabelWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
<item>
<widget class="QTabWidget" name="tabWidgetSegmentationTools">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="styleSheet">
<string notr="true">QTabWidget::tab-bar { alignment: middle; }</string>
</property>
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab2DTools">
<attribute name="title">
<string>2D tools</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout2D">
<item>
<widget class="QmitkToolGUIArea" name="toolGUIArea2D" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QmitkToolSelectionBox" name="toolSelectionBox2D" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="interpolatorWarningLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string/>
</property>
</widget>
</item>
<item>
<widget class="QmitkSlicesInterpolator" name="slicesInterpolator" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer2D">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab3DTools">
<attribute name="title">
<string>3D tools</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout3D">
<item>
<widget class="QmitkToolGUIArea" name="toolGUIArea3D" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<widget class="QmitkToolSelectionBox" name="toolSelectionBox3D" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>50</weight>
<bold>false</bold>
</font>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer3D">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QmitkSingleNodeSelectionWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkSingleNodeSelectionWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkToolSelectionBox</class>
<extends>QWidget</extends>
<header location="global">QmitkToolSelectionBox.h</header>
</customwidget>
<customwidget>
<class>QmitkToolGUIArea</class>
<extends>QWidget</extends>
<header location="global">QmitkToolGUIArea.h</header>
</customwidget>
<customwidget>
<class>QmitkSlicesInterpolator</class>
<extends>QWidget</extends>
<header location="global">QmitkSlicesInterpolator.h</header>
</customwidget>
<customwidget>
<class>QmitkMultiLabelManager</class>
<extends>QWidget</extends>
- <header>QmitkMultilabelManager.h</header>
+ <header>QmitkMultiLabelManager.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources>
<include location="../../resources/segmentation.qrc"/>
</resources>
<connections/>
</ui>